add lbps simulator and break down use cases

docs/.vuepress/components/Tools.vue

@@ -82,13 +82,6 @@ const coreTools = [
 ];
 
 const calculatorsAndDApps = [
-  {
-    title: 'Xeonus and Zen Dragon Tools',
-    icon: '/images/logo-light.svg',
-    details:
-      'veBAL, Impermanent Loss and Price Impact Calculators - created by Xeonus and Zen Dragon',
-    link: 'https://balancer.tools/veBAL',
-  },
   {
     title: 'veBAL Gauge Multivoter',
     icon: '/images/toolshub/zekraken.jpg',
@@ -118,18 +111,18 @@ const calculatorsAndDApps = [
     link: 'https://tools.balancer.blue/internalmanager',
   },
   {
-    title: 'Custom Pool Metadata',
+    title: 'Stable Swap Simulator',
     icon: '/images/toolshub/balancer-symbol.svg',
     details:
-      'Tool for owners to be able to add custom metadata to their pools - created by Bleu',
-    link: 'https://tools.balancer.blue/metadata/',
+      'Dashboard to visualize the impact of changes in the Amplification Factor on Balancer Stable-Like Pools - created by Bleu',
+    link: 'https://tools.balancer.blue/stableswapsimulator',
   },
   {
-    title: 'Stable Swap Simulator',
+    title: 'LBP simulator',
     icon: '/images/toolshub/balancer-symbol.svg',
     details:
-      'Dashboard to visualize the impact of changes in the Amplification Factor on Balancer Stable-Like Pools - created by Bleu',
-    link: 'https://tools.balancer.blue/stableswapsimulator',
+      'Tool created for LBP pool creators, with the goal of facilitating the projection of different scenarios that the pool may follow.',
+    link: 'https://lbp.balancer.fi/',
   },
   // Add more calculators and dApps as needed
 ];
@@ -139,7 +132,7 @@ const analyticsSites = [
     title: 'DeFilytica Analytics',
     icon: '/images/toolshub/defilytica_simple.png',
     details:
-      'Protocol, pool and token metrics. Additionally, an in-depth financial dashboard and service-provider analytics board.',
+      'Protocol, pool and token metrics. Additionally, an in-depth financial dashboard and service-provider analytics board. V2 only ',
     link: 'https://balancer.defilytica.com/',
   },
   {

docs/concepts/explore-available-balancer-pools/liquidity-bootstrapping-pool/.order

@@ -0,0 +1 @@
+1

docs/concepts/explore-available-balancer-pools/liquidity-bootstrapping-pool/fixed-price-lbp.md

@@ -0,0 +1,28 @@
+---
+order: 4
+title: Fixed Price LBP
+---
+
+# Fixed Price LBP
+
+A **Fixed Price LBP** is a Liquidity Bootstrapping Pool that keeps a **constant exchange rate** between the project token and the reserve token for the whole sale. Unlike standard LBPs, there is no scheduled weights changes.
+
+## When to use it?
+
+Use a Fixed Price LBP when you want a **constant-rate token sale**: one project token always costs the same amount of reserve token (1 TOKEN = 10 USDC). Use a **weight-shifting LBP** when you want price discovery (check [Token Launches](./token-launches.md)).
+
+## How it works?
+
+- **Constant price:** The pool uses a fixed rate (e.g. `projectTokenRate`). Swaps are simple: reserve in → project out at that rate (or the reverse, depending on configuration).
+- **Invariant:** The pool uses a constant-sum style invariant: `projectBalance * projectTokenRate + reserveBalance`, i.e. total value in terms of the reserve token. No weighted math or time-dependent weights.
+- **Buy-only (one-way):** Fixed Price LBPs are configured so that only **buying** the project token with the reserve token is allowed. Selling the project token back into the pool is disabled.
+- **Seedless:** Because the sale is one-way, the pool is initialized with **project tokens only**. No reserve tokens are required up front; buyers supply the reserve token when they swap.
+
+## Summary
+
+| Aspect                         | Weight-shifting LBP                              | Fixed Price LBP               |
+| :----------------------------- | :----------------------------------------------- | :---------------------------- |
+| **Price**                      | Changes over time (weight schedule)              | Constant (fixed rate)         |
+| **Use case**                   | Price discovery (launches, divestment, buybacks) | Constant-rate sales           |
+| **Initial liquidity**          | Project + reserve (or seedless for some configs) | Project token only (seedless) |
+| **Selling project token back** | Configurable                                     | Disabled (buy-only)           |

docs/concepts/explore-available-balancer-pools/liquidity-bootstrapping-pool/liquidity-bootstrapping-pool.md

@@ -0,0 +1,81 @@
+---
+order: 0
+title: Liquidity Bootstrapping Pool
+---
+
+# Liquidity Bootstrapping Pools (LBPs)
+
+## Overview
+
+Balancer offers two LBP variants:
+
+- **Weight Shifting LBPs**: Pools that change token weighting over time (e.g. 90/10 → 10/80 project/reserve token). They use Weighted Math with time-dependent weights for price discovery.
+- **[Fixed Price LBP](./fixed-price-lbp.md)**: Pools that keep a constant exchange rate for the whole sale (no weight schedule). Used for constant-rate token sales; buy-only and seedless by default.
+
+The pool owner is the only address that can add liquidity to the pool, which must be done prior to the start of the sale. Furthermore, the proceeds can only be removed after the end time.
+
+## Use Cases (weight-shifting LBPs)
+
+The following use cases rely on **weight-shifting** LBPs (scheduled weights changes). For constant-rate sales, see [Fixed Price LBP](./fixed-price-lbp.md).
+
+### 1. [Token Launches](./token-launches.md)
+
+**Objective:** Fair initial token distribution.
+
+The standard LBP configuration supports price discovery for new tokens via a continuous Dutch-auction-style mechanism. The pool starts with a high project-token weight (e.g., 90% project token / 10% reserve) and gradually shifts over time to a lower project-token weight (e.g., 20% / 80%).
+
+This scheduled reweighting creates controlled downward price pressure, helping distribute tokens more broadly while reducing incentives for bot sniping and whale concentration. Buyers can enter when the price reaches a level they consider fair, rather than rushing into a priority-fee bidding race at launch.
+
+### 2. [Treasury Diversification](./treasury-diversification.md)
+
+**Objective:** Position entry and exit with minimal market impact.
+
+For DAOs and treasuries managing significant capital, LBPs can be used to enter or exit positions over time via a scheduled weight shift. This allows treasuries to:
+
+- **Divest:** Sell large positions with reduced market impact.
+- **Invest:** Accumulate positions in target tokens with reduced market impact.
+
+### 3. [Token Buybacks](./token-buybacks.md)
+
+**Objective:** Efficient protocol token accumulation.
+
+An LBP configured for accumulation inverts the weight logic to create upward price pressure. By starting with high reserve token weight (90% WETH / 10% project token) and shifting toward the project token (10% / 90%), the pool functions as an automated, rising limit order.
+
+## Pool Settings
+
+LBPs are highly configurable. Here are the key parameters and settings, as defined in the pool implementation:
+
+- **Tokens**: LBPs are always two-token pools: the project token (being launched) and the reserve token (e.g., a stablecoin or WETH).
+- **Weights**: The pool owner specifies the starting and ending weights for both tokens. These weights change linearly over time.
+- **Period**: The pool owner sets the `startTime` and `endTime` (timestamps) for the LBP. Swaps are only enabled between these times.
+- **Swaps**: Optionally, the pool can block selling the project token back into the pool (`blockProjectTokenSwapsIn`). This is typically enabled for token launches to prevent manipulation, but disabled for token buybacks where sellers must deposit the project token into the pool.
+- **Trusted Router**: All pool interactions must go through a trusted router to ensure correct sender reporting and security.
+
+## Pool Migration
+
+It is possible to either create a standalone LBP or create one that can easily be migrated to a weighted pool after the operation has concluded. To use this feature the pool factory offers a `createWithMigration` function. For this additional parameters are required:
+
+- `bptLockDuration`: The time in seconds the BPT of the created weighted pool is locked before the liquidity can be removed from the created weighted pool.
+- `bptPercentageToMigrate`: The percentage of the liquidity to be migrated from the LBP to the created weighted pool.
+- `migrationWeightProjectToken`: Defines the weight of the project token in the created weighted pool.
+- `migrationWeightReserveToken`: Defines the weight of the reserve token in the created weighted pool.
+
+The migration happens via the [`LBPMigrationRouter`](https://github.com/balancer/balancer-deployments/tree/master/v3/tasks/20251219-v3-liquidity-bootstrapping-pool-v3).
+
+**Technical Parameters (from the implementation):**
+
+- `projectToken` / `reserveToken`: ERC20 addresses for the tokens.
+- `projectTokenStartWeight` / `reserveTokenStartWeight`: Initial weights (scaled).
+- `projectTokenEndWeight` / `reserveTokenEndWeight`: Final weights (scaled).
+- `startTime` / `endTime`: UNIX timestamps for the sale window.
+- `blockProjectTokenSwapsIn`: Boolean to restrict project token sales.
+- `poolCreator`: The account accruing [pool creator fees](../core-concepts/pool-creator-fee.md)
+- Only two tokens are allowed per pool.
+
+::: tip
+
+**Primary Use Case:** This feature is most commonly used for **Token Launches**, where the LBP concludes with a successful distribution and the project wishes to establish permanent liquidity. By migrating to a reCLAMM or Weighted pool, the project token becomes immediately tradable on Balancer.
+
+:::
+
+---

docs/concepts/explore-available-balancer-pools/liquidity-bootstrapping-pool/token-buybacks.md

@@ -0,0 +1,32 @@
+---
+order: 3
+title: Token Buybacks
+---
+
+# Token Buybacks
+
+The same LBP mechanism can be used to support **accumulation** - buying the project token.
+
+## Mental Model
+
+For DAOs and treasuries, buying back a large amount of a token can be challenging - **market buys** can create abrupt price impact. An LBP buyback configuration approaches this differently: it uses a scheduled weight shift to create a rising bid, and lets arbitrage keep the pool price aligned with external markets.
+
+## Configuration
+
+### 1. Token Setup
+
+- **Reserve token:** The asset the Treasury wishes to spend (e.g., USDC, WETH).
+- **Project token:** The asset the Treasury wishes to acquire.
+
+### 2. Weight Schedule
+
+The weight curve should start with the reserve token dominant.
+
+| Parameter         | Example value                         | Reason                            |
+| :---------------- | :------------------------------------ | :-------------------------------- |
+| **Start weights** | 90% reserve token / 10% project token | Keeps the initial bid low.        |
+| **End weights**   | 30% reserve token / 70% project token | Allows the bid to rise over time. |
+
+### 3. Swap Permissions
+
+Ensure that `blockProjectTokenSwapsIn` is set to `false`. The mechanism relies on external actors swapping the project token _in_ to the pool to extract the reserve token.

docs/concepts/explore-available-balancer-pools/liquidity-bootstrapping-pool/token-launches.md

@@ -0,0 +1,54 @@
+---
+order: 1
+title: Token Launches
+---
+
+# Token Launches
+
+The Liquidity Bootstrapping Pool (LBP) is the standard primitive for initial token distribution. The LBP utilizes time-dependent weights to facilitate fair price discovery and capital efficiency.
+
+::: tip New on Balancer v3: Seedless LBPs
+Token launch LBPs can be configured as **seedless**, meaning they require **no initial liquidity in the reserve token**.
+:::
+
+### Mental Model
+
+You can think of the starting price of your LBP as the ceiling you would want to set for the token sale. This may seem counterintuitive, but since LBPs work differently than other token sales, your starting price should be set much higher than what you believe is the fair price.
+
+This does not mean you are trying to sell the token above what it is worth. Setting a high starting price allows the changing pool weights of your LBP to make their full impact, lowering the price progressively until market equilibrium is reached. Unlike older token sale models, such as bonding curves, users are disincentivized to buy early and instead benefit from waiting for the price to decrease until it reaches a level they believe is fair.
+
+## Advantages
+
+### Capital Efficiency
+
+LBPs can be configured as **seedless**, meaning they require **no initial liquidity in the reserve token**.
+
+### Fair Market Price
+
+LBPs often start with intentionally high prices. This strongly disincentivizes whales and bots from snatching up much of the pool liquidity at the get-go. When LBPs are used for early-stage tokens, this can help increase how widespread the token distribution is.
+
+### Immediate Liquidity
+
+Once the LBP concludes, immediate access to the funds raised is available. The new token holders can immediately trade their token, providing instant liquidity without lengthy lock-up periods.
+
+### Sell Pressure
+
+During a weight shift, the token price of one token experiences sell pressure while the other experiences buy pressure. When this is mixed with modest swap volume, the price approaches the generally agreed-upon market price.
+
+## Configuration
+
+Token launches using LBPs rely on a scheduled **weight shift**.
+
+### Duration
+
+Token launches are typically run over **days** (not weeks or months). A common choice is **48 to 72 hours** (2 to 3 days), which gives participants time to enter without concentrating all activity into a short window.
+
+### Weights
+
+To create the necessary "price ceiling," the **project token** should start with a dominant weight and decrease over time. In practice, avoid weight schedules that go all the way to the extremes (close to 100/0 or 0/100), as pricing becomes highly non-linear near the ends of the range.
+
+## Liquidity Migration
+
+A successful LBP concludes with the **project token** widely distributed and the **reserve token** accumulated in the pool. To transition to a permanent trading venue, use the `createWithMigration` function on the factory.
+
+This allows the migration of liquidity from the LBP to a **concentrated** or **weighted** pool upon conclusion.