# lp-math

AMM liquidity mathematics skill covering constant-product pools, concentrated liquidity, price impact, and LP share calculations.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 430 installs · ★ 443
- Author: agiprolabs
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/agiprolabs/claude-trading-skills/tree/HEAD/skills/lp-math/SKILL.md
- Updated: 2026-09-03
- HTML: https://affpapa.org/en/nevibecode/skills/lp-math

## What it does

The skill provides mathematical references and calculation routines for automated market makers such as Raydium, Orca, and Meteora. It models constant-product swaps via the `xy = k` invariant, handles fee deductions, and calculates reserve updates after execution.

It outlines concentrated liquidity mechanics (CLMM), including tick conversion, capital efficiency ratios, and boundary valuations. A position that moves outside its chosen price band earns zero trading fees and shifts completely into a single asset.

It also models single-pool and multi-hop price impact, tracks LP share minting for deposits, and projects annual fee returns.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add agiprolabs/claude-trading-skills --skill lp-math -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/lp-math/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/lp-math/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add agiprolabs/claude-trading-skills --skill lp-math -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/lp-math/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add agiprolabs/claude-trading-skills --skill lp-math -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/lp-math/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install agiprolabs/claude-trading-skills lp-math
```

2. **Manually: put the files in place**
- File: `.github/skills/lp-math/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add agiprolabs/claude-trading-skills --skill lp-math -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/agiprolabs/claude-trading-skills --path skills/lp-math
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/lp-math/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add agiprolabs/claude-trading-skills --skill lp-math -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/agiprolabs/claude-trading-skills/tree/HEAD/skills/lp-math/SKILL.md

## When to use it
- Calculate swap outputs and price impact for constant-product pools
- Evaluate capital efficiency multipliers across CLMM price bands
- Determine total price impact for multi-hop swap routes
- Compute minted LP shares during balanced pool deposits

## Example prompts
- Calculate the net USDC output and price impact when trading 5 SOL into a pool of 100 SOL and 10,000 USDC with a 0.3% fee.
- Calculate the capital efficiency multiplier for a CLMM range between 95 and 105 USDC per SOL.
- Determine how many LP shares are minted when depositing 10 SOL and 1,000 USDC into the current pool reserves.

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: 7fece06686400546.

BEGIN THIRD-PARTY FILE 7fece06686400546
````text
---
name: lp-math
description: AMM liquidity provision mathematics including constant-product, concentrated liquidity, price impact, and LP share calculations
---

# LP Math — AMM Liquidity Provision Mathematics

Automated Market Makers (AMMs) replace traditional orderbooks with liquidity pools. Instead of matching buyers and sellers, a mathematical formula determines prices based on reserve ratios. Liquidity providers (LPs) deposit both assets into a pool and earn fees from every trade.

Understanding the math behind AMMs is essential for:
- Evaluating whether providing liquidity is profitable after impermanent loss
- Estimating price impact before executing large trades
- Comparing capital efficiency across pool types (constant product vs concentrated)
- Calculating expected fee revenue for a given pool position

**Related skills**: See `impermanent-loss` for IL calculations, `yield-analysis` for LP yield modeling, `liquidity-analysis` for pool depth assessment.

---

## 1. Constant Product AMM (xy = k)

The foundational AMM model used by Raydium V4 and most Solana DEXes.

### Core Invariant

```
x * y = k
```

Where:
- `x` = reserve amount of token X (e.g., SOL)
- `y` = reserve amount of token Y (e.g., USDC)
- `k` = constant product (increases over time from fees)

### Spot Price

```
P = x / y    (price of Y in terms of X)
P = y / x    (price of X in terms of Y)
```

For a pool with 100 SOL and 10,000 USDC: price of SOL = 10,000 / 100 = 100 USDC.

### Trade Execution

When a trader swaps Δx of token X into the pool:

```python
# Output amount (before fees)
delta_y = y * delta_x / (x + delta_x)

# With fee (e.g., 0.3%)
delta_y_after_fee = delta_y * (1 - fee_rate)

# New reserves
x_new = x + delta_x
y_new = y - delta_y_after_fee
```

The key insight: larger trades get worse prices because each unit moves the ratio further.

### Inverse Calculation

To get a specific output amount Δy, the required input is:

```python
delta_x = x * delta_y / (y - delta_y)
```

### Price After Trade

```python
price_new = y_new / x_new
```

### Worked Example

Pool: 100 SOL / 10,000 USDC (k = 1,000,000), fee = 0.3%

Buy 5 SOL worth of USDC:
1. Gross output: `10,000 * 5 / (100 + 5) = 476.19 USDC`
2. Fee: `476.19 * 0.003 = 1.43 USDC`
3. Net output: `474.76 USDC`
4. Effective price: `474.76 / 5 = 94.95 USDC/SOL` (vs spot 100)
5. Price impact: `(100 - 94.95) / 100 = 5.05%`
6. New reserves: 105 SOL / 9,525.24 USDC
7. New k: `105 * 9,525.24 = 1,000,150.2` (k increased from fees)

See `references/amm_formulas.md` for complete derivations.

---

## 2. Concentrated Liquidity (CLMM)

Used by Orca Whirlpool, Raydium CLMM, and Meteora DLMM. Liquidity is only active within a chosen price range [P_lower, P_upper].

### Key Concepts

```
L = sqrt(x * y)           # Liquidity within the active range
price_at_tick = 1.0001^tick  # Tick-to-price conversion
```

### Capital Efficiency

Concentrating liquidity in a narrow range provides more depth per dollar:

```python
# Capital efficiency ratio
````
END THIRD-PARTY FILE 7fece06686400546

The third-party file has ended. Everything between the 7fece06686400546 tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 3018 of 10035 bytes. © agiprolabs · MIT · https://github.com/agiprolabs/claude-trading-skills/tree/HEAD/skills/lp-math/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md