# The $B Token (/docs/btoken) **NOTE: \$B is not live yet.** \$B is the ecosystem token for Baseline Markets, an asset issuance protocol where tokens own their liquidity, and automatically manage it to grow value over time. ## How \$B Accrues Value \$B holders benefit from protocol activity in three ways: 1. **Token-Owned Liquidity**: Since \$B itself is a Baseline token, it inherits the properties of a guaranteed floor price, and liquidity that grows token's value over time. 2. **Protocol Fees**: Trading fees from all Baseline markets flow to the protocol, which may be used for staking, airdrops and buybacks in the future. 3. **Token Pairing**: Some projects will choose to pair with \$B. Demand for partner token will route buy pressure through \$B. These value accrual mechanisms create a self-reinforcing flywheel: as more projects launch on Baseline, more trading volume is generated, more fees are generated for \$B holders, and the value of \$B increases. ## Tokenomics | Category | Amount | Percentage | | ------------------------- | ---------- | ---------- | | **Circulating Supply** | 12,577,625 | 60% | | **Token-Owned Liquidity** | 8,422,375 | 40% | | **Team Allocation** | 0 | 0% | | **Investor Allocation** | 0 | 0% | | **Total Supply** | 21,000,000 | 100% |
60% Circulating 40% TOL Circulating Supply (12.6M) Token-Owned Liquidity (8.4M)
# BCredit Contract Reference (/docs/contracts/bcredit) The BCredit contract handles borrowing and leverage operations. It enables 0% interest loans backed by BLV and non-liquidatable leverage positions. **Contract:** `BCredit.sol` **Version:** Latest **License:** AGPL-3.0-only ## Overview BCredit provides two main capabilities: 1. **Borrowing** : Take loans against bToken collateral at BLV 2. **Leverage** : Create multiplied positions through borrow + buy loops All positions are non-liquidatable because collateral is valued at BLV (guaranteed floor). ## Borrowing Functions ### borrow Borrow reserves against bToken collateral. ```solidity function borrow( BToken _bToken, address _user, uint256 _collateralAmount, uint256 _borrowAmount ) external returns (uint256 fee_) ``` | Parameter | Type | Description | | ------------------- | --------- | ----------------------------- | | `_bToken` | `BToken` | The bToken collateral | | `_user` | `address` | User borrowing | | `_collateralAmount` | `uint256` | bTokens to lock as collateral | | `_borrowAmount` | `uint256` | Reserves to borrow | **Returns:** * `fee_`: Origination fee charged **Requirements:** * Collateral must support the borrow amount at BLV * User must have approved bToken transfer *** ### repay Repay borrowed reserves and unlock collateral. ```solidity function repay( BToken _bToken, address _user, uint256 _collateralAmount, uint256 _repayAmount ) external ``` | Parameter | Type | Description | | ------------------- | --------- | --------------------- | | `_bToken` | `BToken` | The bToken collateral | | `_user` | `address` | User repaying | | `_collateralAmount` | `uint256` | Collateral to unlock | | `_repayAmount` | `uint256` | Debt to repay | **Errors:** * `BCredit_RepaidMoreThanDebt`: Repaying more than owed *** ### defaultSelf Allow user to forfeit collateral to clear debt (emergency exit). ```solidity function defaultSelf(BToken _bToken, address _user) external ``` *** ## Leverage Functions ### leverage Create a leveraged position by borrowing and buying more bTokens. ```solidity function leverage( BToken _bToken, address _user, uint256 _collateral, uint256 _leverageFactor, uint256 _limitAmount ) external returns ( uint256 collateralAdded_, uint256 debtAdded_, uint256 collateralIn_, uint256 reservesIn_ ) ``` | Parameter | Type | Description | | ----------------- | --------- | -------------------------------------- | | `_bToken` | `BToken` | The bToken to leverage | | `_user` | `address` | User creating position | | `_collateral` | `uint256` | Initial bToken collateral | | `_leverageFactor` | `uint256` | Target leverage (WAD, e.g., 2e18 = 2x) | | `_limitAmount` | `uint256` | Maximum reserves to spend (slippage) | **Returns:** * `collateralAdded_`: Total collateral after leverage * `debtAdded_`: Debt created * `collateralIn_`: bTokens used as input * `reservesIn_`: Reserves borrowed *** ### deleverage Reduce leverage by selling collateral to repay debt. ```solidity function deleverage( BToken _bToken, address _user, uint256 _collateralToSell, uint256 _limitAmount ) external returns ( uint256 collateralRedeemed_, uint256 debtRepaid_, uint256 collateralSold_, uint256 refund_ ) ``` | Parameter | Type | Description | | ------------------- | --------- | ------------------------------------- | | `_bToken` | `BToken` | The leveraged bToken | | `_user` | `address` | User deleveraging | | `_collateralToSell` | `uint256` | Collateral to sell for debt repayment | | `_limitAmount` | `uint256` | Minimum reserves from sale (slippage) | *** ## View Functions ### getCreditAccount Get a user's credit account state. ```solidity function getCreditAccount(BToken _bToken, address _user) external view returns (State.CreditAccount memory) ``` **Returns:** `CreditAccount` struct: * `collateral`: Locked bTokens * `debt`: Outstanding debt *** ## Events ```solidity event Borrow( BToken bToken, address user, uint256 borrowed, uint256 fee, State.CreditAccount post ); event Repay( BToken bToken, address user, uint256 collateralRedeemed, uint256 debtRepaid, State.CreditAccount post ); event Leverage( BToken bToken, address user, uint256 collateralAdded, uint256 debtAdded, uint256 collateralIn, uint256 reservesIn, State.CreditAccount post ); event Deleverage( BToken bToken, address user, uint256 collateralRedeemed, uint256 debtRepaid, uint256 collateralSold, uint256 refund, State.CreditAccount post ); event DefaultSelf(BToken bToken, address user); ``` *** ## Errors | Error | Description | | -------------------------------------------- | ---------------------------------------- | | `BCredit_InsufficientCollateral` | Not enough collateral for borrow | | `BCredit_RepaidMoreThanDebt` | Repaying more than owed | | `BCredit_Leverage_ZeroCollateral` | Leverage with no collateral | | `BCredit_Leverage_BorrowAmountTooLow` | Borrow doesn't meet minimum | | `BCredit_Deleverage_InvalidCollateralToSell` | Invalid deleverage amount | | `BCredit_Deleverage_Undercollateralized` | Would leave position undercollateralized | *** ## Collateral Calculation Borrowing capacity is calculated against BLV: ``` Max Borrow = Collateral x BLV x LTV ``` Where: * `Collateral` = bTokens locked * `BLV` = Current floor price * `LTV` = Loan-to-value ratio (up to 90%) *** ## Usage Example ```solidity // Borrow 900 reserves against 1000 bTokens at 90% LTV bToken.approve(address(bcredit), 1000e18); uint256 fee = bcredit.borrow( bToken, msg.sender, 1000e18, // collateral 900e18 // borrow amount ); // Create 2x leverage bcredit.leverage( bToken, msg.sender, 1000e18, // initial collateral 2e18, // 2x leverage 1100e18 // max reserves to use ); // Repay and unlock reserve.approve(address(bcredit), 900e18); bcredit.repay( bToken, msg.sender, 1000e18, // collateral to unlock 900e18 // debt to repay ); ``` *** ## Related * [Borrowing Guide](/docs/holders/borrow) : How to borrow * [Multiply](/docs/holders/multiply) : How to use leverage * [BLV Mechanics](/docs/how-it-works/blv): Why loans are 0% interest # BLens Contract Reference (/docs/contracts/blens) The BLens contract provides read-only view functions for querying bToken state, prices, positions, and protocol parameters. **Contract:** `BLens.sol` **Version:** 4 **License:** AGPL-3.0-or-later ## Overview BLens is a view-only contract with \~50 functions for reading protocol state. Use BLens for: * Querying prices (BLV, market, premium) * Reading pool state (reserves, supply, fees) * Checking user positions (staking, credit) * Getting protocol configuration ## Price Functions ### getActivePrice Get current market price. ```solidity function getActivePrice(BToken _bToken) external view returns (uint256) ``` **Returns:** Market price in WAD (1e18 = 1.0) *** ### getBLV Get current Baseline Value (floor price). ```solidity function getBLV(BToken _bToken) external view returns (uint256) ``` **Returns:** BLV in WAD *** ### getPremium Get premium above BLV. ```solidity function getPremium(BToken _bToken) external view returns (uint256) ``` **Returns:** Premium in WAD (market price - BLV) *** ### getBookPrice Get book price (total reserves / circulating supply). ```solidity function getBookPrice(BToken _bToken) external view returns (uint256) ``` *** ## Pool State Functions ### totalReserves Get total reserves in the pool. ```solidity function totalReserves(BToken _bToken) external view returns (uint256) ``` *** ### totalBTokens Get total bTokens held by the protocol. ```solidity function totalBTokens(BToken _bToken) external view returns (uint256) ``` *** ### totalSupply Get total token supply. ```solidity function totalSupply(BToken _bToken) external view returns (uint256) ``` *** ### getCirculatingSupply Get circulating supply (total - protocol holdings). ```solidity function getCirculatingSupply(BToken _bToken) external view returns (uint256) ``` *** ### reserve Get the reserve token address. ```solidity function reserve(BToken _bToken) external view returns (ERC20) ``` *** ## Ratio Functions ### getInventoryRatio Get inventory ratio (pool inventory / circulating). ```solidity function getInventoryRatio(BToken _bToken) external view returns (uint256) ``` *** ### getBufferRatio Get buffer reserves ratio. ```solidity function getBufferRatio(BToken _bToken) external view returns (uint256) ``` *** ### getLiquidityLeverage Get liquidity leverage (buffer ratio x inventory ratio). ```solidity function getLiquidityLeverage(BToken _bToken) external view returns (uint256) ``` *** ## Fee Functions ### poolFeeShare Get fee share going to pool (BLV growth). ```solidity function poolFeeShare(BToken _bToken) external view returns (uint256) ``` *** ### creatorFeePct Get creator fee percentage. ```solidity function creatorFeePct(BToken _bToken) external view returns (uint256) ``` *** ### totalFeeShare Get total fee share. ```solidity function totalFeeShare(BToken _bToken) external view returns (uint256) ``` *** ### creatorClaimable Get claimable fees for creator. ```solidity function creatorClaimable(BToken _bToken) external view returns (uint256) ``` *** ## Position Functions ### getCreditAccount Get user's credit (borrow) position. ```solidity function getCreditAccount(BToken _bToken, address _user) external view returns (State.CreditAccount memory) ``` **Returns:** Struct with: * `collateral`: Locked bTokens * `debt`: Outstanding debt *** ### getStakedAccount Get user's staking position. ```solidity function getStakedAccount(BToken _bToken, address _user) external view returns (State.StakedAccount memory) ``` **Returns:** Struct with: * `amount`: Staked bTokens * `rewardDebt`: Accumulated rewards claimed *** ### getMaxBorrow Get maximum borrowable amount for collateral. ```solidity function getMaxBorrow(BToken _bToken, uint256 _collateral) external view returns (uint256) ``` *** ### getLeverageResult Preview leverage operation result. ```solidity function getLeverageResult( BToken _bToken, uint256 _collateral, uint256 _leverageFactor ) external view returns ( uint256 collateralAdded_, uint256 debtAdded_, uint256 reservesNeeded_ ) ``` *** ## Protocol Configuration ### protocolFeeRecipient Get protocol fee recipient address. ```solidity function protocolFeeRecipient() external view returns (address) ``` *** ### protocolFeePct Get protocol fee percentage. ```solidity function protocolFeePct() external view returns (uint256) ``` *** ### originationFee Get loan origination fee. ```solidity function originationFee() external view returns (uint256) ``` *** ### isPoolPaused Check if a pool is paused. ```solidity function isPoolPaused(BToken _bToken) external view returns (bool) ``` *** ### isProtocolPaused Check if entire protocol is paused. ```solidity function isProtocolPaused() external view returns (bool) ``` *** ## Hook Functions ### hasHook Check if bToken has Uniswap V4 hook. ```solidity function hasHook(BToken _bToken) external view returns (bool) ``` *** ### poolKey Get Uniswap V4 pool key. ```solidity function poolKey(BToken _bToken) external view returns (PoolKey memory) ``` *** ## Component Functions ### getComponents Get all protocol components. ```solidity function getComponents() external view returns (address[] memory) ``` *** ## Usage Example ```solidity // Get current prices uint256 marketPrice = blens.getActivePrice(bToken); uint256 blv = blens.getBLV(bToken); uint256 premium = blens.getPremium(bToken); // Check pool state uint256 reserves = blens.totalReserves(bToken); uint256 circulating = blens.getCirculatingSupply(bToken); // Preview leverage (uint256 collateral, uint256 debt, uint256 needed) = blens.getLeverageResult( bToken, 1000e18, // initial collateral 2e18 // 2x leverage ); // Check user position State.CreditAccount memory credit = blens.getCreditAccount(bToken, user); uint256 maxBorrow = blens.getMaxBorrow(bToken, credit.collateral); ``` *** ## Related * [BSwap Contract](/docs/contracts/bswap) : Trading functions * [BCredit Contract](/docs/contracts/bcredit) : Borrowing functions * [BStaking Contract](/docs/contracts/bstaking) : Staking functions # BStaking Contract Reference (/docs/contracts/bstaking) The BStaking contract handles staking operations for bTokens. Users can stake their tokens to earn a share of protocol trading fees. **Contract:** `BStaking.sol` **Version:** 1 **License:** AGPL-3.0-or-later ## Overview BStaking implements a reward accumulator pattern where fees are distributed proportionally to staked balances. Stakers earn rewards in the reserve asset (e.g., ETH/WETH). ## Functions ### Staking Functions #### deposit Stake bTokens to earn rewards. ```solidity function deposit(BToken _bToken, address _user, uint256 _amount) external ``` | Parameter | Type | Description | | --------- | --------- | --------------------------------- | | `_bToken` | `BToken` | The bToken to stake | | `_user` | `address` | User receiving the stake position | | `_amount` | `uint256` | Amount of bTokens to stake | **Requirements:** * Caller must have approved BStaking to transfer bTokens * BToken must be initialized *** #### withdraw Withdraw staked bTokens. ```solidity function withdraw(BToken _bToken, address _user, uint256 _amount) external ``` | Parameter | Type | Description | | --------- | --------- | ------------------ | | `_bToken` | `BToken` | The staked bToken | | `_user` | `address` | User withdrawing | | `_amount` | `uint256` | Amount to withdraw | **Errors:** * `BStaking_StakeIsLocked`: If stake is in lock period *** #### withdrawMax Withdraw all staked bTokens. ```solidity function withdrawMax(BToken _bToken, address _user) external returns (uint256 amount_) ``` *** #### withdrawAndClaim Withdraw staked tokens and claim earned rewards in one transaction. ```solidity function withdrawAndClaim(BToken _bToken, address _user, uint256 _amount) external ``` *** ### Rewards Functions #### claim Claim accumulated rewards. ```solidity function claim(BToken _bToken, address _user) external returns (uint256 amount_) ``` | Parameter | Type | Description | | --------- | --------- | --------------------- | | `_bToken` | `BToken` | The staked bToken | | `_user` | `address` | User claiming rewards | **Returns:** * `amount_`: Reserve tokens claimed *** ### View Functions #### getEarned Get unclaimed rewards for a user. ```solidity function getEarned(BToken _bToken, address _user) external view returns (uint256) ``` #### getAccumulator Get current reward accumulator value. ```solidity function getAccumulator(BToken _bToken) external view returns (uint256) ``` #### getCurrentRate Get current reward distribution rate. ```solidity function getCurrentRate(BToken _bToken) external view returns (uint256) ``` *** ## Events ```solidity event Deposit(BToken bToken, address user, uint256 amount, State.StakedAccount post); event Withdraw(BToken bToken, address user, uint256 amount, State.StakedAccount post); event Claim(BToken bToken, address user, uint256 amount); event Liquidate(BToken bToken, address user, uint256 amount, State.StakedAccount post); ``` *** ## Errors | Error | Description | | ------------------------------- | ----------------------------------------- | | `BStaking_StakeIsLocked` | Attempting to withdraw during lock period | | `BStaking_BTokenNotInitialized` | BToken pool not initialized | *** ## Reward Distribution Rewards are distributed proportionally based on: 1. **Share of total stake** : Your staked amount / total staked 2. **Time staked** : Rewards accumulate over time 3. **Trading volume** : More fees = more rewards The accumulator pattern ensures fair distribution regardless of when you stake. *** ## Usage Example ```solidity // Stake 1000 bTokens bToken.approve(address(bstaking), 1000e18); bstaking.deposit(bToken, msg.sender, 1000e18); // Check earned rewards uint256 earned = bstaking.getEarned(bToken, msg.sender); // Claim rewards uint256 claimed = bstaking.claim(bToken, msg.sender); // Withdraw and claim in one tx bstaking.withdrawAndClaim(bToken, msg.sender, 500e18); ``` *** ## Related * [Staking Guide](/docs/holders/stake) : How to stake * [BLens Contract](/docs/contracts/blens) : View staking state # BSwap Contract Reference (/docs/contracts/bswap) The BSwap contract implements Baseline's power-law AMM curve for token trading. It handles all buy and sell operations, applying the n=2 curve with BLV translation. **Contract:** `BSwap.sol` **Version:** 21 **License:** AGPL-3.0-or-later ## Overview BSwap provides four trading entry points (exact input/output for buys and sells) and corresponding quote functions. All trades execute through the power-law curve: ``` y_buffer = K x (x/c)^2 ``` ## Functions ### Trading Functions #### buyTokensExactIn Buy bTokens with an exact amount of reserves. ```solidity function buyTokensExactIn( BToken _bToken, uint256 _amountIn, uint256 _limitAmount ) external returns (uint256 amountOut_, uint256 feesReceived_) ``` | Parameter | Type | Description | | -------------- | --------- | ------------------------------------------------ | | `_bToken` | `BToken` | The bToken to buy | | `_amountIn` | `uint256` | Exact reserve amount to spend | | `_limitAmount` | `uint256` | Minimum bTokens to receive (slippage protection) | **Returns:** * `amountOut_`: bTokens received * `feesReceived_`: Fees collected **Errors:** * `SlippageExceeded`: If `amountOut_ < _limitAmount` *** #### buyTokensExactOut Buy an exact amount of bTokens. ```solidity function buyTokensExactOut( BToken _bToken, uint256 _amountOut, uint256 _limitAmount ) external returns (uint256 amountIn_, uint256 feesReceived_) ``` | Parameter | Type | Description | | -------------- | --------- | ----------------------------------------------- | | `_bToken` | `BToken` | The bToken to buy | | `_amountOut` | `uint256` | Exact bTokens to receive | | `_limitAmount` | `uint256` | Maximum reserves to spend (slippage protection) | *** #### sellTokensExactIn Sell an exact amount of bTokens. ```solidity function sellTokensExactIn( BToken _bToken, uint256 _amountIn, uint256 _limitAmount ) external returns (uint256 amountOut_, uint256 feesReceived_) ``` | Parameter | Type | Description | | -------------- | --------- | ------------------------------------------------- | | `_bToken` | `BToken` | The bToken to sell | | `_amountIn` | `uint256` | Exact bTokens to sell | | `_limitAmount` | `uint256` | Minimum reserves to receive (slippage protection) | *** #### sellTokensExactOut Sell bTokens to receive an exact amount of reserves. ```solidity function sellTokensExactOut( BToken _bToken, uint256 _amountOut, uint256 _limitAmount ) external returns (uint256 amountIn_, uint256 feesReceived_) ``` | Parameter | Type | Description | | -------------- | --------- | --------------------------------------------- | | `_bToken` | `BToken` | The bToken to sell | | `_amountOut` | `uint256` | Exact reserves to receive | | `_limitAmount` | `uint256` | Maximum bTokens to sell (slippage protection) | *** ### Quote Functions Quote functions return expected trade results without executing. #### quoteBuyExactIn ```solidity function quoteBuyExactIn(BToken _bToken, uint256 _amountIn) external view returns (uint256 amountOut_, uint256 fee_) ``` #### quoteBuyExactOut ```solidity function quoteBuyExactOut(BToken _bToken, uint256 _amountOut) external view returns (uint256 amountIn_, uint256 fee_) ``` #### quoteSellExactIn ```solidity function quoteSellExactIn(BToken _bToken, uint256 _amountIn) external view returns (uint256 amountOut_, uint256 fee_) ``` #### quoteSellExactOut ```solidity function quoteSellExactOut(BToken _bToken, uint256 _amountOut) external view returns (uint256 amountIn_, uint256 fee_) ``` *** ### View Functions #### getCurveParams Get current curve parameters for a bToken. ```solidity function getCurveParams(BToken _bToken) external view returns (CurveParams memory) ``` **Returns:** `CurveParams` struct containing: * `k`: Curve invariant * `blv`: Current BLV (floor price) * `swapFeePct`: Fee percentage *** ## Errors | Error | Description | | ------------------------ | -------------------------------------------- | | `SlippageExceeded` | Trade output doesn't meet limit | | `SolverFailed` | Numerical solver failed to converge | | `AmountExceedsLiquidity` | Requested amount exceeds available liquidity | *** ## Events ```solidity event Swap( BToken bToken, address sender, bool isBuy, uint256 amountIn, uint256 amountOut, uint256 fee ); ``` *** ## Usage Example ```solidity // Buy 100 bTokens, paying at most 110 ETH uint256 amountIn; uint256 fees; (amountIn, fees) = bswap.buyTokensExactOut( bToken, 100e18, // 100 tokens 110e18 // max 110 reserves ); // Get quote first (uint256 quotedOut, uint256 quotedFee) = bswap.quoteBuyExactIn( bToken, 100e18 // 100 reserves ); ``` *** ## Related * [BMM Mechanics](/docs/how-it-works/bmm): Power-law curve explanation * [BLens Contract](/docs/contracts/blens) : View functions # Deployments (/docs/contracts) ## Baseline Mercury contracts Baseline Mercury is currently in development. ## Baseline Legacy contracts | Contract | Network | Address | | :-------------------- | :-----------: | :-------------------------------------------------------------------------------------------------------------------- | | YES (v3) | Base mainnet | [0x1B68244B100A6713ca7F540697b1bE12148a8bf9](https://basescan.org/address/0x1B68244B100A6713ca7F540697b1bE12148a8bf9) | | MARKET\_MAKING (v3) | Base mainnet | [0xe9B2fa00e24310f712aFFD9C00EC8c2C42c0c34F](https://basescan.org/address/0xe9B2fa00e24310f712aFFD9C00EC8c2C42c0c34F) | | CREDIT\_FACILITY (v3) | Base mainnet | [0xc9329Cb681d1338219B9e21E5E99754853436C8D](https://basescan.org/address/0xc9329Cb681d1338219B9e21E5E99754853436C8D) | | LOOP\_FACILITY (v3) | Base mainnet | [0x7bA0Fc5542Fad1931A5b765c220dB2ECF3E09a4F](https://basescan.org/address/0x7bA0Fc5542Fad1931A5b765c220dB2ECF3E09a4F) | | LOOPS (v3) | Base mainnet | [0x6B129C94eE04Ff4d989B0a0B2784Fc8bcFe777eF](https://basescan.org/address/0x6B129C94eE04Ff4d989B0a0B2784Fc8bcFe777eF) | | CREDT (v3) | Base mainnet | [0xa35E4Ac9565Fb006812755C30c369314be3511D9](https://basescan.org/address/0xa35E4Ac9565Fb006812755C30c369314be3511D9) | | RESERVE (v3) | Base mainnet | [0x4200000000000000000000000000000000000006](https://basescan.org/address/0x4200000000000000000000000000000000000006) | | UniswapV3Pool (v3) | Base mainnet | [0xdFCFDf5dd0569d591E0Bce28B5dA3b13dE09E3CB](https://basescan.org/address/0xdFCFDf5dd0569d591E0Bce28B5dA3b13dE09E3CB) | | YES (v2) | Blast mainnet | [0x1a49351bdB4BE48C0009b661765D01ed58E8C2d8](https://blastscan.io/address/0x1a49351bdB4BE48C0009b661765D01ed58E8C2d8) | | Afterburner (v2) | Blast mainnet | [0xFE49B8F38130d3B3fb0A2AD0697D81Df4f18dd84](https://blastscan.io/address/0xFE49B8F38130d3B3fb0A2AD0697D81Df4f18dd84) | | ThrusterPool (v2) | Blast mainnet | [0xD0F1e1243c9FfB11100eFd25f1C9Ef7Ca956dC13](https://blastscan.io/address/0xD0F1e1243c9FfB11100eFd25f1C9Ef7Ca956dC13) | | YES (v1) | Blast mainnet | [0x20fE91f17ec9080E3caC2d688b4EcB48C5aC3a9C](https://blastscan.io/address/0x20fE91f17ec9080E3caC2d688b4EcB48C5aC3a9C) | | Baseline (v1) | Blast mainnet | [0x14eB8d9b6e19842B5930030B18c50B0391561f27](https://blastscan.io/address/0x14eB8d9b6e19842B5930030B18c50B0391561f27) | | BaselineFactory (v1) | Blast mainnet | [0x0C056B34F2AFa70Ee1351e3659DFBD2097765275](https://blastscan.io/address/0x0C056B34F2AFa70Ee1351e3659DFBD2097765275) | | PreAsset (v1) | Blast mainnet | [0x60BF64CCAa52da304d456892dC0A8f1C5B159f61](https://blastscan.io/address/0x60BF64CCAa52da304d456892dC0A8f1C5B159f61) | | YEV (v1) | Blast mainnet | [0xC7b96D7f622e0a3A24cf333e84C29e36955f25BB](https://blastscan.io/address/0xC7b96D7f622e0a3A24cf333e84C29e36955f25BB) | | Yescension (v1) | Blast mainnet | [0xba1578e20578e0ad57e0430f241c9fcd76acd026](https://blastscan.io/address/0xba1578e20578e0ad57e0430f241c9fcd76acd026) | | ThrusterPool (v1) | Blast mainnet | [0x1d16788b97eDB7d9a6aE66D5C5C16469037Faa00](https://blastscan.io/address/0x1d16788b97eDB7d9a6aE66D5C5C16469037Faa00) | ## Operational | Contract | Network | Address | | :----------------- | :-----------: | :-------------------------------------------------------------------------------------------------------------------- | | Team multisig | Blast mainnet | [0x8044f710c58B6eA6a178CC540f9F1Cd758F7d1B2](https://blastscan.io/address/0x8044f710c58B6eA6a178CC540f9F1Cd758F7d1B2) | | Community multisig | Blast mainnet | [0xb4b9106fe909E9354A19842a31ffB611D48A92d0](https://blastscan.io/address/0xb4b9106fe909E9354A19842a31ffB611D48A92d0) | | JimmyStimmy | Blast mainnet | [0x9092a444a92e38F28f28dE49dA3FF6C760d9E568](https://blastscan.io/address/0x9092a444a92e38F28f28dE49dA3FF6C760d9E568) | | JimmyStimmy | Blast mainnet | [0x92c567E67C42fC9c2Df46D4fa944BD62C166d661](https://blastscan.io/address/0x92c567E67C42fC9c2Df46D4fa944BD62C166d661) | # Audits (/docs/contracts/security) | Audit | Link | Date | Auditors | | --------------- | --------------------------------------------------------------------------------------------- | ---------- | ------------------------------------------------- | | Fixed Supply | [2025-02-27\_Baseline\_Fixed\_Supply.pdf](/assets/2025-02-27_Baseline_Fixed_Supply.pdf) | 2025-02-27 | [Guardian Audits](https://guardianaudits.com/) | | BMM Looping #2 | [2025-02-03\_Baseline\_MM\_Looping\_2.pdf](/assets/2025-02-03_Baseline_MM_Looping_2.pdf) | 2025-02-03 | [Guardian Audits](https://guardianaudits.com/) | | BMM Looping #1 | [2025-01-22\_Baseline\_MM\_Looping.pdf](/assets/2025-01-22_Baseline_MM_Looping.pdf) | 2025-01-22 | [Guardian Audits](https://guardianaudits.com/) | | Credit Migrator | [2024-11-28\_Baseline\_Credit\_Migrator.pdf](/assets/2024-11-28_Baseline_Credit_Migrator.pdf) | 2024-11-28 | [Guardian Audits](https://guardianaudits.com/) | | BToken | [2024-10-27\_Baseline\_BToken.pdf](/assets/2024-10-27_Baseline_BToken.pdf) | 2024-10-27 | [Guardian Audits](https://guardianaudits.com/) | | Loops | [2024-08-23\_Baseline\_Loops.pdf](/assets/2024-08-23_Baseline_Loops.pdf) | 2024-08-23 | [Guardian Audits](https://guardianaudits.com/) | | Baseline V2 | [guardian\_v2.pdf](/assets/guardian_v2.pdf) | 2024-06-17 | [Guardian Audits](https://guardianaudits.com/) | | Baseline V1 | [audit\_trust\_security.pdf](/assets/audit_trust_security.pdf) | 2024-02-27 | [Trust Security](https://www.trust-security.xyz/) | # Borrow (/docs/holders/borrow) Baseline allows you to borrow against your bTokens at 0% interest and a small origination fee, using the [Baseline Value (BLV)](/docs/how-it-works/blv) floor price as collateral. Baseline Borrow gives you access to capital without needing to sell your position or risk liquidation. Borrowing against bTokens is ideal for users who want to free up liquidity for other purposes: like rotating capital into another token. ## Why borrow? * **Access capital without selling** : Keep your bToken exposure * **No liquidation risk** : BLV guarantees your collateral value so there's no need for expiration or liquidation thresholds * **0% interest** : No ongoing borrowing costs * **Maintain exposure to future upside** : If bToken price increases, you benefit * **Earn trading fees** : Borrowing automatically entitles you to a pro-rata amount of trading fees captured by the token * **No oracles**: No need to trust external price feeds oracles that may misreport. ## How borrowing works 1. bTokens have a Baseline Value (BLV) that is backed by reserves in the liquidity pool. 2. You can borrow against the BLV value of your bTokens directly from the Baseline protocol 3. When you borrow, you deposit your bTokens as collateral, and receive the borrowed amount in the reserve asset (e.g., ETH). The amount you receive is based on the BLV value: $\text{borrowed} = P_{blv} \times \text{bTokens}$ 4. You can repay the reserve amount anytime and get back your bTokens. There is no expiration date, or liquidation threshold. ### Example Suppose that YES is a bToken trading at 1.5 ETH per token, and the BLV is 1 ETH per token. In this case, the premium is +50% (1.5 ETH / 1 ETH - 1). You own 100 bTokens that you want to borrow against. Then: | Metric | Value | | --------------------------------- | -------------------------- | | Your bTokens | 100 | | Market price per token | 1.5 ETH | | BLV per token | 1 ETH | | Market value of your bTokens | 150 ETH | | Borrowed amount (total BLV value) | 100 ETH | | Loan-to-Value (LTV) | 66.67% (100 ETH / 150 ETH) | Let's consider some scenarios: 1. Market price increases to 2 ETH per token. You can repay the loan (100 ETH) to get back your bTokens, and sell for 200 ETH. Note that you still benefitted from the price increase, even though you borrowed against your bTokens. 2. Market price decreases to BLV (1 ETH per token). You can repay the loan (100 ETH) to get back your bTokens, and sell for 100 ETH. Note that when the price converges to BLV, there is no incentive to repay since you'll get back exactly what you used to repay. ## Next Steps * Earn trading fees by [staking](/docs/holders/stake) * Multiply exposure through [multiply](/docs/holders/multiply) # Multiply (/docs/holders/multiply) Baseline allows you to create leveraged positions on bTokens without liquidation risk. By borrowing against the Baseline Value (BLV) floor and using those funds to buy more bTokens, you can amplify your exposure to price movements. ## Why multiply? * **Amplify price exposure** : Use borrowed funds to buy more bTokens, amplifying your price exposure to directional moves * **Earn trading fees** : Multiplying automatically entitles you to a pro-rata amount of trading fees captured by the token. Since multiplying increases your total bToken position, you earn more fees relative to basic staking or borrowing. * **No liquidation risk** : The BLV floor guarantees your collateral is always worth at least your debt which means your leveraged position cannot be liquidated. Baseline multiply is an advanced trading strategy that requires careful consideration of the risks involved. In particular: * **Price Exposure**: Larger positions mean bigger gains AND bigger losses * **Slippage**: Leveraging buys (and sells) from the Baseline Pool which means it will be subjct to price impact and slippage. * **Market Timing**: Buying high with leverage amplifies losses if price drops * **Locked Collateral**: Your bTokens are locked until you deleverage ## How leverage works Baseline leverage uses a "multiply" mechanism repeatedly borrowing against your bTokens and using the borrowed funds to buy more bTokens: 1. **Deposit bTokens** : Your bTokens become collateral 2. **Select target leverage** : Select the target leverage you want to achieve 3. **Borrow against BLV** : The Baseline protocol borrows against your floor value 4. **Buy more bTokens** : Borrowed funds purchase additional bTokens 5. **Add to collateral** : New bTokens increase your position 6. **Repeat** : Repeat the process to multiply your exposure to the target leverage ## Example Suppose that YES is a bToken trading at 1.5 ETH per token, and the BLV is 1 ETH per token. In this case, the premium is +50% (1.5 ETH / 1 ETH - 1). You own 100 bTokens and want to multiply your exposure: | Metric | Value | | --------------------------------- | ------------------------------------ | | Your bTokens | 100 | | Market price per token | 1.5 ETH | | BLV per token | 1 ETH | | Market value of your bTokens | 150 ETH | | Borrowed amount (total BLV value) | 100 ETH | | Additional bTokens purchased | 66.67 (100 ETH / 1.5 ETH) | | Total bTokens after leverage | 166.67 | | Net leverage | 1.66x (166.67 bTokens / 100 bTokens) | Let's consider some scenarios: 1. Market price increases to 2 ETH per token. Your 166.67 bTokens are now worth 333.34 ETH. After repaying your 100 ETH debt, you have 233.34 ETH equity (compared to 200 ETH if you hadn't leveraged). Gain: +55.6% vs +33.3% without leverage. 2. Market price decreases to BLV (1 ETH per token). Your 166.67 bTokens are now worth 166.67 ETH. After repaying your 100 ETH debt, you have 66.67 ETH equity (compared to 100 ETH if you hadn't leveraged). Loss: -55.6% vs -33.3% without leverage. ## Key differences: borrowing vs leverage Both features are borrowing against BLV: the difference is what happens with the borrowed funds. | Feature | Borrowing | Leverage | | ------------------------ | -------------- | -------------------- | | **Borrowed funds** | In your wallet | Reinvested in bToken | | **bToken position size** | Unchanged | Increased | | **Use case** | Access capital | Amplify exposure | | **Risk level** | Lower | Higher | ## Next Steps * [Stake](/docs/holders/stake) : Earn fees on your position * [Borrow](/docs/holders/borrow) : Access capital without leverage # Stake (/docs/holders/stake) Baseline staking lets bToken holders earn rewards directly from trading activity. The amount you earn depends on: | Factor | Impact on Rewards | | ------------------ | --------------------------------------- | | **Your stake** | Larger stake = larger share | | **Total staked** | More competition = smaller share | | **Trading volume** | Higher volume = more fees to distribute | Staking has no lock-up period, and you can claim your rewards anytime. Users who borrow or leverage their bTokens are automatically staked, and thus also eligible for staking rewards. ## Why stake? * **Harvest trading volume** : Capture value from every trade as fees flow to stakers * **Passive income** : Earn fees without actively trading * **No impermanent loss** : Unlike traditional LP staking, your bTokens remain bTokens and you incur no impermanent loss ## How staking works On a high-level, staking works as follows: 1. **Trading fees accumulate** : Every bToken trade generates fees 2. **Fees stream to staking contract** : The Baseline protocol uses the Fee Manager to route a portion of the fees to the staking contract 3. **Proportional distribution** : Stakers earn based on their share of total staked 4. **Claim anytime** : Rewards accumulate and can be claimed whenever you want Baseline uses an adaptive distribution system that smoothly streams rewards to stakers. Trading fees flow into a pending yield pool, and the protocol automatically adjusts the distribution rate using a proportional controller. When trading volume is high, the distribution rate increases to match the influx of fees. During quieter periods, it gradually decreases. This ensures steady, predictable reward streams rather than sudden spikes or long waits between distributions. Your rewards accrue continuously with every block based on your share of the total staked amount. The protocol tracks cumulative rewards using an accumulator that updates in real-time, so your earned balance grows automatically without requiring any action on your part. You can claim your accumulated rewards whenever you want—there are no epochs or waiting periods. ## Next Steps * Access capital by [borrowing](/docs/holders/borrow) * Multiply exposure through [multiply](/docs/holders/multiply) # Trade (/docs/holders/trade) Baseline tokens (bTokens) trade on the Baseline Market Maker with a guaranteed floor price, built-in staking, borrowing, and leverage. Every bToken comes with a floor price ([BLV](/docs/how-it-works/blv)), dynamic liquidity managed by the [Baseline Market Maker (BMM)](/docs/how-it-works/bmm), and DeFi utility that enhances the trading experience for novice and experienced investors. * **Guaranteed floor price** -- Every bToken has a public, on-chain minimum price. You can always exit at (or above) this price, even if no one else is buying. This price is enforced programmatically by smart contracts. * **Earn rewards** - Stake your bTokens to earn a pro-rata amount of trading fees captured by the token, * **Access capital** - Borrow against your bToken collateral at 0% interest and a low origination fee, accessing capital without having to sell your position, * **Multiply exposure** - Use borrowed funds to buy more bTokens, amplifying your gains. ## Key Metrics * **Market Price** -- The current trading price based on protocol liquidity. * **BLV (Baseline Value)** -- The guaranteed price floor, backed by reserves. * **Premium** -- The % difference between market price and BLV. * **Volume** -- Baseline generates fees from trading volume. More volume means more staking rewards, and faster BLV growth. ## Trading Strategies * **Conservative:** Buy bTokens near BLV for downside protection * **Earn:** Stake bTokens to earn trading fees passively without impermanent loss * **Capital Efficiency:** Borrow against bTokens at 0% to deploy capital elsewhere while maintaining exposure * **Speculative:** Use Baseline Multiply to amplify your exposure to price movements without liquidation risk ## Next Steps * Earn trading fees by [staking](/docs/holders/stake) * Access capital by [borrowing](/docs/holders/borrow) * Multiply exposure through [multiply](/docs/holders/multiply) # Baseline Value (BLV) (/docs/how-it-works/blv) Every Baseline token comes with a **Baseline Value (BLV)**: a minimum redemption price that is backed by pool reserves. The BLV is programmatically enforced by smart contracts, guaranteeing holders an exit regardless of market conditions. The BLV can never decrease but, through the token's market making operations, the BLV can increase over time. ## Why BLV Matters Traditional tokens offer no downside protection. When market sentiment shifts, liquidity dries up, holders race to exit, and prices crash. This creates several problems: * **Rug pulls**: Projects can drain liquidity at any time, leaving holders with worthless tokens and no way to sell. * **Death spirals**: Price drops trigger panic selling. Without a floor to backstop, negative market reflexivity accelerates panic selling. * **Short lifespan**: When the only guarantee is a price of zero, tokens become unsuitable as collateral or for long-term holding. BLV transforms tokens from speculative instruments into assets with programmatic guarantees. ## How BLV Works Every Baseline token splits reserves in the liquidity pool into backing reserves and buffer reserves: $$ y_{pool} = y_{backing} + y_{buffer} $$ * **Backing reserves** guarantee every circulating token can be redeemed at the floor price * **Buffer reserves** enable price discovery above the floor BLV is the guaranteed floor price that determines how backing reserves are allocated: $$ P_{blv} = \frac{y_{backing}}{c} $$ The [Baseline Market Maker (BMM)](/docs/how-it-works/bmm) enforces this as the minimum price for all trades. As trading happens, BMM directs excess reserves to increasing the BLV. ## Benefits of BLV * **Downside Protection**: BLV guarantees a sell price, reducing the risk of catastrophic losses and making tokens safer to hold. * **Market Integrity**: Because BLV is onchain and cannot be manipulated or removed, Baseline eliminates common risks like liquidity rug pulls. * **Capital coordination**: As more users trade, stake, or loop, the BLV increases, reinforcing a shared incentive to grow the token's instrinsic value. * **DeFi Utility**: BLV is collateral. Token holders can [borrow](/docs/holders/borrow) against their BLV, or [multiply](/docs/holders/multiply) their exposure without liquidation risk. # Market Maker (BMM) (/docs/how-it-works/bmm) The Baseline Market Maker (BMM) is an onchain algorithmic market maker that differs from traditional market makers in three fundamental ways: 1. It operates 24/7 and autonomously with rules transparently enshrined in smart contracts. 2. It splits the pool reserves into backing (floor protection) and buffer (price discovery). 3. It quotes bid-ask prices based on token circulating supply. By allocating liquidity intelligently, the BMM facilitates better price discovery and creates more efficient token markets for all participants. ## Why BMM Matters Most markets today use central limit order books to allocate liquidity. This approach requires every project to negotiate deals to bootstrap liquidity, and have professional market makers to actively manage quotes. In a world where most assets are issued digitally at an accelerating pace, this is no longer a viable solution. Algorithmic Market Makers (AMMs) solve this by replacing active management with a bonding curve, a mathematical formula that quotes prices automatically using pooled liquidity. This approach, however, treats liquidity separate from the token, creating problems: * **Liquidity mismatch**: Pools quote without knowing float, causing either low-float pumps (too much liquidity) or death spirals (too little liquidity) * **Value leakage**: Most popular AMMs deploy liquidity even when they should protect reserves * **Death spirals**: Without awareness of circulating supply, the AMM is unable to backstop negative market reflexivity, causing tokens to trend to zero. BMM enables something traditional AMMs cannot: a **guaranteed floor price** that coexists with healthy price discovery. ## How BMM Works By using token-owned liquidity, BMM tracks circulating supply, pool inventory and pool reserves. BMM splits reserves into backing reserves (blue) and buffer reserves (green): * **Backing reserves** guarantee every circulating token can be redeemed at the floor price * **Buffer reserves** enable price discovery above the floor The chart shows pool inventory on the x-axis and pool reserves on the y-axis. The blue area represents backing reserves required to buyback all circulating supply at the floor. The green area represents buffer reserves available for price discovery. Reserves Curve showing backing and buffer reserves Backing reserves use the [Baseline Value (BLV)](/docs/how-it-works/blv) to determine how much reserves to allocate for a given circulating supply: $$ y_{backing} = P_{blv} \cdot c $$ Buffer reserves follow a power-law curve based on a ratio between circulating supply and pool inventory: $$ y_{buffer}\cdot \left(\frac{x}{c}\right)^2 = K $$ The invariant maintains a constant K by adjusting buffer reserves based on the inventory ratio (x/c): * **High circulation** (x is small, c is large): Inventory ratio is low, so buffer reserves are large. The pool deploys deep liquidity to facilitate price discovery as tokens trade actively. * **Low circulation** (x is large, c is small): Inventory ratio is high, so buffer reserves shrink. The pool withdraws liquidity as it absorbs supply, transitioning from price discovery to price protection at the floor. In other words, the pool automatically scales buffer reserves based on how much supply is circulating, preventing the low-float, high-FDV distortions that plague traditional AMMs. As trading happens, BMM captures value through the use of [dynamic fees](/docs/how-it-works/fees). This excess value is directed to increasing the BLV. ## Benefits of BMM * **Token-Owned Liquidity:** Instead of depending on unreliable counterparties, BMM operates programmatically, transparently and in perpetuity. * **Value Accrual**: By managing its own liquidity, the token captures trading fees as revenue, and grows its own value over time. * **Efficient Markets**: BMM creates efficient markets by allocating liquidity intelligently based on circulating supply and pool inventory. # Fees (/docs/how-it-works/fees) Baseline charges fees on trades that flow back to the token's balance sheet. Every trade increases the floor price, making trading activity directly strengthen the token's value. ## How Fees Work Fees adapt based on where the trade occurs relative to the floor price: **On Sells:** * Fee charged on the **premium portion** (above BLV) * Higher premiums pay higher fees * Distressed sells near the floor pay almost nothing This protects sellers who need to exit during market stress. If you're selling near the floor, you're already taking a loss - the fee structure doesn't punish you further. **On Buys:** * Fee charged on the **BLV portion** * Consistent fee capture on the stable component This ensures consistent revenue capture regardless of where the price is trading above the floor. ## Benefits of Fees * **Floor Growth**: Fees accumulate in backing reserves, permanently raising BLV with every trade. * **Revenue Generation**: The token monetizes its own trading activity instead of paying market makers. * **Aligned Incentives**: More trading volume means higher floor prices for all holders. * **Distressed Seller Protection**: Sellers near the floor pay minimal fees - no punishment for exiting during stress. # Overview (/docs/how-it-works/overview) At its core, every Baseline token is managed by the [Baseline Market Maker (BMM)](/docs/how-it-works/bmm), a novel AMM that allocates liquidity more intelligently, facilitating better price discovery and creating more efficient token markets. ## Why It Matters Most markets today use central limit order books to allocate liquidity. This approach requires every project to negotiate deals to bootstrap liquidity, and have professional market makers to actively manage quotes. In a world where most assets are issued digitally at an accelerating pace, this is no longer a viable solution. Algorithmic Market Makers (AMMs) solve this by replacing active management with a bonding curve, a mathematical formula that quotes prices automatically using pooled liquidity. This approach, however, treats liquidity separate from the token, creating problems: * **Liquidity mismatch**: Pools quote without knowing float, causing either low-float pumps (too much liquidity) or death spirals (too little liquidity) * **Value leakage**: Most popular AMMs deploy liquidity even when they should protect reserves * **Death spirals**: Without awareness of circulating supply, the AMM is unable to backstop negative market reflexivity, causing tokens to trend to zero. The Baseline Market Maker (BMM) enables Baseline tokens to move beyond limitations of traditional markets to programmable markets that actively grow the economies they represent. ## How It Works Token-owned liquidity tracks circulating supply ($c$), pool inventory ($x$) and pool reserves ($y$) in a single smart contract. Pool reserves are split into backing reserves and buffer reserves: $$ y = y_{backing} + y_{buffer} $$ * **Backing reserves** guarantee every circulating token can be redeemed at the floor price * **Buffer reserves** enable price discovery above the floor ### Baseline Value (BLV) [BLV](/docs/how-it-works/blv) is the guaranteed floor price that determines how backing reserves are allocated: $$ P_{blv} = \frac{y_{backing}}{c} $$ Equivalently: $$ y_{backing} = P_{blv} \cdot c $$ This invariant is enforced programmatically at the smart contract level, ensuring every circulating token can be redeemed at, or above, the floor price. The BLV can never decrease but, through the token's market making operations, the BLV can increase over time. ### The Buffer Invariant Buffer reserves follow a power-law curve based on inventory ratio: $$ y_{buffer}\cdot \left(\frac{x}{c}\right)^2 = K $$ The invariant maintains a constant K by adjusting buffer reserves based on the inventory ratio (x/c): * High circulation (x is small, c is large): Inventory ratio is low, so buffer reserves are large. The pool deploys deep liquidity to facilitate price discovery as tokens trade actively. * Low circulation (x is large, c is small): Inventory ratio is high, so buffer reserves shrink. The pool withdraws liquidity as it absorbs supply, transitioning from price discovery to price protection at the floor. ### Liquidity Efficiency [BMM](/docs/how-it-works/bmm) allocates liquidity based on two ratios that work together. **Inventory Ratio** measures pool inventory relative to circulating supply: $$ R_{inventory} = \frac{x}{c} $$ **Buffer Ratio** measures buffer reserves relative to total reserves in the pool: $$ R_{buffer} = \frac{y_{buffer}}{y} $$ Traditional AMMs ignore these relationships, which causes problems in extreme states. BMM, on the other hand, maintains a bounded liquidity efficiency: $$ L_{efficiency} = R_{buffer} \times R_{inventory} $$ This ensures liquidity allocation stays efficient across all circulation states. As inventory ratio increases, buffer ratio decreases proportionally, preventing the system from over-allocating liquidity when it should be protecting the floor. ## Example The chart below shows pool inventory on the x-axis and total reserves on the y-axis. The blue area represents backing reserves required to buyback all circulating supply at the floor. The green area represents buffer reserves available for price discovery. Reserves Curve showing backing and buffer reserves ## Baseline vs Traditional AMMs Traditional constant-product AMMs (xy=k) have a fundamental limitation: they deploy all reserves for trading with no floor protection. Using the definitions above, in xyk systems, we have: * $y_{backing} = 0$ (no concept of backing reserves) * $y_{buffer} = y$ (all reserves used for price discovery) * $P_{blv} = 0$ (no floor price, tokens can go to zero) * $L_{efficiency} \rightarrow \infty$ as $c \rightarrow 0$ This creates several problems: * **Liquidity mismatch**: Pools quote without knowing float, causing either low-float pumps (too much liquidity) or death spirals (too little liquidity) * **Value leakage**: Reserves get extracted even when the system should be protecting them * **No defensive mechanism**: Traditional AMMs don't transition from price discovery to price protection BMM solves this by being circulation-aware and splitting reserves into backing and buffer. As circulation collapses, BMM automatically withdraws buffer liquidity and transitions to price protection, preventing the distortions that plague traditional AMMs. ## Key Concepts * **[Baseline Value (BLV)](/docs/how-it-works/blv)**: The guaranteed floor price mechanism * **[Baseline Market Maker (BMM)](/docs/how-it-works/bmm)**: The circulating-supply-aware AMM * **[Fees](/docs/how-it-works/fees)**: How fees grow the floor price # What is Baseline? (/docs) Baseline protocol: tokens that own their liquidity and grow value over time ## Tokens as assets, not liabilities Today, the process of launching a token is risky, expensive, and time-consuming. Instead of building, founders are figuring out smart contracts, negotiating with market makers, and optimizing their tokenomics. As a result, launching a token today causes more problems than it solves. Every step in a token's lifecycle presents a different obstacle: 1. **Misconfigured setup**: Imbalances in supply and liquidity can result in easy manipulation and ineffective price discovery. That's why over [85% of all tokens](https://x.com/mementoresearch/status/2003089388511604744) end up below their TGE price. 2. **Counterparty risk**: One rogue action from your investors, market makers or exchange can jeopardize your entire project. 3. **Ongoing costs**: Once launched, tokens become a liability as you have to manage operations, liquidity and holder expectations. Baseline was built to solve these problems by turning a token from a liability that works against projects, into an asset that works for them. ## The end-to-end asset issuance protocol In Baseline, tokens own their liquidity, and automatically manage it to grow value over time. By using Baseline, founders save time, prevent costly mistakes, and automate the entire token lifecycle. Founders configure launch parameters, and Baseline does the rest: token deployment, liquidity management and value accrual. * **Token-Owned Liquidity:** Instead of depending on unreliable counterparties, Baseline tokens operate programmatically, transparently and in perpetuity with no cost. * **Value Accrual:** By managing its own liquidity, the token captures trading fees as revenue, and grows its own value over time. * **Capital Coordination:** Baseline tokens have built-in utility like real yield, borrowing without interest, and leverage without liquidation. By rethinking token design from first principles, Baseline tokens move beyond static limitations of traditional equity to programmable assets that actively grow the economies they represent. [Launch a Token](/docs/projects) ## Beyond zero-sum trading Traditional token trading is a zero-sum game with binary choices: hold and wait for a pump, or sell to access capital. Baseline gives traders optionality on how to manage and grow their portfolio. * **Guaranteed floor price:** Baseline establishes the point at which the risk-reward profile is the most asymmetric, backstopping negative market reflexivity. * **Incentives to hold:** Baseline captures and distributes LP fees to holders, harvesting volume into yield automatically. * **Access to Capital:** Baseline gives the ability to borrow with no interest and no liquidation risk, making every token a permanent source of liquidity when needed. With token-owned liquidity, Baseline offers programmatic guarantees that no other assets can, fundamentally rewriting the game theory of token trading. [Learn More](/docs/holders/trade) # Points Program (/docs/points) Baseline will launch a Points program when \$B goes live. Points earned will convert into a future airdrop. More details coming soon. # Launch (/docs/projects/launch) Interested in launching a token with Baseline? [Fill out this form](https://baselineprotocol.notion.site/302c1b2b222b8075b572da3f3799bf3b?pvs=105) and we'll be in touch shortly. # Links (/docs/resources/links) * [Website](https://baseline.markets/) * [X](https://twitter.com/baselinemarkets) * [Discord](https://discord.gg/baseline) * [GitHub](https://github.com/0xbaseline) # LLMs.txt (/docs/resources/llms-txt) Baseline provides [llms.txt](https://llmstxt.org/) endpoints so that LLMs, AI agents, and other tools can consume our documentation programmatically. ## Endpoints | Endpoint | Description | | -------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | | [`/llms.txt`](https://www.baseline.markets/llms.txt) | Overview of Baseline, key concepts, FAQ, and a linked index of all documentation pages | | [`/docs/llms-full.txt`](https://www.baseline.markets/docs/llms-full.txt) | Full text of every documentation page in a single file | | [`/docs/llms.mdx/{slug}`](https://www.baseline.markets/docs/llms.mdx/how-it-works/blv) | Raw MDX source for a single doc page (e.g. `how-it-works/blv`) | | [`/blog/llms.txt`](https://www.baseline.markets/blog/llms.txt) | Blog index with post titles, dates, and descriptions | | [`/blog/llms-full.txt`](https://www.baseline.markets/blog/llms-full.txt) | Full text of every blog post | ## Usage Start with `/llms.txt` for an overview and index. Use `/docs/llms-full.txt` to ingest all documentation at once, or fetch individual pages via `/docs/llms.mdx/{slug}` when you only need specific topics. All endpoints return plain text with a 1-hour cache (`Cache-Control: public, max-age=3600`). # Migration FAQ (/docs/resources/migration-faq) Frequently asked questions about the Baseline Mercury migration (April 20, 2026). ## What is Baseline and what is \$B? The Baseline protocol is pioneering the concept of Token-Owned Liquidity where tokens automatically manage their liquidity to grow value over time. Baseline tokens come with their [own AMM](https://x.com/BaselineMarkets/status/2044809031026614723) and bonding curve that gives every token a floor price and features such as staking to earn trading fees, borrowing with no expiration, and leveraging without liquidation. \$B will be the ecosystem token that accrues value from the Baseline protocol. *** ## What is Mercury and why is there a migration? Mercury is the new Baseline protocol upgrade. It upgrades the AMM curve and pool architecture while keeping the same core mechanics: token-owned liquidity, BLV floor, and DeFi utilities (stake, borrow, multiply). All supported tokens migrate from the legacy deployment into Mercury on April 20. *** ## How are \$YES and \$B related? \$YES is being migrated from Base L2 to Ethereum Mainnet L1 and rebranded as \$B token. All balances will transfer 1:1. Borrowed positions and looped positions will be combined into a single Credit position (collateral balances summed, debt summed). **NO ACTION REQUIRED**. Just check your wallets when the migration is finished. *** ## When is the migration starting? Migration will start at \~06:00 UTC on April 20, 2026 *** ## What does the migration process look like? The migration process will follow the following steps: 1. Pause the legacy pool for each token. 2. Snapshot the token balances, including spot, collateral and debt positions across borrows and loops. 3. Migrate the balances to Mercury. 4. Deploy and unlock the pool for each token. 5. Tokens are tradable. During migration, tokens will be paused and not be tradable. We will also sunset [https://legacy.baseline.markets](https://legacy.baseline.markets) in preparation for the new Baseline Terminal. *** ## How long will the migration take? We will start at \~06:00 UTC on April 20, 2026 and aim to finish within a few hours. Please check Discord for updates: [https://discord.com/invite/baseline](https://discord.com/invite/baseline) *** ## What tokens are migrating and in what order? A: We will migrate tokens in the following order on April 20th: BLT, FLAPPY, AI, BSR,\$YES. ONYX will be migrated on April 22nd. *** ## Do I need to claim anything after migration? No. All spot balances, credit positions, and loop positions are migrated automatically. Just check your wallet at [app.baseline.markets/portfolio](https://app.baseline.markets/portfolio) once migration is complete. *** ## When will trading start? Once the tokens are migrated and deployed, we will do quick verification checks & unlock. Tokens will become instantly tradable. *** ## I hold BLT, FLAPPY, AI, BSR, YES or ONYX. What happens to my positions? All supported tokens are migrating. Spot balances transfer 1:1. Credit and loop positions carry over with the same economics. No action required before migration. After migration, check [app.baseline.markets/portfolio](https://app.baseline.markets/portfolio) for your updated positions. **NO ACTION REQUIRED**. Just check your wallets when the migration is finished. *** ## Will the floor price (BLV) change? No. The pool reserves that back the floor are migrated to Mercury as part of the same process. Your floor price carries over at its current level. The BLV on Mercury will reflect the same reserve-to-supply ratio as the legacy pool at the time of migration. *** ## Will the token contract address change? Yes. Mercury uses new contract deployments, so all token and pool addresses will change. We will publish a single source-of-truth post with all new addresses once migration is complete. Update any watchlists, bots, or dashboards using old addresses. *** ## Where can I check my positions? All information for your wallets will be available at [app.baseline.markets/portfolio](https://app.baseline.markets/portfolio) after migration. *** ## Can I get liquidated if I borrow or use leverage on the new Mercury upgrade? No. Baseline Mercury has no liquidations. Borrow and leverage positions do not expire and accrue no interest. Opening a credit position (by borrowing or leveraging) costs a one-time 1% origination fee. Repaying debt and unlooping have no fee. *** ## I borrowed and also looped on the old protocol. What does it mean that loops and borrowed balances are combined into a single Credit balance? On legacy YES, borrowing and looping were tracked in two different modules (Credit facility and Loop facility). Migration does not change the economics: your collateral and debt are carried over 1:1. On Mercury, that exposure is shown as one Credit position: a single collateral figure and a single debt figure instead of separate Credit vs Loop lines. Your net position is preserved. If you used both, you will see the totals combined in [app.baseline.markets/portfolio](https://app.baseline.markets/portfolio) after migration. *** ## How can I launch a Baseline token? Chat with us in Discord: [https://discord.com/invite/baseline](https://discord.com/invite/baseline) # Terms of Service (/docs/resources/tos) Last Updated: Feb 21, 2025 These terms of use are entered into by and between you and the Baseline Markets (including all affiliates and subsidiaries, collectively referred to as, "Baseline Markets," "we," "us," or "our"). The following terms and conditions, together with any documents they expressly incorporate by reference (collectively, these "Terms of Use"), govern your access to and use of baseline.markets, including, but not limited to, any content, functionality, and services offered on or through baseline.markets (collectively, the "Website"). Please read the Terms of Use carefully before you start to use the Website. By using the Website or by clicking to accept or agree to the Terms of Use when this option is made available to you, you accept and agree to be bound and abide by these Terms of Use. If you do not agree to these Terms of Use, you must not access or use the Website. We may revise and update these Terms of Use from time to time in our sole discretion. All changes are effective immediately when we post them. Your continued use of the Website following the posting of revised Terms of Use means that you accept and agree to the changes. You are expected to check this page frequently so you are aware of any changes, as they are binding on you. ## Prohibited Uses You may use the Website only for lawful purposes and in accordance with these Terms of Use. You agree not to use the Website: In any way that violates any applicable federal, state, local, or international law or regulation (including, without limitation, any laws regarding the export of data or software to and from the United States or other countries); For the purpose of exploiting, harming, or attempting to exploit or harm minors in any way by exposing them to inappropriate content, asking for personally identifiable information or otherwise; To send, knowingly receive, upload, download, use, or re-use any material which does not comply with these Terms of Use; To transmit, or procure the sending of, any advertising or promotional material without our prior written consent, including any "junk mail", "chain letter", "spam", or any other similar solicitation; To impersonate or attempt to impersonate Baseline Markets, a contractor of Baseline Markets, another user, or any other person or entity (including, without limitation, by using e-mail addresses or screen names associated with any of the foregoing); and To engage in any other conduct that restricts or inhibits anyone's use or enjoyment of the Website, or which, as determined by us, may harm Baseline Markets or users of the Website or expose them to liability. Additionally, you agree not to: Use the Website in any manner that could disable, overburden, damage, or impair the Website or interfere with any other party's use of the Website, including their ability to engage in real time activities through the Website; Use any robot, spider, or other automatic device, process or means to access the Website for any purpose, including monitoring or copying any of the material on the Website; Use any manual process to monitor or copy any of the material on the Website or for any other unauthorized purpose without our prior written consent; Use any device, software or routine that interferes with the proper working of the Website; Introduce any viruses, trojan horses, worms, logic bombs, or other material which is malicious or technologically harmful; Attempt to gain unauthorized access to, interfere with, damage, or disrupt any parts of the Website, the server(s) on which the Website is stored, or any server, computer or database connected to the Website; Attack the Website via a denial-of-service attack or a distributed denial-of-service attack; and otherwise attempt to interfere with the proper working of the Website. ## Reliance on Information Posted The information presented on or through the Website is made available solely for general information purposes. We do not warrant the accuracy, completeness or usefulness of this information. Any reliance you place on such information is strictly at your own risk. We disclaim all liability and responsibility arising from any reliance placed on such materials by you or any other visitor to the Website, or by anyone who may be informed of any of its contents. The Website may include content provided by third parties, including materials provided by third-party licensors, syndicators, aggregators, and/or reporting services. All statements and/or opinions expressed in these materials, other than the content provided by Baseline Markets, are solely the opinions and the responsibility of the person or entity providing those materials. These materials do not necessarily reflect the opinion of Baseline Markets. We are not responsible, or liable to you or any third party, for the content or accuracy of any materials provided by any third parties. ## Changes to the Website We may update the content on the Website from time to time, but its content is not necessarily complete or up-to-date. Any of the material on the Website may be out of date at any given time, and we are under no obligation to update such material. All information we collect on the Website is subject to our Privacy Policy. By using the Website, you consent to all actions that may be taken by us with respect to your information in compliance with the Privacy Policy. You may link to our homepage, provided you do so in a way that is fair and legal and does not damage our reputation or take advantage of it, but you must not establish a link in such a way as to suggest any form of association, approval or endorsement on our part without our express written consent. If the Website contains links to other sites and resources provided by third parties, these links are provided for your convenience only. This includes links contained in advertisements, including banner advertisements and sponsored links. We have no control over the contents of those sites or resources, and accept no responsibility for them or for any loss or damage that may arise from your use of them. If you decide to access any of the third party websites linked to the Website, you do so entirely at your own risk and subject to the terms and conditions of use for such Website. We reserve the right to withdraw linking permission without notice. ## Disclaimer of Warranties You understand that we cannot and do not guarantee or warrant that files available for downloading from the internet or the Website will be free of viruses or other destructive code. You are responsible for implementing sufficient procedures and checkpoints to satisfy your particular requirements for anti-virus protection and accuracy of data input and output, and for maintaining a means external to our site for any reconstruction of any lost data. WE WILL NOT BE LIABLE FOR ANY LOSS OR DAMAGE CAUSED BY A DISTRIBUTED DENIAL-OF-SERVICE ATTACK, VIRUSES, OR OTHER TECHNOLOGICALLY HARMFUL MATERIAL THAT MAY INFECT YOUR COMPUTER EQUIPMENT, COMPUTER PROGRAMS, DATA, OR OTHER PROPRIETARY MATERIAL DUE TO YOUR USE OF THE WEBSITE OR ANY SERVICES OR ITEMS OBTAINED THROUGH THE WEBSITE OR TO YOUR DOWNLOADING OF ANY MATERIAL POSTED ON IT, OR ON ANY WEBSITE LINKED TO IT. YOUR USE OF THE WEBSITE, THEIR CONTENT AND ANY SERVICES OR ITEMS OBTAINED THROUGH THE WEBSITE IS AT YOUR OWN RISK. THE WEBSITE, THEIR CONTENT AND ANY SERVICES OR ITEMS OBTAINED THROUGH THE WEBSITE IS PROVIDED ON AN "AS IS" AND "AS AVAILABLE" BASIS, WITHOUT ANY WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED. NEITHER Baseline Markets NOR ANY PERSON ASSOCIATED WITH Baseline Markets MAKES ANY WARRANTY OR REPRESENTATION WITH RESPECT TO THE COMPLETENESS, SECURITY, RELIABILITY, QUALITY, ACCURACY, OR AVAILABILITY OF THE WEBSITE. WITHOUT LIMITING THE FOREGOING, NEITHER Baseline Markets NOR ANYONE ASSOCIATED WITH Baseline Markets REPRESENTS OR WARRANTS THAT THE WEBSITE, THEIR CONTENT OR ANY SERVICES OR ITEMS OBTAINED THROUGH THE WEBSITE WILL BE ACCURATE, RELIABLE, ERROR-FREE OR UNINTERRUPTED, THAT DEFECTS WILL BE CORRECTED, THAT THE WEBSITE OR THE SERVER(S) THAT MAKES THEM AVAILABLE ARE FREE OF VIRUSES OR OTHER HARMFUL COMPONENTS OR THAT THE WEBSITE OR ANY SERVICES OR ITEMS OBTAINED THROUGH THE WEBSITE WILL OTHERWISE MEET YOUR NEEDS OR EXPECTATIONS. Baseline Markets HEREBY DISCLAIMS ALL WARRANTIES OF ANY KIND, WHETHER EXPRESS OR IMPLIED, STATUTORY, OR OTHERWISE, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, NON-INFRINGEMENT, AND FITNESS FOR PARTICULAR PURPOSE. SOME JURISDICTIONS DO NOT ALLOW EXCLUSION OF WARRANTIES OR LIMITATIONS ON THE DURATION OF IMPLIED WARRANTIES, SO THE ABOVE DISCLAIMER MAY NOT APPLY TO YOU IN THEIR ENTIRETIES, BUT WILL APPLY TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW. ## Limitation on Liability IN NO EVENT WILL Baseline Markets, ITS AFFILIATES OR THEIR LICENSORS, SERVICE PROVIDERS, EMPLOYEES, AGENTS, OFFICERS, OR DIRECTORS BE LIABLE FOR DAMAGES OF ANY KIND, UNDER ANY LEGAL THEORY, ARISING OUT OF OR IN CONNECTION WITH YOUR USE, OR INABILITY TO USE, THE WEBSITE, ANY WEBSITE LINKED TO THEM, ANY CONTENT ON THE WEBSITE OR SUCH OTHER WEBSITE OR ANY SERVICES OR ITEMS OBTAINED THROUGH THE WEBSITE OR SUCH OTHER WEBSITE, INCLUDING ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, CONSEQUENTIAL OR PUNITIVE DAMAGES, INCLUDING BUT NOT LIMITED TO, PERSONAL INJURY, PAIN AND SUFFERING, EMOTIONAL DISTRESS, LOSS OF REVENUE, LOSS OF PROFITS, LOSS OF BUSINESS OR ANTICIPATED SAVINGS, LOSS OF USE, LOSS OF GOODWILL, LOSS OF DATA, AND WHETHER CAUSED BY TORT (INCLUDING NEGLIGENCE), BREACH OF CONTRACT OR OTHERWISE, EVEN IF FORESEEABLE. THE FOREGOING DOES NOT AFFECT ANY LIABILITY WHICH CANNOT BE EXCLUDED OR LIMITED UNDER APPLICABLE LAW WHICH MAY INCLUDE FRAUD. ## Indemnification You agree to defend, indemnify, and hold harmless Baseline Markets, its affiliates, licensors, and service providers, and its and their respective officers, directors, employees, contractors, agents, licensors, suppliers, successors, and assigns from and against any claims, liabilities, damages, judgments, awards, losses, costs, expenses, or fees (including reasonable attorneys' fees) arising out of or relating to your violation of these Terms of Use or your use of the Website, including, but not limited to, any use of the Website content, services and products other than as expressly authorized in these Terms of Use or your use of any information obtained from the Website. ## Governing Law and Jurisdiction All matters relating to the Website and these Terms of Use and any dispute or claim arising therefrom or related thereto (in each case, including non-contractual disputes or claims), shall be governed by and construed in accordance with the internal laws of the Cayman Islands without giving effect to any choice or conflict of law provision or rule (whether of the Cayman Islands or any other jurisdiction). Any dispute arising out of or in connection with the Website and these Terms of Use, including any question regarding its existence, validity or termination, shall be referred to and finally resolved by arbitration under the rules of the London Court of International Arbitration ("LCIA"), which rules are deemed to be incorporated by reference into this clause. The number of arbitrators shall be one. The seat, or legal place, of arbitration shall be London, United Kingdom. The language to be used in the arbitration shall be English. You and Baseline Markets agree to submit all Disputes between you and Baseline Markets to individual binding arbitration. "Dispute" means any dispute, claim, or controversy between you and Baseline Markets that relates to the Website and these Terms of Use. If a Dispute must be arbitrated, you or Baseline Markets must start arbitration of the Dispute within one (1) year from when the Dispute first arose. If applicable law requires you to bring a claim for a Dispute sooner than one (1) year after the Dispute first arose, you must start arbitration in that earlier time period. Baseline Markets encourages you to tell us about a Dispute as soon as possible so we can work to resolve it. The failure to provide timely notice will bar all claims. In any Dispute, the arbitrator will award to the prevailing party, if any, the costs and attorneys' fees reasonably incurred by the prevailing party in connection with those aspects of its claims or defenses on which it prevails, and any opposing awards of costs and legal fees awards will be offset. Any breach by you of these Terms of Use could cause Baseline Markets irreparable harm for which it has no adequate remedies at law. Accordingly, Baseline Markets is entitled to seek specific performance or injunctive relief for any such breach. Nothing in this section will preclude Baseline Markets from seeking specific performance or injunctive relief from a court of appropriate jurisdiction. ## Waiver and Severability No waiver by Baseline Markets of any term or condition set forth in these Terms of Use shall be deemed a further or continuing waiver of such term or condition or a waiver of any other term or condition, and any failure of Baseline Markets to assert a right or provision under these Terms of Use shall not constitute a waiver of such right or provision. If any provision of these Terms of Use is held by a court or other tribunal of competent jurisdiction to be invalid, illegal, or unenforceable for any reason, such provision shall be eliminated or limited to the minimum extent such that the remaining provisions of the Terms of Use will continue in full force and effect. ## Entire Agreement The Terms of Use, our Privacy Policy and other terms and conditions applicable at the time you access the Website constitute the sole and entire agreement between you and Baseline Markets with respect to the Website and supersede all prior and contemporaneous understandings, agreements, representations and warranties, both written and oral, with respect to the Website. # Capital Formation Theory (/docs/theory/capital-formation) This page archives the theoretical framework for understanding how Baseline fits into broader capital formation patterns. ## Why Token Markets Are Broken In traditional markets, these four components are owned by separate entities with conflicting incentives: * **Fundraising**: Capital forms off-market through private rounds, or IPOs managed by banks * **Market structure**: Market makers are third-party intermediaries providing liquidity for self-interested reasons * **Price discovery**: Exchanges match orders without knowledge of the underlying capital structure, creating disconnected price signals * **Balance sheet**: Balance sheets are opaque and controlled by management, or through offchain accounting and corporate filings Capital formation in crypto has evolved through several phases: | Era | Mechanism | Problem | | ---------------------------- | ---------------------------- | -------------------------------------- | | **ICOs** | Crowdsales with no liquidity | No price discovery mechanism | | **Traditional AMMs** | xy=k pools, LP tokens | Value extraction, impermanent loss | | **Protocol-Owned Liquidity** | Bonds, DAO-owned LP | Vague definition, varied goals | | **Token-Owned Liquidity** | Baseline | Native balance sheets, designed growth | Each attempt merged some components, but with limited success: * ICOs disconnect fundraise from liquidity bootstrapping. Projects raise capital, but still depend on professional market makers or exchanges to facilitate liquidity and trading * AMMs provided a 24/7 liquidity solution with bonding curves, but require projects to rent liquidity via pool2 incentives, adding downward pressure on the token's price through continued emissions * AMMs provide no backing guarantees, and perform poorly at price discovery, creating volatility and easy manipulation. Any value accrual is extracted by professional traders, leaving nothing for the token itself. The token price ends up looking like a pump-and-dump, losing trust with community and hurting the project's brand reputation This explains why [over 85% of tokens](https://x.com/mementoresearch/status/2003089388511604744) trade below their launch price. ## The Four Components Framework Every market, whether stocks, bonds, or tokens, operates through four interconnected components: 1. **Fundraising** is where money enters the system. In traditional markets, this happens through IPOs, private rounds, or bond issuance. In crypto, it's presales, ICOs, or fair launches. 2. **Balance Sheet** is where value is stored and accounted for. In traditional markets, this is done offchain in corporate filings and accounting departments. In crypto, this is done onchain either through multisigs or DAOs. 3. **Market Structure** defines liquidity depth, where it concentrates, how much supply should be sold (or be bought back), and encodes rules for updating based on order flows. In traditional markets, this is done through large exchanges (e.g. NYSE, NASDAQ) and order books. In crypto, this can be done through Centralized Exchanges (CEX) and order books, or through Decentralized Exchanges (DEX) and Automated Market Makers (AMMs) and liquidity pools. 4. **Price Discovery** is the trade-by-trade process of finding what buyers will pay and sellers will accept. Prices, and thereby volatility, emerge from the interaction of supply available for sale, demand wanting the asset, and the available market structure to support the trade. In traditional markets, this is done with the help of professional market makers (i.e. Citadel). In crypto, this is still done with the help of professional market makers (i.e. Wintermute), but increasingly through algorithmic market makers (i.e. Baseline). ## How Components Interact These four components are tightly coupled and influence each other continuously: * Fundraising enables an initial market structure to emerge * Through liquidity bootstrapping, and a pricing mechanism, the market structure facilitates price discovery * Through marginal price, liquidity depth, and slippage, price discovery either begets more liquidity, or depletes it, thereby influencing the market structure * Through trading activity thanks to a well-designed market structure, the balance sheet is strengthened or weakened, and the market structure is updated accordingly * As balance sheet grows baseline value, and book value, the token becomes more valuable, attracting more fundraising * As price discovery happens, market cap increases, and healthy liquidity depth attracts more fundraising When these components work together, markets are stable and efficient. When they're misaligned, markets become chaotic. ## How Baseline Unifies the Framework Baseline combines fundraising, balance sheet, market structure, and price discovery into a unified system called [Token-Owned Liquidity](/docs/how-it-works/tol): 1. **Token owns Market Structure (Baseline Market Maker)**: Through the [Baseline Market Maker (BMM)](/docs/how-it-works/bmm), the token manages its own liquidity using a custom bonding curve. Unlike Uniswap's constant-product formula that spreads liquidity thin, BMM creates capital-efficient markets that take into account circulating supply and price. 2. **Token owns Balance Sheet (Baseline Value)**: Through the [Baseline Value (BLV)](/docs/how-it-works/blv), reserves back a guaranteed floor price that can only increase. Unlike traditional tokens with no backing, BLV is intrinsic value guaranteed by the token. 3. **Token guides Price Discovery**: Because the token controls its own liquidity, it sets the depth, slippage, and marginal price of the token. Furthermore, since it's circulating supply aware, it can adjust liquidity to optimize for value accretion. 4. **Trading activity strengthens the system**: Through fee capture and floor growth, every trade increases the token's value. By owning the liquidity, the token owns all trading fees, making it a revenue-generating asset. The fees go to raising BLV over time, and increasing the token's book value. # Token-Owned Liquidity (TOL) (/docs/theory/tol) Token-Owned Liquidity (TOL) means the **token itself owns and manages its liquidity position**. Instead of renting liquidity from external market makers or incentivizing mercenary liquidity providers, the token maintains its own market. This is Baseline's answer to the capital formation problem: balance sheets should be **native to the market**. ## Why TOL Matters Historically, tokens externalized liquidity management in a variety of ways: * **Professional market makers**: Projects partner with professional market makers to manage their liquidity pool. The terms of the deal are signed off-chain and are often expensive, requiring projects to give up a percent of their supply to the market maker, either at the time of the deal, or structured as call options. * **Initial Exchange Offerings (IEOs)**: Projects partner with centralized exchanges to list their token. This creates a dependency on the exchange for liquidity and trading. These deals are often slow and, even worse, require projects to give up a percent of their supply to the exchange. * **Rented liquidity**: Projects incentivize transient liquidity with token emissions that get farmed and dumped. Pool2 farming, popular in DeFi summer, is a prime example. * **Automated Liquidity Management (ALM)**: Projects use automated liquidity management services to manage their liquidity pool. These services are a combination of rented liquidity and professional market making, suffering from the same issues. In all cases, externalizing liquidity management makes liquidity an ongoing cost to the project, and ensures that any value built up through trading gets extracted by third parties. Projects that have tried to internalize liquidity management quickly realized the challenge of working with AMMs. For example, poorly configured xy=k curves quote price per token that vastly undervalues the token in low float scenarios. Launching the pools yourself runs the risk of selling supply for cheap or getting supply sniped. In all cases, the project is forced to pay a premium in form of opportunity cost, that may be difficult to recover from. Token-Owned Liquidity solves these issues by internalizing the responsibilities of liquidity management, and aligning the rules to token value. | Aspect | Rented Liquidity | TOL (Baseline) | | ------------------ | --------------------- | ------------------------ | | **Ownership** | Market makers | Token itself | | **Costs** | Ongoing payments | None | | **Fee Capture** | Lost to third parties | Revenue-generating asset | | **Floor Price** | None | Guaranteed BLV | | **Sustainability** | Mercenary | Structural | **Key Insight:** Whereas traditional launchpads let you launch tokens, Baseline lets you launch tokens that grow in value over time. This is uniquely possible because the token owns its liquidity. ## How TOL Works Token-Owned Liquidity uses circulating supply, pool inventory and total supply to maintain an internal balance sheet, with assets and liabilities tracked onchain. ### Supply Accounting The token's total supply is split into pool inventory and circulating supply: $$ x + c = X_{total} $$ Where: * $x$ = pool inventory (tokens owned by protocol) * $c$ = circulating supply (tokens held by users) * $X_{total}$ = total supply Pool inventory is an asset (disposable, no liabilities) while circulating supply is a liability (must be redeemable at [BLV](/docs/how-it-works/blv)). ### Reserve Accounting The reserves in the liquidity pool are split into backing reserves and buffer reserves: $$ y = y_{backing} + y_{buffer} $$ Where: * $y_{backing}$ = backing reserves (guarantee redemption at floor) * $y_{buffer}$ = buffer reserves (enable price discovery) The protocol treats backing reserves as non-negotiable assets that must be allocated to buyback the entire circulating supply at the floor price. The buffer reserves are the speculative portion, allocated intelligently to support price discovery above the floor. Reserves Curve showing backing and buffer reserves The x-axis represents pool inventory and y-axis represents total reserves. The blue area represents the backing reserves required to buyback circulating supply at the floor. The green area represents the buffer reserves available for price discovery. The sum of both areas equals total reserves. ### Baseline Value (BLV) The Baseline Value (BLV) is the guaranteed floor price, defined as backing reserves divided by circulating supply: $$ P_{blv} = \frac{y_{backing}}{c} $$ BLV is the minimum price at which any holder can exit, regardless of market conditions. Learn more about [BLV](/docs/how-it-works/blv). ### Book Price The book price is total reserves divided by circulating supply: $$ P_{book} = \frac{y}{c} $$ Book price represents the total value backing each circulating token, including both guaranteed floor and speculative buffer. ## Benefits of TOL * **Transparency**: All liquidity, reserves, and accounting are onchain and verifiable. No off-chain deals or hidden terms. * **Guarantees**: Every token has a guaranteed floor price (BLV) that can only increase. Holders always have an exit. * **Programmability**: Liquidity rules are encoded in smart contracts, enabling composability with other DeFi protocols like borrowing and leverage. * **Revenue-generating**: Trading fees flow to the token's balance sheet, increasing BLV over time. Your token becomes a revenue-generating asset instead of paying market makers to provide liquidity.