A trade lands
Any buy or sell on a Glue market routes through the Stick Engine before it touches the pool. There is no path around it.
The stick engine
Every trade thickens the floor.
The Stick Engine sits under each market. Here is exactly what happens the moment a trade lands — three steps, no discretion, no multisig in the middle.
A slice is glued
A fixed slice of that trade is taken out and set aside. The rate is written on-chain at launch and capped by the contract.
Minted, then burned
The slice is paired and minted into liquidity — and the LP tokens are sent to the burn address. Nobody holds them. Nobody can pull them.
Floor simulator
Watch the floor climb.
Move the sliders. Every trade takes its slice, the slice becomes liquidity, and the liquidity is burned into the floor. The line has no way down.
Volume—
Glued & burned—
An illustrative model, not a projection. It is arithmetic on the inputs you pick — no market data, no promises about price.
GLUED LIQUIDITY—
GLUE MARKET
ORDINARY POOL — NOTHING GLUED
Sealed by the contract
You can't rug what's glued down.
Every exit path is closed in code, not in a promise. These are contract properties, verifiable on-chain once deployed.
No withdraw path
There is no function that removes glued liquidity. Not for the deployer, not for governance, not for anyone.
No mint()
Supply is fixed at deploy. The token contract has no mint function to call.
No owner switch
Stick rate bounds are set at launch inside contract-enforced limits. Nobody raises them later.
Compare
Three ways to hold a floor.
Most launches either trust the deployer or trust a clock. Glue removes the withdrawal function instead of scheduling it.
| Property | Standard LP | Timelocked LP | Glue market |
|---|---|---|---|
| Who can pull liquidity | Deployer, any time | Deployer, after unlock | Nobody, ever |
| Floor over time | Can go to zero | Flat, then a cliff | Monotonically up |
| Depends on a promise | Yes | Yes, until unlock | No |
| Grows with volume | No | No | Yes |
| Unlock date to watch | None | Yes | None — nothing unlocks |
| Verifiable on-chain | Partially | Yes | Yes |
Launch a market
Four steps, then it's out of your hands.
That last part is the point. Once the market is live, the deployer has no more power over the liquidity than anyone else.
Configure
Pick the token, the pair and the stick rate — inside the caps the contract enforces.
Deploy
The factory deploys the token and its Stick Engine together, wired in one transaction.
Seed
Seed the opening pool. From this block on, every trade adds to it automatically.
Let go
There is no admin key to hand over, because there was never a withdraw function to guard.
Token
$GLUE, read straight off the contract.
Nothing here is a projection. Every line below is either a constant in the source or a status we're honest about.
Total supply1,000,000,000 $GLUE
Supply typeFixed — no mint()
Decimals18
StandardERC-20 (OpenZeppelin v5)
ChainRobinhood Chain
Contract address0xd40c704776434b4aa9fba0dbc21083c3adaaa313
StatusDeployed
What $GLUE steers
Governance over the stick rate, inside hard caps.
Holders steer stick-rate bounds, a share of protocol fees, and boosted stick on partnered markets. The caps themselves are contract constants — governance moves the dial inside them, never past them.
There is no treasury unlock schedule to publish yet, and we'd rather leave this blank than invent one.
0xd40c704776434b4aa9fba0dbc21083c3adaaa313
Where things actually stand
Status, without the theatre.
No fake counters, no "$0 TVL" dressed up as traction. This is the real state of the protocol today.
Identity and siteDone
Mark, palette and this page. The brand is settled.
Contracts deployedDone
$GLUE is live on Robinhood Chain. The address is on this page — verify it before you sign.
Audit and public testnetIn progress
Third-party review of the burn path and the stick-rate caps, then an open testnet market anyone can trade against.
Mainnet and the factoryAfter that
$GLUE launches on its own engine, then the factory opens so anyone can launch a market on it.
FAQ
The questions worth asking.
If liquidity only goes up, where does sell pressure go?
Into the pool, like anywhere else. Glue doesn't stop the price falling — it stops the liquidity falling. A sell still moves the price; it just also thickens the book it moved through. Anyone telling you a mechanism prevents drawdowns is selling something.
Doesn't the stick rate just make trading more expensive?
Yes. A slice of every trade is exactly that — a cost, paid by the trader, in exchange for a market that can't be pulled out from under them. The rate is capped in the contract precisely so it can't be raised into something predatory later.
What stops the team raising the stick rate?
The caps are contract constants, not parameters. Governance can move the dial inside the range that was compiled in; it cannot move the range. There is no admin function that rewrites it.
Burned LP tokens — burned to what address?
The standard burn address, with no known private key. The tokens are gone in the same sense any burn is gone. Once deployed, that transfer is visible on every trade in the explorer.
Is it live?
Yes. $GLUE is deployed on Robinhood Chain at
0xd40c704776434b4aa9fba0dbc21083c3adaaa313.
Check that string against this page before you sign anything — it is the only address
we publish.
Which chain, exactly?
Robinhood Chain — a USDG-native Arbitrum Orbit L2, chain id 4663, EVM equivalent. Glue needs nothing exotic from it: the Stick Engine is ordinary EVM bytecode. Take the RPC endpoint from the chain's own documentation, not from a project page.
Invariants
Six things that stay true at every stick rate.
Properties of how a Glue market is built — including the inconvenient ones. If any of these stops being true, the market isn't a Glue market.
Glued liquidity never decreases
No function subtracts from it. It is add-only, block after block.
LP tokens go to the burn address
Not to a timelock, not to a multisig, not to a treasury. Burned.
Supply is fixed at deploy
No mint function exists, so no supply event can be scheduled later.
The stick rate has a hard ceiling
The cap is a contract constant. Governance moves inside it, never past it.
Price can still fall
Glue holds the liquidity, not the price. A sell still moves the market.
Traders pay for it
The slice is a real cost on every trade. That is the trade-off, stated plainly.
Settlement
Glue settles on Robinhood Chain.
Glue markets run on the USDG-native L2, an Arbitrum Orbit rollup, chain id 4663, fully EVM. No custom opcodes and no bridge assumptions — a Glue market is ordinary ERC-20 machinery on ordinary L2 rails.
- ✓ Burned LP tokens, so the floor is math and not a promise
- ✓ Stick rate written on-chain at launch, capped by the contract
- ✓ No withdraw function to guard, so no admin key to hand over
USDG
Native gas and unit
Orbit
Arbitrum L2 rollup
4663
Chain id
EVM
Markets + engine, no custom opcodes
Network nameRobinhood Chain
Chain ID4663
Currency symbolUSDG
Decimals18
TypeArbitrum Orbit L2 · EVM equivalent
Adding the network
Chain id 4663, USDG as the native unit. Take the RPC endpoint from Robinhood Chain's own
documentation rather than from any project page — ours included. A wallet pointed at
someone else's RPC is a wallet someone else can watch.