Two ways out: instant unstake and tickets

Native stake takes at least one epoch to deactivate, so any liquid staking protocol has to decide how to give people SOL back. Oblio offers two paths, and both are enforced by the program rather than by an operator.

Instant unstake

The pool keeps a reserve of liquid SOL, targeted as a percentage of total assets. An instant exit burns your shares and pays from that reserve immediately, minus a fee. The fee depends on how much of the reserve the trade uses: at or above target it sits at a floor, and it climbs along a curve up to a ceiling as the reserve is drawn down. The curve exponent is configurable.

The fee is the integral of the curve over the reserve the trade consumes, not the curve evaluated at one point. That means draining the reserve in one large trade costs the same as draining it in many small ones, so there is no benefit to splitting orders and no way to game the price by ordering. A test compares one trade of four units with four trades of one unit and checks they net the same within rounding.

Part of the fee goes to the protocol treasury, and the rest stays in the pool and accrues to remaining holders. If the reserve cannot cover the request, the instruction fails with a clear error and you can use a ticket instead.

Standard unstake with tickets

A ticket burns your shares at the current price and records exactly how much SOL you are owed. There is no fee. The ticket gets a position in a cumulative first-in-first-out queue. Free liquidity funds the queue in order, so a ticket becomes claimable when the funded counter passes its position and its cooldown (one epoch by default) has elapsed.

• Tickets can pay a different recipient than the orderer.
• Claiming is permissionless, so relayers can trigger payouts; the money only ever goes to the ticket recipient.
• Claims and ticket orders keep working during a guardian pause, so exits are never trapped.

Where the liquidity comes from

When the queue is underfunded, anyone can run the unstake pipeline. First, a decrease instruction splits stake from the most over-weight validator bucket (the program checks that the chosen bucket really is the most over-weight, so callers cannot steer unstaking to a validator of their choice) and deactivates it. After the epoch passes, a withdraw instruction pulls the inactive stake back to the gateway, which immediately funds the queue, then refills the reserve, then leaves the rest free to delegate.

A bucket that is busy unstaking cannot block the others: the selection only considers buckets that can actually be decreased.

Instant unstake is limited by the reserve. For large amounts, use a standard unstake.