The Alberta Buck -- The BasketWheel (prototype)

Read every figure below as "in a simulated economy", not as a forecast. The contract surface is in the Ethereum implementation; the design record, with every ruling and measurement, is in doc/ (BASKET-EQUITY.org, BASKET-WHEEL.org, BASKET-REBALANCE.md).

The basket is shares of equity, one lien, and a wallet.

    gross(mark)   =  sum over pools ( 2 L_i sqrt(P_i)  +  idle TOKEN_i x P_i )
    equity(mark)  =  gross(mark)  +  signedBalance(basket)  +  reliefAccrued(basket)
    share price   =  equity / shares

2 L sqrt(P) is a full-range position's fair value at a price. It is computed from the pool's liquidity and a price, never from token balances, so tokens sent to a pool cannot inflate it. There are three marks: the TWAP, HIGH (each pool at the higher of spot and TWAP) and LOW (the lower). A deposit is valued at LOW against a basket at HIGH; an exit at LOW. Each side pays a charge the size of the swap the wheel will make for it: (1 - K)/2 of the pool fee for TOKEN in, (1 + K)/2 of the dearest pool's fee for BUCK in or out. Nobody can enter or leave at a price that moves value between the holders.

The credit. The basket is an ordinary BUCK account holding one self-issued marked credit, marked before anything that spends at equity(LOW) – the depositors' equity, and nothing else. Buck therefore enforces

    lien(basket)  <=  K x equity(LOW)

on every draw. The basket never mints or burns: it spends past its held BUCK, which draws on the credit, and BUCK it receives repays the lien. The lien earns Jubilee relief like any other. A cut in K changes no lien; an under-water account simply cannot draw. There are no margin calls: the excess is repaid only by the wheel's paced Trim.

Exits. The treasury takes 25% of a receipt's gain over its cost basis, as shares, and nothing of a loss. The rest is paid in BUCK when Buck lets the basket spend it. Otherwise it is paid in kind: the exit's fraction f of every position and of the idle TOKEN, by transfer, its share of the lien repaid from the BUCK its positions return. No swap is forced on anyone.

The wallet absorbs the flows. Its target liquidity is the larger of 1% of the gross and a flow-sized amount – enough that half of it covers two standard deviations of the daily net flow times 1 + K – capped at 20% of the gross. Deposits and exits net against each other inside it, and an ordinary exit touches no pool.

A constant-mix portfolio earns more than the weighted average of its parts: stochastic portfolio theory calls the difference the excess growth rate (Fernholz, 2002),

    gamma*  =  1/2 ( sum_i w_i sigma_i^2  -  sigma_p^2 )

– half the gap between the parts' average variance and the portfolio's own. It is the rebalancing premium, and for a pool half TOKEN and half BUCK it is sigma^2 / 8 of the position per unit time.

A full-range position is a constant-mix rebalancer that trades at stale prices. It sells TOKEN as the price rises and buys as it falls, but at its own price, which trails the market. Whoever moves it to the market price keeps the difference: the loss-versus-rebalancing of Milionis, Moallemi, Roughgarden and Zhang (2022),

    LVR  ~  V x sigma^2 / 8     per unit time, before fees

– the same number. So the harvest goes to the arbitrageur, and the pool keeps the fees on the arbitrageur's volume. For one pool reverting with a 20-day half-life at 1.5% a day, the premium is 1.0% a year of the position:

The finer the trading against the fee, the more the fee recovers by itself; the coarser, the more only the basket's own arbitrage can.

A pool cannot harvest slow swings at all. A constant-mix rebalancer earns the variance of short-horizon moves – the quadratic variation. A smooth cycle has almost none, however large its amplitude. A swing is harvested only by trades timed across pools: selling one leg near its top, buying another near its bottom.

So a basket's excess return over holding its commodities has three sources, each with its own harvester:

Beneath all three are the tolls: the fees on the basket's own pools, which the Sync step collects.

Three pools quote each constituent:

                 TOKEN_i
                /       \
      TOKEN/USDC         TOKEN/BUCK    (the basket's own pool)
              /           \
          USDC ----------- BUCK
                BUCK/USDC

If the three prices agree, going round the triangle returns what went in, less the fees. If they disagree, one direction returns more. Going round that way, by the right amount, closes the gap and keeps the difference.

    out(x)  =  g Y x / (X + g x)  =  r x / (1 + k x),     r = g Y / X,   k = g / X

    r  =  r1 r2 r3
    k  =  k1 + k2 r1 + k3 r1 r2
    cycle(x)  =  r x / (1 + k x)

    x*  =  (sqrt(r) - 1) / k          profit*  =  (sqrt(r) - 1)^2 / k

A Uniswap tick is a log price, so the basket's pools hand it log prices for free. Write c_i for constituent i's log price in BUCK, and split the vector the way a three-phase machine splits its line voltages – into a common mode, which carries no torque, and differential modes, which carry all of it:

    differential:  c_i - mean(c)        which commodity is rich against which
    common:        log(basket in BUCK)  what the whole basket costs, against par

The differential mode is numeraire-free: anything common to every leg, including BUCK's own wobble against the dollar, cancels exactly. It is the director's signal. The common mode is the K controller's process variable, and it is the desk's signal. Both are kept as ladders of exponential moving averages over geometrically spaced windows; the difference of two adjacent EMAs is a band-pass filter, so a ladder is an octave filter bank, each rung seeing swings of its own size.

Why there are tides. New money does not reach all prices at once (Cantillon, 1755). Correlating each constituent's year-over-year growth with the M2 money supply, lags swept from 0 to 36 months:

Monetary assets move first, energy and construction next, labour and food last. When M2 surges the fast legs overshoot their share and stay overweight until the slow ones catch up – roughly a year. Those excursions are the director's harvest.

Wait for the turn. A rebalancer that reacts to the instantaneous deviation sells a riser all the way up, paying fees and bleeding against the trend. One that waits until the excursion levels off makes fewer, larger trades at the greatest mispricing. Measured on a portfolio of held tokens over twenty synthetic years (30 bp a leg), gated policies collected 75-90% of continuous rebalancing's premium on 30-55% of its turnover, trading at twice the mispricing depth; through the 2020-25 history, where bitcoin ran nine-fold and never reverted, they bled 90-130 bp a year less than continuous rebalancing. Across a filter bank, with each rung voting, a gated policy beat continuous rebalancing's gross premium outright (+496 against +430 bp a year): multiple scales recover the mid-size swings a single window concedes.

The equity director. EquityTurnDirector (optional) samples each pool's TWAP tick once a day, takes it against the basket's mean, and keeps for each leg a ladder of EMAs of that deviation:

• The lean. Each declared weight is scaled by exp(-tilt x excursion) and the weights renormalized, the excursion being the leg's deviation against a long anchor EMA (1280 days). A leg rich against its own past is leaned down. tilt defaults to 1.
• The turn. Six shorter EMAs, 5 to 160 days, each vote when moving back toward the anchor. A quorum (default 4 of 6) is a turn. No rung can fire alone, which is what makes the fast ones safe to include. A leg not turned is still running, and a run is let run: the director never trims a leg still rising or buys one still falling.
• The leash. A leg more than 30% off its declared weight trades regardless of the turn. The lean times the mandate; the leash enforces it. (Today a deposit waiting to be placed still defers it: see the open questions.)

The Fund step buys the director's pick and the Trim step sells it. Proceeds wait in the wallet between a sale and the buy that is due, so the director never has to catch a falling knife to stay invested. Its outputs are hints, not authority: it holds no funds, and every step it steers marks the credit first and trades at most 1% of a pool's depth. A stale or adversarial director can mis-time trades within those bounds; it cannot move value out of the basket.

On pools, the value is in the lean. The gated-portfolio numbers above are for held tokens. In the basket the pools already do the continuous part, so on synthetic worlds (below) the gate alone adds little – a pool's weight moves only half its price move, and the pool already sells into every run. The lean adds the most, and the gate becomes the regime knob:

In momentum cycles the gate is what makes the lean pay; in memoryless reversion it costs, by trading late; in a walk every setting is noise. The longer the anchor, the better the lean (320 days: +1.1%; 1280 days: +1.6%; all but fixed: +1.9%, at tilt 1 in the cycle world). An anchor's risk is a permanent repricing, which the leash bounds. Timing beats volume: every setting that bought more gross harvest with more turnover lost it again in a trend.

BUCK_K is sound and slow. It reaches the economy only through credit limits, and a credit book turns over in months; an attacker with real money can push BUCK off parity in days. The desk is the fast actuator: K sets the standing policy, the desk runs the operations – the division a central bank makes between its policy rate and its open-market desk.

                   BUCK CHEAP                    BUCK DEAR
                   (basket costs more BUCK)      (basket costs less BUCK)

  REVERTING     Q1 ABSORB: buy BUCK, hold     Q3 SUPPLY: sell held BUCK
                   supply unchanged              supply unchanged

  PERSISTENT    Q2 RETIRE: buy BUCK back      Q4 ISSUE: draw BUCK and
  (past the        against its own issue         sell it for TOKEN
  leash N days)    supply falls                  supply rises

Someone has to notice the work and send the transaction. The basket does not wait for a keeper paid by the hour: its work runs on a work wheel, a bounded state machine any caller advances with tick(maxWork, maxScan), which does each block's work once however many callers there are.

• Slots over task kinds. Each kind of work owns a range of slots, and a cursor walks them round robin. The equity basket's components are 2N + 3 slots: Daily (the flow estimate, the relief, the director's sample), Sync and Deploy for each of N pools, Fund and Trim. The consistency cycles are one slot per triangle. The controller's compute, the director's refresh and the desk's operation are kinds too. Kinds are Solidity mixins over a common chassis, so a wheel is assembled from the kinds it wants, and a kind with no target has no slots. One engine, BasketWheel, is instantiated per machine: the basket's wheel carries the basket's kinds, the desk's carries only the desk's.
• Each step is small. Every component step marks the credit first, and trades at most 1% of a pool's depth, so the outside arbitrage re-pins between steps and no step moves a price far.
• Amortizing the scan. Deciding whether an arbitrage slot is due costs three cold pool reads, about 14,000 gas. A call examines at most maxScan slots, the cursor moves past every slot examined, and the block is marked idle only once consecutive calls have found every slot not due. After that a further call is a storage read and a return. Any trade that touches the basket re-arms it.
• A clock per chain. The wheel keys its work to the chain's own block number; where that is not the chain's own (Arbitrum reports the L1's), a small adapter supplies the right one.

Folded into a transaction a caller sends anyway, a tick whose block is done costs a few thousand gas. A working tick costs what its work costs: about 365,000 gas for a cycle.

Time without a scheduler. Moving averages advance with time, and the EVM has no clock that runs unasked. The answer is the pattern behind Compound's accrueInterest and Maker's drip: advance state on first touch, as a closed function of elapsed time. Under sample-and-hold, n missed epochs of an EMA with decay q collapse exactly,

    m'  =  x + (m - x) q^n

in O(log n) by binary exponentiation (with a matching closed form for its velocity), so a poke after a quiet month costs the same as one after a busy hour and lands where n diligent pokes would have. Work is conserved: triggering more often trades per-call gas against staleness, never total cost. Both directors do this.

Synthetic worlds (alberta_buck/sim/basket_harvest.py): independent TOKENs at about 1.5% a day in three regimes – fast reversion (a 10-day half-life), slow damped cycles with momentum, and a random walk as the control – with an outside arbitrageur re-pinning every pool each step. Eight seeds over four years; a year's return over simply holding the starting commodities ("pools alone" is the basket with no arbitrage of its own):

The basket's arbitrage recaptures what the outsiders took, to the basis point. Costless, perfect rebalancing at the market price would have earned 2.6% in the fast world: pools alone keep about a quarter of it, and the arbitrage lifts that to about two thirds. With realistic flows – two arrivals a day, sixty-day holds – a long-term holder earned about 3% a year, because deposits and exits net inside the wallet and an exit touches no pool.

The desk, modelled (alberta_buck/sim/monetary_ops.py): the pools abstracted to one price with constant-product impact, reverting on a 120-day timescale; an attacker sells 6M BUCK over 20 days, holds 60, then buys back to retire the credit that funded it; 30 bp a leg; nine seeds.

The excursion is damped every time; the desk is paid for absorbing it where the move is not real, and loses where it is. Each attacker was worse off in nine seeds of nine. That the same machinery loses to a real move is the property that makes the rest trustworthy.

A simulated economy (alberta_buck/sim/): the real contracts on an in-process EVM, six commodity TOKENs on their 2020-2025 price histories, the controller, depositors, savers, debtors and a cast of arbitrageurs. These runs predate the equity basket: the cycles and the desk ran on the pro-rata basket it replaced.

• The cycles captured 2-3% of the basket's value a year in the first calm months, and about 1.3% a year over two years; their calls paid for themselves even at 5-gwei L1 gas. About half came from gaps the outside arbitrageurs would have closed.
• The gauge became truer: the basket's value in BUCK, against its value at the commodities' reference prices, erred a third less at the median and 43% less at the 90th percentile.
• Through two years of shocks – demand and supply at one and four times a whale's budget, slow grinds, cohorts of debtors, a book-loading attack, a liquidity exit – nothing broke, the gauge was truer on every run, and the wheel transmitted shocks without amplifying them: BUCK's dollar price swung less, while the basket's pools, which now followed the market, took part of each dislocation and were paid for it.
• The contract desk cut the peak deviation in both seeds tried (1143 -> 768 bp, 1083 -> 914 bp) and the mean in both. An earlier desk run from outside the basket, as an ordinary agent, had cut the peak by a third on one seed – and made it worse on the next two. What replicated was narrower: the mean deviation fell every time. A peak-damping figure from one seed is noise.

Two cautions. The simulated arbitrageurs demand a 60-basis-point edge over the fees, so they leave wider gaps than competitive searchers would; against a real market the wheel's take will be smaller. And the two-year experiments are being rerun on the equity basket and the corrected Jubilee accounting now.

1. A competitive market. How much remains when real searchers compete the large gaps down to gas, whether thinning their participation widens the gaps beyond the wheel's reach, and which of a v4 hook or an auction for the right to go first should take the gaps v3 must race for.
2. Leverage through a K cut. Drawing the full K on each deposit keeps the basket more levered through a cut (a lien of 0.92 of equity at the stress peak, against 0.80), with returns within noise. The paced Trim is the only repayment, by design; whether its pace is right is open.
3. Depositors as shock absorbers. Pools that follow the market carry BUCK's moves into the depositors' positions. They were paid for transient shocks; under a persistent increase in supply their realized profit on the calm runs fell to nothing. Whether the wheel or the cast did that is not yet separated.
4. A residual oscillation. With the agents' decisions randomized, BUCK's dollar price is white noise day to day, but the basket's value and K still reverse direction more often than noise would (about 75% of days against 67%). Some loop still overshoots; it predates the equity basket.
5. The desk and K. Whether a successful desk starves K of the error it needs, and whether the controller should then read the undamped error or feed the desk's achieved action back to its integrator as anti-windup. The bounds and the founding grant are not converged; they are the sweep that answers it. A patient attacker, bleeding in over months, is untested; so is the desk and the director competing for the same pool depth.
6. The desk's reach. It retires only what it has issued. Opening with a standing book – part of its line drawn and sold, which funds Q1 and gives Q2 something to retire – is the remedy an earlier desk used. doc/DESK-LP-RESERVE.org sketches a reserve held as basket shares, pledged.
7. Rebalancing under continuous deposits. The wheel's Fund and Trim wait for a settled wallet – no deposit waiting to be placed – which a growing basket seldom has; in the savings world they never ran in 45 days while legs drifted to twice their declared weight. Gating by what actually conflicts, letting the leash through, and placing deposits toward the targets are the candidates (doc/BASKET-EQUITY.org, section 14).
8. The director's bands. The 30% leash is hand-set. Two refinements with firm theory: under proportional costs the optimal policy is a no-trade region, trading only to its boundary (Davis and Norman, 1990); and for a reverting spread the optimal thresholds are known in closed form from its reversion rate and volatility (Bertram, 2010).
9. The wheel's parameters: the share s, kappa, where the callers' reserve is funded from, and capping every leg of a cycle (v1 caps only the first).
10. Depth. A thin BUCK/USDC pool caps every cycle. The basket owns no BUCK/USDC position, and should not; who provides that depth is a question for any deployment.

• The callbacks and the credits. The swap callback must accept only the pool it expects, only inside its own cycle; the cycle entry only from the wheel itself; the basket's credit entry points only from its wheel. The contracts do all three and test them, unaudited.
• A farmable reserve. The share s cannot be farmed: pushing a pool costs more than closing the gap returns. kappa per working tick is not tied to the work's size, so a large reserve might reward many small, cheaply opened gaps. The minimum edge, the reserve's cap and a pay bounded by the work's value are the defences to test.
• Displacing the arbitrageurs. If external arbitrageurs thin out, the gaps beyond the wheel's reach may close more slowly.
• Gas on an L1. A working tick is expensive; on an L1 only large gaps pay, and those are the ones searchers race for. The case is strongest on rollups.
• Liveness. No calls, no harvest, and new deposits wait in the wallet. Nothing already placed is at risk, and exits are paid from the wallet or in kind.
• A desk that looks healthy. Every runaway above showed a profit while it ran. Watch the desk's inventory beside its P&L, always: a desk that damps a deviation by holding a position it could never unwind has moved the loss, not removed it.
• A trending market. None of this changes the basket's exposure. In a secular trend a constant-mix basket still trails a buy-and-hold of the runaway; the director's leash and the admission rule are the only defences (the asset that never comes back).

The first BuckBasket assumed that the world's arbitrageurs keep it honest and pay it to be kept. The first half is true. The second is only partly true, because the price of keeping a pool honest is paid by the pool. The equity basket brings that work home: it closes its own gaps with cycles that need no capital and cannot lose, waits for the tides its pools cannot feel to turn, and lets a desk with its own books steady BUCK in days while K does the slow work of months. Anyone who finds it worth their gas turns the wheels. If the early readings survive a competitive market and an audit, the savings basket earns a little more – and its valuation tells the controller the truth a little sooner.

• 1. Milionis, C. C. Moallemi, T. Roughgarden, A. L. Zhang, /Automated Market Making and

  Loss-Versus-Rebalancing/, 2022.

• 1. Adams, C. C. Moallemi, S. Reynolds, D. Robinson, /am-AMM: An Auction-Managed Automated Market

  Maker/, 2024.

• 1. 1. Fernholz, Stochastic Portfolio Theory, Springer, 2002.
• 1. 1. 1. Davis, A. R. Norman, Portfolio Selection with Transaction Costs, Mathematics of

  Operations Research, 1990.

• 1. 1. Bertram, Analytic Solutions for Optimal Statistical Arbitrage Trading, Physica A, 2010.
• 1. Cantillon, Essai sur la Nature du Commerce en General, 1755.
• Uniswap Labs, Uniswap v3 Core (2021): the pay-first swap callback; and Uniswap v4's hooks.
• The design record: doc/BASKET-EQUITY.org (the equity basket's rulings and the harvest study), doc/BASKET-WHEEL.org (the wheel and its measurements), doc/BASKET-REBALANCE.md (the gated policies and the M2 lags), doc/CONVERGENCE.org (the experiments), src/basket/, src/wheel/ and alberta_buck/sim/ (including monetary_ops.py, the desk's model).