the maw is open

maw begins from a simple observation: buying and selling have never been the same operation.

markets spend an extraordinary amount of effort pretending otherwise. an order book attempts to balance one side against the other. an automated market maker adjusts reserves until the price appears fair again. arbitrage moves between venues searching for differences that should not exist, while liquidity providers rent out inventory in exchange for accepting those differences on everyone else's behalf. by the time a participant arrives, the machinery responsible for producing a price is already larger than the transaction itself. most of the market exists only to preserve the appearance that both directions are interchangeable. maw removes that machinery instead of improving it.

there is no liquidity pool holding paired assets, no external inventory waiting to be borrowed, and no market maker standing between buyers and sellers. the exchange is reduced until only the movement of capital remains.

the program owns a single vault. SOL enters it when new supply is created and leaves it when existing supply is destroyed. every state the market will ever occupy is derived from those two movements alone. if the vault grows, it is because someone committed capital. if the vault contracts, it is because someone chose to redeem. nothing inside the system can move value for any other reason. supply is not distributed, emitted, or unlocked over time. it only exists because capital entered the vault first. when supply disappears, it does so by returning along the opposite direction. the vault does not speculate, rebalance, or optimize itself. it simply records the cumulative consequence of every transaction that has ever passed through the program.

most protocols discover their spread after deployment. it emerges from changing liquidity, imperfect routing, volatility, competition between venues, or the incentives of whichever participants happen to be active that day. the spread is treated as an environmental condition rather than a property of the market itself. maw rejects that distinction. the difference between entering and leaving is established before the first transaction is ever executed. it does not widen during uncertainty or narrow during periods of confidence. it is not negotiated between participants because there is nothing available to negotiate. the geometry already exists. every transaction encounters the same opening because the shape of the system is fixed before anyone interacts with it.

that geometry is where the project takes its name. a bear trap is not defined by the instant it closes. by then the mechanism has already completed its important work. the position of the jaws, the distance between them, and the force stored beneath the plate were all determined before anything disturbed it. closing is only the visible consequence of decisions that have already been made. maw follows the same principle. the contract does not observe the market before deciding how it should behave, nor does it adapt itself as conditions change. every participant encounters the same structure because the structure was fixed before deployment. the market does not become asymmetric after someone trades. the trade merely reveals an asymmetry that was already present.

nothing inside the program attempts to determine what the asset is worth. there is no oracle supplying external prices, no administrator adjusting parameters, and no mechanism searching for equilibrium beyond the state already contained inside the vault. the contract asks only where supply currently exists and applies the arithmetic attached to that position. once the current state is known, every quote follows directly from the same equations that existed when the binary was built. the program contains arithmetic rather than judgment. it never decides whether a price is fair, whether conditions have changed, or whether intervention has become necessary. it simply advances from one state to the next according to rules that cannot distinguish one participant from another.

buying and selling are governed by two independent linear pricing functions. they begin from the same origin, but they are not mathematical inverses of one another. purchasing new supply advances along the buy curve, while redemption follows a separate sell curve with a different slope. the contract never attempts to reconcile the two paths because they represent different operations acting on the same market. creation and redemption share a state, not a price.

the distance between those curves is permanent. it is established when the program is compiled and does not depend on trading activity, volatility, or liquidity conditions. there is no fee added to a transaction, no percentage deducted after execution, and no treasury receiving a portion of every trade. the retained value exists entirely because the issuance and redemption functions are intentionally separated. the spread is a property of the geometry itself rather than an additional layer of accounting.

every quote is produced by identifying the current supply and evaluating the appropriate curve for the requested direction. buying always references the issuance function. selling always references the redemption function. the vault receives the difference automatically because both curves describe the same market from different directions. nothing inside the program decides how much to retain after a transaction has occurred. the arithmetic already made that decision before the transaction began.

the sell curve's slope is bounded relative to the buy curve's slope at deploy. the bound is enforced by a compile-time assertion — if the constants ever permit the vault to owe out more SOL than it can hold, the program does not build.

const_assert!(SELL_SLOPE <= BUY_SLOPE);
checked at compile time, not at runtime. there is no path where the invariant is evaluated late and found wanting.

the vault cannot be underwater. not because someone is watching it — because the binary that could be underwater was never produced.

mint and freeze authority are held only by the program's own PDA. no wallet holds them. no wallet ever held them.

upgrade authority is burned after deploy. the code that is live is the code that stays live.

there is no pause function. no team allocation. no treasury. no operator, no multisig, no discretionary anything. there is nobody to ask for a favor and nobody to blame for refusing.

honest about both ends. the curve has two, and neither is dramatic.

supply → 0. the last seller sells into the lowest point of the sell curve. the vault retains the accumulated spread. price does not go to zero — the curve does not extend below its origin, so the final redemption is small, finite, and exactly what the math said it would be. the vault does not empty. it just stops being asked for anything.

supply → cap. minting halts at the cap. buy() returns an error; it does not silently succeed at a worse price. sell() continues to work, unchanged, all the way back down. the top is a wall, not a cliff.

both ends are reachable. both ends are boring. that is the design.