Everything you need to understand how Self Runner works at a protocol level — fee capture, LP routing, and the Self Runner engine beneath it all.
Self Runner is an autonomous on-chain fee engine built on top of the Self Runner protocol. Every trade that occurs against the Self Runner liquidity pool generates fees. Those fees are captured at the protocol level — before they can be distributed — and automatically routed 100% into LP depth every 30 minutes.
The result is a system that compounds on itself. More trades → more fees → deeper liquidity and supply compression → more stable floor → more trades.
Design Goals
- Self-sustaining: The system requires no external capital injection after launch. Fees from trading provide all the fuel.
- Non-extractable: Fees captured by Self Runner cannot be redirected to team wallets or external addresses. The routing is fixed at the contract level.
- Compounding: Each cycle deepens liquidity, which reduces slippage, which attracts more volume, which generates more fees.
- Transparent: All fee flows and LP additions are visible on-chain and reflected in the live fee feed.
The system consists of three interacting layers: the AMM pool, the Self Runner fee interceptor, and the LP depth router.
┌─────────────────────────────────────────────────┐
│ AMM Liquidity Pool │
│ (where $RUN trades happen) │
└────────────────────┬────────────────────────────┘
│ swap fees generated
▼
┌─────────────────────────────────────────────────┐
│ Self Runner Fee Interceptor │
│ captures fees before any distribution │
└────────────────────┬────────────────────────────┘
│ 100% of fees
▼
┌─────────────────────────────────────────────────┐
│ LP Depth Router │
│ adds paired liquidity to the pool range │
│ deepening the LP on every single trade │
└─────────────────────────────────────────────────┘Component Summary
| Component | Role | Controlled by |
|---|---|---|
AMM Pool | Handles all $RUN swaps, generates swap fees on every trade | Permissionless |
Self Runner Interceptor | Hooks into fee distribution, captures before payout | Self Runner Protocol |
LP Router | Routes 100% of captured fees into LP depth — pairs and mints liquidity positions | Self Runner Protocol |
When a swap occurs in the $RUN AMM pool, the pool charges a fee on the input token. Under a standard AMM, this fee would be distributed to liquidity providers. Self Runner intercepts this distribution at the protocol layer.
How interception works
Self Runner registers itself as the fee recipient on pool deployment. Instead of sending fees to LP holders directly, the pool routes all fee accrual to Self Runner's FeeVault contract. The vault is non-custodial — no address can withdraw from it except the Self Runner routing contracts.
// Simplified Self Runner fee vault interface
interface IFeeVault {
// Called by pool on every swap
function receiveFees(
address token,
uint256 amount
) external;
// No external withdrawal — routing only
function routeToSplit() external;
}Trigger conditions
Fee routing can be triggered by anyone calling routeToLP() on the vault — it is a public, permissionless function. In practice, Self Runner's off-chain keeper calls it automatically every 30 minutes, flushing 100% of accumulated fees into the LP.
The LP Depth Router receives 100% of all captured fees and adds them back into the pool as concentrated liquidity. This progressively deepens the pool, tightening spreads and reducing price impact for all traders.
How liquidity is added
The fee allocation arrives as the quote token. To add balanced liquidity, the router uses half of it to buy $RUN (at spot), then pairs both tokens and mints a new LP position in a range centered around the current price.
// LP addition logic (simplified)
// 100% of allocation goes to LP — no split
uint256 halfFees = allocation / 2;
// Buy $RUN with half to create a balanced pair
uint256 srunAcquired = swap(quoteToken, srun, halfFees);
// Add paired liquidity around current tick
pool.mint(
recipient: address(this),
tickLower: currentTick - RANGE_WIDTH,
tickUpper: currentTick + RANGE_WIDTH,
amount0: srunAcquired,
amount1: halfFees
);Range management
LP positions added by the protocol are concentrated in a tight range around the current market price. As the price moves, new positions continue to be added at the current price, progressively building depth across a wider range over time. Old positions remain active and continue earning fees.
The Self Runner Engine is the on-chain liquidity infrastructure built by the Self Runner team. It provides the smart contract primitives for fee interception, non-extractable vaults, autonomous routing, and protocol-owned liquidity management.
Every token launched through Self Runner uses these contracts with configuration parameters specific to that token's setup.
| Self Runner Primitive | Used by Self Runner for |
|---|---|
FeeVault | Capturing and holding all trading fees from the $RUN pool |
LPRouter | Routes 100% of captured fees into LP depth additions |
LPManager | Concentrated liquidity additions to the $RUN pool |
Keeper | Off-chain trigger — calls routeToLP() automatically every 30 minutes |
Self Runner's fee routing follows a strict on-chain path. No off-chain component has the ability to redirect fees — the keeper can only trigger routing, not modify its destination.
Any trade against the $RUN pool generates a fee. The pool calls FeeVault.receiveFees() instead of distributing to LPs.
Fees accumulate in the FeeVault. Every 30 minutes, Self Runner's keeper (or anyone) calls routeToLP() to flush the full balance into the LP.
Self Runner's keeper fires every 30 minutes and calls routeToLP(). The call is permissionless — anyone can trigger it ahead of schedule if desired.
50% is forwarded to BuybackExecutor, 50% to LPManager. Both execute atomically in the same transaction.
BuybackExecuted and LiquidityAdded events are emitted. The Self Runner fee feed reads these events to display live activity.
Self Runner's contracts are designed with a minimal attack surface. The key security properties relevant to Self Runner:
No admin withdrawal
The FeeVault has no withdraw(), emergencyExit(), or equivalent function. The only way fees can leave the vault is through routeToLP(), which sends them directly to the immutable LP router contract.
No upgradeable proxies
Self Runner's core contracts (FeeVault, LPRouter, LPManager) are deployed as non-upgradeable implementations. There is no upgradeTo() function, no proxy admin, and no way to change the contract logic post-deployment.
No owner privileges on fee flow
The deployer of Self Runner has no special privileges over the fee routing. They cannot pause routing, redirect allocations, or change where fees go. The only deployer control is over non-fee parameters like UI metadata.
Reentrancy
All Self Runner contracts use the checks-effects-interactions pattern and include reentrancy guards on all external-call-bearing functions. Fee vault state is updated before any token transfers occur.
$RUN is the native token of the Self Runner system. It is a standard ERC-20 (or SPL on Solana) token with no mint function beyond the initial supply and no special transfer hooks.
| Parameter | Value |
|---|---|
| Name | Self Runner |
| Symbol | $RUN |
| Contract (Solana) | TBA TBA |
| Supply | Fixed at launch, no mint function |
| Tax / Transfer fee | None — all fees are AMM swap fees via Self Runner |
| Ownership | Renounced post-deployment |
No transfer tax
$RUN does not use a transfer tax or fee-on-transfer mechanism. All fee generation happens at the AMM pool level through standard swap fees — not on token transfers. This makes $RUN compatible with all standard DeFi tooling without special handling.
The "floor" in Self Runner refers to the effective price support created by one compounding force: continuously deepening LP from 100% fee routing. Every single fee captured makes the pool harder to move.
Liquidity depth
As protocol-owned LP grows, the pool becomes more resistant to price impact from individual trades. A deep pool means a seller must move significantly more volume to push the price down by a given percentage. This translates directly to a more stable price floor.
Compounding effect
// Simplified floor strength model
// As cycles progress — 100% of fees go to LP:
poolLiquidity += allFeeAmount; // each cycle
// Price impact per unit of sell pressure:
priceImpact = sellAmount / poolLiquidity;
// With growing poolLiquidity,
// the same sell causes less impact each cycle.The five-step flywheel is the core compounding loop of Self Runner. Each step feeds the next, and the final step reinforces the first.
A user swaps against the $RUN AMM pool. The pool charges a swap fee (e.g. 1%) on the input amount. Self Runner captures this fee into the FeeVault.
The FeeVault accumulates fees from every trade. No distribution to LPs occurs. Nothing leaves the system.
SplitRouter divides the accumulated fees 50/50. BuybackExecutor and LPManager each receive their allocation and execute atomically.
The LP addition increases pool depth. Future trades experience lower slippage. The price floor becomes harder to push through.
A stable, deep market with predictable floor mechanics attracts more traders. Volume increases, generating more fees. Return to step 1.
The key parameters governing Self Runner's behavior via Self Runner:
| Parameter | Value | Mutable |
|---|---|---|
feeRate | 1% per swap | No |
splitRatio | 50 / 50 (buyback / LP) | No |
routingThreshold | Accumulation threshold before routing triggers | Keeper |
maxBuybackImpact | Max price impact per buyback execution | No |
lpRangeWidth | Tick range for new LP positions (±N ticks from current) | No |
burnAddress | Solana burn address | No |
Can the team take the fees?
No. Fees enter the Self Runner FeeVault which has no withdrawal function accessible to any EOA. The only exit is through the LP Router. The team has no privileged access to the fee flow.
What happens if no one trades?
If trading volume drops to zero, no new fees are generated and the flywheel stops adding fuel. However, the existing protocol-owned liquidity that has already been added remains. LP is still deep — the floor doesn't unwind.
Can the LP be removed?
Protocol-owned LP positions minted by Self Runner's LPManager have no withdrawal function. They are permanently locked in the pool. This means liquidity can only grow over time, never decrease through protocol actions.
Is Self Runner audited?
Audit details will be published before mainnet contract deployment. Follow the X Community for updates.
What chain is Self Runner on?
Self Runner is deployed on Solana. Contract address will be published at launch. Check the X Community for updates.
Who can trigger fee routing?
Anyone. routeToSplit() is a public permissionless function. Self Runner's keeper calls it automatically, but any wallet can call it manually at any time. Triggering it early just processes whatever fees have accumulated up to that point.