weaveone coin on two chains, launched the same second, held to one market cap by the shuttle
solrhlivenot configured
sol caprh captensionbandloom

the shuttle

weave is one coin in two places. the same name, the same supply on each side, launched in the same second on pump.fun and on pons. the problem with a coin in two places is that the two places drift. one side gets bought, the other does not, and within an hour there are two prices and two market caps for what is supposed to be one thing. the shuttle is the answer to that. it is a reserve on each side and a rule for spending it, and the rule is simple: sell where it is high, buy where it is low, until the two caps meet.

the two curves

each side starts life on a bonding curve. the sol side on pump.fun and the rh side on pons both price the token against a constant product of two reserves: the tokens still on the curve, and the native asset paid in so far. price on a side is the native reserve divided by the token reserve. market cap on a side is that price, times the side's supply, times the native asset's dollar price. when a side graduates from its curve into a pool, the same math applies to the pool's reserves.

symbols
symbolmeaning
xtokens in the curve or pool on a side
ynative asset in the curve or pool on that side
kx times y, constant across a trade with no fee
pprice on that side in native per token, y over x
Ssupply on that side
udollar price of that side's native asset
capS times p times u
mthe mean of the two caps
p*target price on a side, m over S times u

the tension

tension is the gap between the two caps as a fraction of their mean, in basis points. positive tension means the rh side is higher. negative means the sol side is higher. the band is the amount of tension the shuttle tolerates. inside the band the shuttle rests. the band exists because every trade on a curve moves the price, and chasing a gap smaller than the movement a pick causes would only make noise.

tension_bps = round( (cap_rh - cap_sol) / ((cap_rh + cap_sol) / 2) * 10000 ) due = |tension_bps| > band_bps on two consecutive reads

sizing a pick

a pick is sized so that each side lands on the mean. the loom does not guess an amount and check afterward. it reads the reserves on each side and solves for the trade.

on the high side the bobbin sells tokens into that side's curve. selling adds tokens to x and removes native from y. after the sell the price must equal p*, so the new token reserve is the square root of k over p*. the amount sold is that new reserve minus the old one.

on the low side the bobbin spends native to buy tokens from that side's curve. buying adds native to y and removes tokens from x. after the buy the price must equal p*, so the new native reserve is the square root of k times p*. the amount spent is that new reserve minus the old one.

high side, sell: x' = sqrt(k / p*) sell_tokens = x' - x proceeds_native = y - k / x' low side, buy: y' = sqrt(k * p*) spend_native = y' - y bought_tokens = x - k / y' caps: sell_tokens <= bobbin_tokens_high * pick_max_bps / 10000 spend_native <= bobbin_native_low if either cap binds, both legs are scaled by the same ratio so the pick stays symmetric

why the mean

the shuttle pushes both sides to the mean instead of pushing one side to match the other because it costs half as much. moving one cap all the way to the other means one large trade on one curve, and the price impact of a trade on a constant product curve grows with the square of its size. two trades of half the size, one on each curve, move each price half as far and pay a quarter of the impact each. the mean is also the only target that treats both sides the same, which is the point of the whole thing.

where the bobbins came from

each bobbin was funded from its own launch and only from its own launch. when the sol side was created, a fixed share of the supply was sent to the sol bobbin as tokens, and a fixed share of the native raised on the curve was sent to it as sol. the rh side did the same with its supply and its eth. the share is the same on both sides and is shown on the landing page as bobbin share. nothing was bridged to seed a bobbin, so neither side started with an advantage.

the loom

the loom is the process that watches and acts. it subscribes to new blocks on both chains and reads both curves on every block. it keeps a running tension and a count of consecutive reads outside the band. when the count reaches two and the cooldown has passed, it builds both legs of a pick, signs them with the loom wallet on each chain, sends both, waits for both to confirm, reads both curves again, and records the pick with the tension before and after and both transaction hashes. if one leg fails, the other is not sent, and the attempt is recorded as a pick with the note one leg failed and no hashes. the loom's wallets are listed on the verify page.

settlement

over time the two bobbins' native balances drift apart, because picks sell on one chain and buy on the other. the loom does not bridge on every pick. it bridges the net difference in batches when the difference crosses a fixed share of the smaller balance, and records each batch as a pick with the note bridge and one transaction hash per chain. the bobbin tokens never move across chains. the two token supplies are separate and stay separate.

the pick in pictures

SOL CHAINRH CHAINread curveread curvetension outtension outbuild sellbuild buysend and confirmsend and confirmread againread againrecordrecordBOTH LEGS, OR NEITHER
nowafter picknowafter pickTOKENS IN CURVETOKENS IN CURVENATIVE IN CURVENATIVE IN CURVEsell moves right and downbuy moves left and up
DISCRIMINATORAUTHORITYMINTNATIVE VAULTBAND_BPSPICK_MAX_BPSCOOLDOWN_S
layout of the shuttle state account on solana, 128 bytes shown, picks counter and last pick slot follow

the numbers as configured

keyvalue
band
pick cap
cooldown
bobbin share
launched

what can go wrong

a price index can lag. the site shows the source and the age of every read so a stale number is visible as stale.

a chain can stall. if one chain stops producing blocks the loom stops picking, because a pick needs both legs.

a bobbin can run dry. the bobbins panel shows how much of each is left, and when one is empty the shuttle can only act in one direction on that side.

the band can be too tight. if picks fire and the tension does not settle, the band is narrower than the impact of a pick, and the loom widens the band by half and records the change as a pick with the note band widened.

glossary

termmeaning
weavethe coin, and the project.
the sol sidethe pump.fun token on Solana.
the rh sidethe pons token on Robinhood Chain.
the shuttlethe mechanism that holds both market caps level. It sells on whichever side is higher and buys on whichever side is lower.
a pickone action by the shuttle. One pick is one sell on the high side and one buy on the low side, recorded as a pair of transactions.
the bobbinthe reserve held on each side that the shuttle trades from. There is a sol bobbin and an rh bobbin.
the tensionthe current spread between the two market caps, in basis points.
the bandthe amount of tension the shuttle allows before it picks.
the loomthe keeper process that reads both sides every block and fires picks.
the cloththe history of readings, every fifteen seconds, both sides and the tension between them.
levelthe state where the tension is inside the band.