# Sushi 🧑‍🍳

## 👨‍👩‍👧‍👦 Community

* [Twitter](https://www.sushi.com/twitter)

* [Discord](https://www.sushi.com/discord)

* [Forum](https://forum.sushi.com)

* [Proposals](https://snapshot.org/#/sushigov.eth)


## 🔗 Ecosystem

TBC


## 🤝 Partnership

...


## 📚 Resources

**Web App:** [https://www.sushi.com](https://www.sushi.com/)

**Forum:** [https://forum.sushi.com](https://forum.sushi.com/)

**Proposals:** [https://snapshot.org/#/sushigov.eth](https://snapshot.org/#/sushigov.eth)

**Academy:** [https://www.sushi.com/academy](https://sushi.com/academy)

**Partner:** [https://www.sushi.com/partner](https://sushi.com/partner)

**Blog:** [https://www.sushi.com/blog](https://sushi.com/blog)

**Token List** [https://www.sushi.com/tokenlist-request](https://www.sushi.com/tokenlist-request).

***

**Track SushiSwap's performance in the DEX space (TVL / Volume):**

* [https://defillama.com/protocol/sushiswap#information](https://defillama.com/protocol/sushiswap#information)

* [https://tokenterminal.com/explorer/projects/sushiswap](https://tokenterminal.com/explorer/projects/sushiswap)


## 🚀 Roadmap

### Q1 2025

#### RouteProcessor6

* Surplus capture support
* Meta pool support
* Generic bridge support
* Generic callback support

#### Blade (fMM)

* Launch of Blade fMM

### Q2 2025

TBC

### Q3 2025

TBC

### Q4 2025

TBC


## 🔒 Security

### Audits

Sushi regularly engages with top-tier auditors to ensure the security of our smart contracts and infrastructure.

### Bug Bounty

[Immunefi](https://immunefi.com/bug-bounty/sushiswap/information)

### Asset Risk Assessment

[Go+ Security](https://gopluslabs.io)

### Contract

[security@sushi.com](mailto\:security@sushi.com)


## ❓ What is Sushi

Sushi, often called SushiSwap, is a popular decentralized finance (DeFi) platform best known for its Automated Market Maker (AMM). It was created in 2020 as a community-driven fork of Uniswap with a unique twist: Sushi integrated additional staking features and governance options via its native token, SUSHI. Over time, it has expanded into a multifaceted ecosystem offering various DeFi products such as an aggregator, an AMM, and token staking mechanisms.

### A Brief History of SushiSwap

SushiSwap was launched in August 2020 and spearheaded by an anonymous developer known as "Chef Nomi," who forked the Uniswap protocol. The project immediately garnered attention thanks to its incentive system, which rewarded liquidity providers with the SUSHI governance token. Early on, Chef Nomi withdrew funds intended for development but later returned them following community backlash. Despite this early controversy, SushiSwap became one of the most recognized DeFi platforms.

### Core Products and Components

#### 1. Aggregator

Sushi's aggregator searches across various decentralized exchanges (DEXs) to find the best token swap prices for users. Rather than swapping on SushiSwap alone, this tool routes trades across multiple liquidity sources to minimize slippage and optimize overall trade execution.

#### 2. AMM (Automated Market Maker)

At the heart of Sushi is its AMM, which powers token swaps by using liquidity pools instead of traditional order books. Liquidity providers (LPs) can deposit pairs of tokens into these pools and earn a share of the trading fees generated whenever someone swaps tokens.

#### 3. The SUSHI Token

SUSHI is the platform's native governance token. It plays multiple roles within the ecosystem:

Governance: Holders can vote on proposals regarding protocol changes and future developments.
Rewards: LPs can receive SUSHI rewards for staking their liquidity pool tokens in Sushi's farms, known as "Onsen."

#### 4. The xSUSHI Token

xSUSHI is a staked version of the SUSHI token. When users stake their SUSHI, they receive xSUSHI, which entitles them to a portion of the protocol fees generated by SushiSwap. Over time, xSUSHI holders see their underlying SUSHI balance grow as transaction fees accumulate and are distributed back to stakers.

Sushi (SushiSwap) has evolved from a simple fork into a fully featured DeFi hub. It incorporates an aggregator for optimal trades, an AMM for permissionless token swaps, and powerful staking options via its SUSHI and xSUSHI tokens. Despite its rocky beginnings, SushiSwap remains an influential and community-driven protocol at the forefront of decentralized finance.


## 🍣 Why Sushi

Sushi (SushiSwap) stands out as a versatile, community-centric decentralized finance (DeFi) platform that offers more than just token swaps. Launched in 2020, Sushi quickly gained traction by combining competitive yields, governance features, and innovative products. Here’s a quick look at why DeFi enthusiasts choose Sushi:

### All-in-One Ecosystem

Sushi isn’t just an Automated Market Maker (AMM) for swapping tokens. It also features a powerful aggregator tool to secure the best prices from various decentralized exchanges, eliminating the hassle of manually searching for optimal trades.

### Rewarding Liquidity Providers

By supplying liquidity to Sushi pools, providers earn a portion of the trading fees—plus potential SUSHI token rewards in special farms. This dual mechanism of fee sharing and token rewards makes liquidity provisioning on Sushi attractive.

### Governance & Community

Sushi’s governance token, SUSHI, allows holders to vote on protocol changes and developmental directions, fostering a strong community-driven environment. Staking SUSHI into xSUSHI further grants holders a share of the platform’s fees.

### Constant Innovation

From yield farming tools to cross-chain integrations, Sushi continually expands its product suite. The community’s active role in proposing and shaping new features helps keep Sushi at the forefront of DeFi innovation.

In short, Sushi offers a comprehensive DeFi experience—blending competitive yields, robust governance, and ongoing innovation—to empower users who want more control over their crypto trading and earning strategies.


import { LinkTable } from '../../components/table'
import { BladeSubgraphTemplateMap } from '../../constants/subgraphs'

## Blade

<LinkTable data={BladeSubgraphTemplateMap} title="Endpoint" />


import { LinkTable } from '../../components/table'
import { BlocksSubgraphTemplateMap } from '../../constants/subgraphs'

## Blocks

<LinkTable data={BlocksSubgraphTemplateMap} title="Endpoint" />


import { LinkTable } from '../../components/table'
import { V3SubgraphTemplateMap } from '../../constants/subgraphs'

## clAMM (SuhiSwap V3)

<LinkTable data={V3SubgraphTemplateMap} title="Endpoint" />


import { LinkTable } from '../../components/table'
import { V2SubgraphTemplateMap } from '../../constants/subgraphs'

## cpAMM (SuhiSwap V2)

<LinkTable data={V2SubgraphTemplateMap} title="Endpoint" />


## xSUSHI

| Network  | Endpoint                                                                                                                                                                                                                                                    |
| -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ETHEREUM | [https://gateway-arbitrum.network.thegraph.com/api/$\{API\_KEY}/deployments/id/QmWisRwB5h2fWMUdGbxQEdqMvVWAiZB1BxsCdoqcsn2Cij](https://gateway-arbitrum.network.thegraph.com/api/$\{API_KEY}/deployments/id/QmWisRwB5h2fWMUdGbxQEdqMvVWAiZB1BxsCdoqcsn2Cij) |


## Installation

Install Sushi via your package manager, a `<script>` tag, or build from source.

### Package Manager

Install the required packages.

:::code-group
```bash [pnpm]
pnpm add sushi viem
```

```bash [npm]
npm install sushi viem
```

```bash [yarn]
yarn add sushi viem
```

```bash [bun]
bun add sushi viem
```
:::

### CDN

If you're not using a package manager, you can also use Sushi via an ESM-compatible CDN such as [esm.sh](https://esm.sh). Simply add a `<script type="module">` tag to the bottom of your HTML file with the following content.

```html
<script type="module">
  import { getSwap, ChainId } from 'https://esm.sh/sushi'

  const swap = await getSwap({
    chainId: ChainId.ETHEREUM,
    tokenIn: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
    tokenOut: '0x6B3595068778DD592e39A122f4f5a5cF09C90fE2',
    amount: 1000000000000000000n,
    maxSlippage: 0.005,
    apiKey: "sushi_abcdefghijklmnopqr"
  })

  console.log(swap)
</script>
```

{/* ```html
  <script type="module">
  import { ChainId, USDC, Amount } from 'https://esm.sh/sushi'

  const amount = Amount.fromRaw(USDC[ChainId.ETHEREUM], 100)

  console.log(amount.toString())
  </script>
  ``` */}


## Price

Get all prices for a given chain:

```ts twoslash
import { ChainId } from 'sushi/generic'
import { getPrices } from 'sushi/evm'

const prices = await getPrices(ChainId.ETHEREUM)
console.log("Prices:", prices)
```

Get price for a given chain and token address:

```ts twoslash
import { ChainId } from 'sushi/generic'
import { getPrice } from 'sushi/evm'

const price = await getPrice(ChainId.ETHEREUM, '0x6b3595068778dd592e39a122f4f5a5cf09c90fe2')
console.log("Price:", price)
```


## Quote

Call the Quote API:

```ts twoslash
import { ChainId } from 'sushi/generic'
import { getQuote } from 'sushi/evm'

// Get a quote from the API
const data = await getQuote({
  chainId: ChainId.ETHEREUM, // ethereum chain id
  tokenIn: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE', // eth token
  tokenOut: '0x6B3595068778DD592e39A122f4f5a5cF09C90fE2', // sushi token
  amount: 1000000000000000000n, // 1 eth
  maxSlippage: 0.005, // 0.05% max slippage
})
console.log(data)
```


## Swap

Call the Swap API and simulate the result:

```ts twoslash
import { ChainId } from 'sushi/generic'
import { getSwap } from 'sushi/evm'
import { createPublicClient, createWalletClient, http, type Hex } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

const publicClient = createPublicClient({
  chain: mainnet,
  transport: http(),
})

// Get a swap from the API
const data = await getSwap({
  chainId: ChainId.ETHEREUM, // ethereum chain id
  tokenIn: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE', // eth token
  tokenOut: '0x6B3595068778DD592e39A122f4f5a5cF09C90fE2', // sushi token
  sender: '0x', // replace with your own address
  amount: 1000000000000000000n, // 1 eth
  maxSlippage: 0.005, // 0.05% max slippage
})
console.log(data)

// If the swap status is 'Success'
if (data.status === 'Success') {
  const { tx } = data
  // Simulate a call to the blockchain for the swap
  const callResult = await publicClient.call({
    account: tx.from,
    data: tx.data,
    to: tx.to,
    value: tx.value,
  })
  // Returns the simulated amount out
  console.log('Output: ', callResult)
 
  // Send a transaction
  const PRIVATE_KEY = process.env.PRIVATE_KEY as Hex
  const walletClient = createWalletClient({
    chain: mainnet,
    transport: http(),
  })
  const hash = await walletClient.sendTransaction({ 
    account: privateKeyToAccount(PRIVATE_KEY),
    data: tx.data,
    to: tx.to,
    value: tx.value,
  })
  console.log('Tx: ', hash)
}
```


## Viem

Extending viem with sushi actions.

```ts
import { createPublicClient, createWalletClient, http } from 'viem'
import { mainnet } from 'viem/chains'
import { publicActions, walletActions } from 'sushi'
 
const publicClient = createPublicClient({
  chain: mainnet,
  transport: http()
}).extends(publicActions)
const { request } = await client.simulateProcessRoute()
  .then(console.log)
  .catch(console.error)

const account = privateKeyToAccount('PRIVATE_KEY')
const walletClient = createWalletClient({
  account,
  chain: mainnet,
  transport: http()
}).extends(walletActions)
await client.processRoute(request)
  .then(console.log)
  .catch(console.error)

```


## Amount

An `Amount` represents a quantity of a specific currency/token using an integer `amount` (raw units) and a `currency` that carries decimals and metadata.

* `currency`: The currency or token this amount is for.
* `amount`: The raw integer value (`bigint`), typically smallest units (e.g. wei).

```ts twoslash
import { Amount } from 'sushi/generic'
import { EvmToken } from 'sushi/evm'

const USDC = new EvmToken({
  chainId: 1,
  address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
  symbol: 'USDC',
  name: 'USD Coin',
  decimals: 6,
})

// Construct from raw units (smallest unit)
const raw = new Amount(USDC, 1_000_000n) // 1.0 USDC

// Construct from human-readable value (respects currency.decimals)
const a = Amount.fromHuman(USDC, '1.5')   // 1.5 USDC -> 1_500_000n
const b = Amount.fromHuman(USDC, 2.25)    // 2.25 USDC -> 2_250_000n
```

### Creating Amounts

* From raw integer: `new Amount(currency, bigint | number | string)` // Throws on invalid, e.g. non-integer
* From human value: `Amount.fromHuman(currency, bigint | number | string)` // Throws on invalid
* Safe parse: `Amount.tryFromHuman(currency, value) // returns undefined on invalid`

```ts twoslash
import { Amount } from 'sushi/generic'

// @noErrors
const amt = new Amount(USDC, 500_000n) // 0.5 USDC
const fromStr = Amount.fromHuman(USDC, '0.000001') // 1 micro USDC
const maybe = Amount.tryFromHuman(USDC, 'not-a-number') // undefined
```

### Arithmetic

All operations return a new `Amount` and keep the left-hand side currency.

* Add/Subtract: `add`, `sub`, `addHuman`, `subHuman`
* Multiply/Divide: `mul`, `mulHuman`, `div`
* Fractional division: `divToFraction()` returns a precise `Fraction` ratio

```ts twoslash
import { Amount, Fraction } from 'sushi/generic'

// @noErrors
const one = Amount.fromHuman(USDC, '1')
const half = Amount.fromHuman(USDC, '0.5')

const sum = one.add(half)              // 1.5 USDC
const sum2 = one.addHuman('0.25')      // 1.25 USDC
const diff = one.sub(half)             // 0.5 USDC

const times = one.mulHuman('2.5')      // 2.5 USDC
const halfDiv = one.div('2')           // 0.5 USDC

// Use Fraction for ratios without rounding the divisor
const priceImpact = new Fraction({ numerator: 3n, denominator: 2n })
const impacted = one.mul(priceImpact)  // 1.5 USDC

// For precise ratio of two raw amounts
const ratio = one.divToFraction(half)  // 1 / 0.5 => 2/1
```

### Comparison

* `gt`, `gte`, `lt`, `lte`, `eq` compare raw values.

```ts twoslash
// @noErrors
sum.gt(one)   // true
half.lte(one) // true
```

### Formatting

Convert to human-readable strings using the currency decimals.

* Default: `toString()` is equal to `toString({ fixed: decimals })`.
* Fixed decimals: `toString({ fixed: n })` always shows exactly `n` decimals.
* Maximum decimals: `toString({ maxFixed: n })` shows up to `n` decimals, trimming trailing zeros.
* Significant digits: `toSignificant(n)` keeps `n` significant digits.

```ts twoslash
// @noErrors
one.toString()                 // '1'
one.toString({ fixed: 2 })     // '1.00'
sum.toString({ maxFixed: 6 })  // e.g. '1.5'
sum.toSignificant(4)           // e.g. '1.5'
```

### Serialization

`toJSON()` returns a JSON-safe object `{ currency, amount }` where `amount` is a string.

```ts twoslash
// @noErrors
const json = one.toJSON()
// { currency: { ... }, amount: '1000000' }
JSON.stringify(json)
```

### Wrapping

`wrap()` converts the underlying currency to its wrapped representation and keeps the same raw amount (useful for native -> wrapped token).

```ts twoslash
// @noErrors
const wrapped = one.wrap() // Amount with wrapped currency
```


## Fraction

`Fraction` is a precise rational number type backed by bigint numerators/denominators. Use it for ratios, percentages, and lossless math where floating point could introduce errors.

### Arithmetic & Formatting

Common operations with examples of string formatting and JSON output.

```ts twoslash
import { Fraction } from 'sushi/generic'

const oneHalf = new Fraction({ numerator: 1n, denominator: 2n })
const three = new Fraction(3) // shorthand for 3/1

const sum = oneHalf.add(three)      // 3.5 => 7/2
const diff = three.sub(oneHalf)     // 2.5 => 5/2
const prod = oneHalf.mul(three)     // 1.5 => 3/2
const div  = three.div(oneHalf)     // 6 => 6/1

// Formatting helpers
sum.toSignificant(4)            // '3.5'
sum.toString({ fixed: 2 })      // '3.50'
sum.toString({ maxFixed: 4 })   // '3.5'
sum.toString({ significant: 3 })// '3.5'

// Inversion and JSON
const inv = oneHalf.invert()    // 2/1
inv.toString({ fixed: 0 })      // '2'
// Object vs string forms
sum.toJSON()                    // { n: '7', d: '2' }
```

### Comparison

Relational operators using exact rational arithmetic (no float rounding).

```ts twoslash
import { Fraction } from 'sushi/generic'

const a = new Fraction({ numerator: 1n, denominator: 3n }) // ~0.3333
const b = new Fraction({ numerator: 2n, denominator: 5n }) // 0.4
const c = new Fraction({ numerator: 1n, denominator: 3n }) // equal to a

a.lt(b)   // true
a.lte(b)  // true
a.eq(b)   // false
a.gte(b)  // false
a.gt(b)   // false
a.neq(b)  // true

a.eq(c)   // true
a.lte(c)  // true
a.gte(c)  // true
```


## Primitives

| Primitive            | Summary                                                                                                                               |
| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| [Amount](amount)     | Quantity of a currency/token in raw units (bigint). Human parsing, arithmetic, comparisons, formatting, JSON serialization, wrapping. |
| [Fraction](fraction) | Precise rational numbers (bigint numerator/denominator) for ratios, comparisons, and formatting without float errors.                 |
| [Token](token)       | Base for fungible, addressable currencies. Identity, equality, serialization; extend per-chain (e.g., EVM token).                     |
| [Native](native)     | Base for chain native currency with `wrap()` to the canonical wrapped token. Identity, flags, serialization.                          |


## Native

`Native` is the abstract base for a chain’s native currency (e.g., ETH). It extends `BaseCurrency` and models non-addressable currencies with a `wrap()` method to obtain the canonical wrapped token.

### Features

* Identity: `id = "<chainId>:NATIVE"`
* Flags: `type = 'native'`, `isNative = true`, `isToken = false`
* Wrapping: `wrap()` returns the wrapped token representation (e.g., WETH)
* Serialization: implement `toJSON()` (and optional static `fromJSON`)

Note on metadata: `Native` also supports an optional `metadata` bag just like `Token`. For details on typing, validating, and serializing `metadata`, see [Token](/sdk/primitives/token#metadata).

### Usage Example

On EVM, `EvmNative` implements `wrap()` via the `WNATIVE` map and can be constructed from a chain id.

```ts twoslash
import { EvmNative } from 'sushi/evm'

const eth = EvmNative.fromChainId(1)
eth.isNative        // true
eth.id              // '1:NATIVE'

const weth = eth.wrap() // EvmToken for WETH on chain 1
weth.isToken        // true
```


## Token

`Token` is the abstract base for fungible, addressable currencies. It extends `BaseCurrency` and adds a chain-specific `address`, identity `id`, and equality semantics.

This page explains features and how to extend `Token` for a new network type.

### Features

* Identity: `id = "<chainId>:<address>"` (lowercased address)
* Flags: `type = 'token'`, `isToken = true`, `isNative = false`
* Equality: `isSame(other)` checks chainId, decimals, type, and address
* Serialization: implement `toJSON()` (and an optional static `fromJSON`)
* Wrapping: `wrap()` returns a token (no-op for tokens on most chains)

### Usage Example

On EVM, `EvmToken` extends `Token` and adds helpers like `sortsBefore`.

```ts twoslash
import { EvmToken } from 'sushi/evm'

const USDC = new EvmToken({
  chainId: 1,
  address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
  symbol: 'USDC',
  name: 'USD Coin',
  decimals: 6,
})

USDC.id           // '1:0xa0b8...e48'
USDC.isToken      // true
USDC.isNative     // false
USDC.toJSON()     // stable, JSON-safe shape
```

### Metadata

Currencies support an arbitrary `metadata` bag typed via the generic parameter. This is useful for attaching ancillary data such as a logo URL, tags, price feed hints, etc.

```ts twoslash
import { EvmToken } from 'sushi/evm'

type TokenMetadata = {
  logoURI?: string
  tags?: string[]
  coingeckoId?: string
  origin?: 'native' | 'bridge' | 'celer' | 'stargate' | 'wormhole'
}

const DAI = new EvmToken<TokenMetadata>({
  chainId: 1,
  address: '0x6b175474e89094c44da98b954eedeac495271d0f',
  symbol: 'DAI',
  name: 'Dai Stablecoin',
  decimals: 18,
  metadata: {
    logoURI: 'https://assets.coingecko.com/coins/images/9956/large/4943.png',
    tags: ['stablecoin', 'defi'],
    coingeckoId: 'dai',
    origin: 'native',
  },
})

DAI.metadata.tags?.includes('stablecoin') // true

const json = DAI.toJSON()
json.metadata?.logoURI // preserved in serialized form
```

Note: You don’t need to pre‑type `metadata` — TypeScript infers it from the constructor object. If desired, you can still use a generic or `satisfies { ... }` for stricter typing.

### Validation with Zod

Each concrete token class exposes a Zod schema factory for its serialized shape. On EVM, use `serializedEvmTokenSchema({ metadata })` to validate parsed JSON. You can supply a custom `metadata` schema to enforce structure; if omitted, metadata defaults to a permissive `record(unknown).optional().default({})`.

```ts twoslash
import * as z from 'zod'
import { EvmToken, serializedEvmTokenSchema } from 'sushi/evm'

// Optional: a stricter metadata schema
const metadataSchema = z.object({
  logoURI: z.string().url().optional(),
  tags: z.array(z.string()).optional(),
  coingeckoId: z.string().optional(),
})

// Build the schema for serialized tokens
const schema = serializedEvmTokenSchema({ metadata: metadataSchema })

// Example validation
const input = {
  chainId: 1,
  address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
  symbol: 'USDC',
  name: 'USD Coin',
  decimals: 6,
  type: 'token' as const,
  metadata: {},
}
const parsed = schema.parse(input)

const token = EvmToken.fromJSON(parsed)
```


## 👩‍💻 Developer Portal

### Welcome to the Developer Portal documentation

This page is under construction. 🛠


## 🏛️ Governance

### Model

SushiSwap is governed by its community, which participates in forum discussions and votes on proposals on the SushiSwap Snapshot. Only proposals posted to the Snapshot voting system by the CORE team can be considered binding if passed with a quorum.

The community votes on major DAO structural changes, tokenomics, and the use of the devfund wallet. In contrast, the core team handles organizational operations and changes in the SushiSwap protocol, as mandated in the following proposal:

[https://forum.sushi.com/t/governance-reorg-pre-proposal/28](https://forum.sushi.com/t/governance-reorg-pre-proposal/28)

Any use of the devfund wallet requires that the Treasury Council Multisig members sign it as directed by the community via a successful proposal and Snapshot vote outlined in the DAO's foundation rulebook. There must be at least 4 out of 6 signatures to approve a transaction.

The Multisig members are trusted crypto industry members, and the community votes for the active signers via Snapshot.

Any changes within the core team's purview must pass the Operations Multisig with at least three signatures.

Our long-term goal is to establish a DAO with working, trustless governance. We welcome positive discourse from community members on progressing our governance model by participating in our forums and the #governance channel of the SushiSwap Discord.

### Proposals

Any community member is welcome to post a proposal on our forums. When you create a thread, please follow the template shown so prospective voters can easily read through the proposals. If you want a poll added to your thread, please contact a core or community team member.

If your proposal gains enough traction, the core team will bring it up for voting on our Snapshot voting platform. The community will vote with SUSHIPOWAH to decide the outcome.

Our Snapshot voting platform can be found here, where all Sushi proposals are housed.

SUSHIPOWAH is our voting metric and is decided as follows:

Each $SUSHI in the SUSHI-ETH pool is worth 2 SUSHIPOWAH.

Each $SUSHI held via xSUSHI tokens is worth 1 SUSHIPOWAH.

A vote must gain a quorum of at least 5 million SUSHIPOWAH to pass and become binding.

Please note: To be an eligible voter for any proposal on our Snapshot, you must have SUSHIPOWAH from any or all of the three above options when the vote starts. This means that you cannot simply buy $SUSHI tokens to vote on an already ongoing vote, and is intended to reduce the risk of influence by whales and flashloaners.


## Tokenomics

### 1. Token Overview

* **Total Supply** 280m
* **Symbol** SUSHI
* **Chain** ETHEREUM
* **Address** [0x6B3595068778DD592e39A122f4f5a5cF09C90fE2](https://etherscan.io/token/0x6B3595068778DD592e39A122f4f5a5cF09C90fE2)

SUSHI was introduced in August 2020 as part of SushiSwap’s fork of Uniswap, aiming to align incentives for liquidity providers and community governance.

### 2. Supply & Issuance

1. **Initial Emission:**

At launch, SUSHI emission was set at 1,000 SUSHI per Ethereum block for the first \~2 weeks to bootstrap liquidity.
After this “fair launch” period, the block rewards were reduced to 100 SUSHI per block.

2. **Ongoing Inflation:**

Because block rewards continue indefinitely, SUSHI does not have a hard-capped maximum supply.
The protocol can adjust reward rates through governance if needed (e.g., to reduce inflation).

3. **Distribution of Rewards:**

A portion of newly minted SUSHI goes to liquidity providers in eligible SushiSwap liquidity pools.
Historically, 10% of newly minted tokens were allocated to a developer fund, though the allocation details have been adjusted over time via governance proposals.

### 3. Utility and Value Accrual

1. **Governance:**

SUSHI is primarily a governance token, enabling holders to vote on SushiSwap’s protocol proposals.
Important protocol changes—such as fees, reward schedules, and new product launches—are decided by SUSHI token holders.

2. **Staking (SushiBar / xSUSHI):**

SUSHI holders can stake tokens in the SushiBar contract to receive xSUSHI, representing a share of the SushiBar pool.
Protocol fees from trades (typically 0.05% of each swap) are used to buy back SUSHI on the open market. These purchased tokens are distributed to the xSUSHI pool, effectively creating a continuous buyback mechanism that benefits stakers.

3. **Liquidity Incentives:**

Liquidity providers in selected SushiSwap pools earn newly minted SUSHI tokens as an incentive to lock capital.
This mechanism helps ensure deep liquidity across various trading pairs on SushiSwap.

### 4. Governance & Protocol Control

1. **On-chain Proposals:** SUSHI holders can create or vote on proposals that affect emissions, fee parameters, or treasury allocations.

2. **Treasury & Dev Fund:** The SushiSwap treasury (funded partly through block rewards and partially through trading fees) is used to support continued ecosystem growth, grants, audits, and community initiatives.

### 5. Key Tokenomic Features

1. **Continuous, Controlled Inflation:**

No maximum supply; block rewards continue indefinitely.
Governance can adjust block rewards to manage inflation.

2. **Fee Buybacks to Stakers:**

A portion of trading fees (0.05% out of a typical 0.30% total swap fee) is diverted to buy and distribute SUSHI to xSUSHI holders.
Community-Centric Design:

SUSHI’s governance-first ethos aims to keep power in the hands of the community, rather than a small group of core developers or investors.

#### In Summary

The SUSHI token lies at the heart of SushiSwap’s community-driven DEX model on Ethereum. It provides both governance rights and value accrual through staking rewards and protocol fee buybacks. Although SUSHI lacks a hard cap, its emission rate is subject to community governance, balancing liquidity incentives with inflation. By combining yield farming incentives, fee revenue sharing, and on-chain governance, SUSHI’s tokenomics aim to foster a sustainable and community-aligned ecosystem.


import { AddressTable } from '../../components/table'
import {
  BLADE_POOL_ADDRESSES,
  BLADE_COVE_ADDRESSES,
  BLADE_PERMIT_ROUTER_ADDRESSES,
  BLADE_LP_TRANSFER_ADDRESSES,
  BLADE_REGISTER_ADDRESSES,
  BLADE_FEE_SPLIT_ADDRESSES,
  BLADE_FARM_FEE_SPLIT_ADDRESSES,
  BLADE_VAULT_ADDRESSES,
  BLADE_FARMING_HELPER_ADDRESSES,
  BLADE_TRANSFER_HELPER_ADDRESSES,
} from '../../constants/blade'

## Blade

**Blade** is Sushi's RFQ (Request for Quote) trading protocol that provides better pricing through off-chain liquidity aggregation and on-chain settlement.

### Deployments

#### Pool Register

<AddressTable data={BLADE_REGISTER_ADDRESSES} />

#### Pool

<AddressTable data={BLADE_POOL_ADDRESSES} />

#### Cove

<AddressTable data={BLADE_COVE_ADDRESSES} />

#### Permit Router

<AddressTable data={BLADE_PERMIT_ROUTER_ADDRESSES} />

#### LP Transfer

<AddressTable data={BLADE_LP_TRANSFER_ADDRESSES} />

#### Fee Split

<AddressTable data={BLADE_FEE_SPLIT_ADDRESSES} />

#### Farm Fee Split

<AddressTable data={BLADE_FARM_FEE_SPLIT_ADDRESSES} />

#### Vault

<AddressTable data={BLADE_VAULT_ADDRESSES} />

#### Farming Helper

<AddressTable data={BLADE_FARMING_HELPER_ADDRESSES} />

#### Transfer Helper

<AddressTable data={BLADE_TRANSFER_HELPER_ADDRESSES} />


import { AddressTable, NetworkTable } from '../../components/table'
import {
  SUSHISWAP_V3_FACTORY_ADDRESS,
  SUSHISWAP_V3_INIT_CODE_HASH,
  SUSHISWAP_V3_POSITION_MANAGER,
  SUSHISWAP_V3_TICK_LENS,
  SUSHISWAP_V3_QUOTER,
} from 'sushi/evm'

## clAMM (SuhiSwap V3)

The **Concentrated Liquidity Automated Market Maker (clAMM)**

### Deployments

#### Factory

<AddressTable data={SUSHISWAP_V3_FACTORY_ADDRESS} />

#### Position Manager

<AddressTable data={SUSHISWAP_V3_POSITION_MANAGER} />

#### Tick Lens

<AddressTable data={SUSHISWAP_V3_TICK_LENS} />

#### Quoter

<AddressTable data={SUSHISWAP_V3_QUOTER} />

#### Init Code Hash

<NetworkTable data={SUSHISWAP_V3_INIT_CODE_HASH} />


import { AddressTable, NetworkTable } from '../../components/table'
import {
  SUSHISWAP_V2_FACTORY_ADDRESS,
  SUSHISWAP_V2_ROUTER_ADDRESS,
  SUSHISWAP_V2_INIT_CODE_HASH
} from 'sushi/evm'

## cpAMM (SuhiSwap V2)

The **Constant Product Automated Market Maker (cpAMM)**

### Deployments

#### Factory

<AddressTable data={SUSHISWAP_V2_FACTORY_ADDRESS} />

#### Router

<AddressTable data={SUSHISWAP_V2_ROUTER_ADDRESS} />

#### Init Code Hash

<NetworkTable data={SUSHISWAP_V2_INIT_CODE_HASH} />


## cpAMM

...


import { AddressTable } from '../../components/table'
import { RED_SNWAPPER_ADDRESS } from 'sushi/evm'

## Red Snwapper

RedSnwapper is a facade for the execution router contracts (RouteProcessor), and handles single & multi token swaps.

### Functions

#### snwap

```solidity
function snwap(
  IERC20 tokenIn,
  uint amountIn,
  address recipient,
  IERC20 tokenOut,
  uint amountOutMin,
  address executor,
  bytes calldata executorData
) external payable returns (uint amountOut)
```

1. Transfers `amountIn` of `tokenIn` to `executor`.
2. Launches `executor` with `executorData` and `value = msg.value`.
3. Checks that `recipient`'s `tokenOut` balance increased by at least `amountOutMin`.

##### Parameters

| Name           | Type      | Description                                                          |
| -------------- | --------- | -------------------------------------------------------------------- |
| `tokenIn`      | `IERC20`  | The token being swapped                                              |
| `amountIn`     | `uint`    | The amount of `tokenIn` to swap (0 means take from contract balance) |
| `recipient`    | `address` | The address receiving the swapped tokens                             |
| `tokenOut`     | `IERC20`  | The token to receive after the swap                                  |
| `amountOutMin` | `uint`    | Minimum amount of `tokenOut` that must be received                   |
| `executor`     | `address` | The contract that will execute the swap logic                        |
| `executorData` | `bytes`   | Data payload passed to the `executor`                                |

##### Return Values

| Name        | Type   | Description                              |
| ----------- | ------ | ---------------------------------------- |
| `amountOut` | `uint` | The actual amount of `tokenOut` received |

#### snwapMultiple

```solidity
function snwapMultiple(
  InputToken[] calldata inputTokens,
  OutputToken[] calldata outputTokens,
  Executor[] calldata executors
) external payable returns (uint[] memory amountOut)
```

1. Transfers each of the `inputTokens` to `inputTokens[i].transferTo`.
2. Launches all specified `executors`.
3. Checks that the final `recipient`'s `tokenOut` balance(s) are each at least their corresponding `amountOutMin`.

##### Parameters

| Name           | Type            | Description                                                          |
| -------------- | --------------- | -------------------------------------------------------------------- |
| `inputTokens`  | `InputToken[]`  | Array of input token structs, each describing what token to transfer |
| `outputTokens` | `OutputToken[]` | Array of output token structs, each describing the expected output   |
| `executors`    | `Executor[]`    | Array of executor structs to be launched sequentially                |

##### Return Values

| Name        | Type            | Description                                  |
| ----------- | --------------- | -------------------------------------------- |
| `amountOut` | `uint[] memory` | Actual amounts of each output token received |

### Deployments

<AddressTable data={RED_SNWAPPER_ADDRESS} />

### Examples

#### Using a contract to call RedSnwapper

Below is an example Solidity contract that can be used to call RedSnwapper.

It expects "self" as the `source` parameter when calling the API, and will pre-fund RedSnwapper with the input tokens before executing the swap.
In case "sender" is used as the `source`, the contract can be simplified by removing the token transfer logic, although an `approve` call is still be needed.

The `source` parameter is disregarded when the input token is native (ETH), in which case the contract must be pre-funded with enough ETH to cover the swap.

```solidity
contract RedSnwapperProxy {
  constant address NATIVE = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
  constant address RED_SNWAPPER = 0xac4c6e212a361c968f1725b4d055b47e63f80b75;

  function swap(bytes calldata data) external payable returns (uint256 amountOut) {
    // Skip the first 4 bytes (function selector), decode the input token and amountIn
    (address tokenIn, uint256 amountIn) = abi.decode(data[4:], (address, uint256));

    // If the "source" parameter used to call the API is "self", we need to pre-fund the contract
    uint256 nativeAmount = 0;
    if (tokenIn == NATIVE) {
      require(msg.value >= amountIn, "Not enough ETH sent");
      nativeAmount = amountIn;
    } else {
      IERC20(tokenIn).transfer(RED_SNWAPPER, amountIn);
    }

    // Call RedSnwapper
    (bool success, bytes memory returnData) = RED_SNWAPPER.call{value: nativeAmount}(data);
    require(success, "RedSnwapper call failed");

    amountOut = abi.decode(returnData, (uint256));
  }
}

```


import { AddressTable } from '../../components/table'
import { SUSHI_ADDRESS } from 'sushi/evm'

## Sushi

On some chains, Sushi tokens are considered insolvent due to the bridges that they were issued through being hacked or becoming defunct. This applies particularly to anySushi from the Multchain/AnySwap bridge and 1Sushi from the Harmony v1 bridge.

### Deployments

<AddressTable data={SUSHI_ADDRESS} />


import { AddressTable } from '../../components/table'
import { XSUSHI_ADDRESS } from 'sushi/evm'

## xSushi Token

Currently xSushi is only available on Ethereum, or bridged to Polygon through the [Polygon PoS bridge](https://portal.polygon.technology/bridge).

### Deployments

<AddressTable data={XSUSHI_ADDRESS} />


## What is Blade?

#### The Blue-Chip DEX

Blade is a DEX designed for blue-chip tokens (e.g., ETH, WBTC, USD stablecoins, etc.) and no impermanent loss. Blue-chip tokens comprise 70% of all on-chain trading volume.

Blade's novel architecture makes money for LPs using the same arbitrage strategy used by professional market makers, but implemented in a permissionless and non-custodial manner. In contrast to most DEXs, Blade's LP yields are not generated from fees.

Blade computes prices off-chain using a sophisticated formula that incorporates low-latency price feeds from centralized exchanges along with a snapshot of on-chain state. It then uses on-chain proofs to validate prices and preserve permissionlessness. This allows Blade to make money from arbitrage, instead of paying a tax to arbitrageurs, while keeping gas fees low for traders. On Blade, liquidity providers take home superior yields with **no impermanent loss** and traders can expect no whales or bots front-running their trades.


## Blade's Benchmark: No Impermanent Loss

Blade's pools act like a daily rebalancing portfolio composed of roughly 1/3 ETH, 1/3 WBTC, and 1/3 stablecoins (with zero transaction costs for rebalancing). **This rebalancing strategy results in no impermanent loss for LPs.**

#### How Blade Stacks Up Against the Benchmark

Blade's benchmark is no impermanent loss. It achieves this through tracking a theoretical costless DRP.

If we look at a sample of Blade's performance from September 11, 2022 through October 10, 2022, we see that it closely tracks the DRP while staying slightly ahead of it--finishing the interval almost 40 basis points ahead.

***Note:** Blade is "Clipper" in the chart below; Clipper was the initial name of Blade*

<div align="center">
  ![Blade Performance Chart](/images/blade/performance-chart.png)
</div>

Blade was within 1 bps of the DRP for more than three-quarters of the days in the period. For those days where Blade and the DRP diverged by more than 1 bps, Blade was in the leading position more than two-thirds of the time (23% vs. 10% of days).

| **Blade LP Daily Performance vs. Benchmark** | **Frequency** |
| -------------------------------------------- | ------------- |
| > 1 basis point worse                        | 10%           |
| 1 basis point worse to 1 basis point better  | 77%           |
| > 1 basis point better                       | 23%           |

The reason for return divergence is that Blade's FMM will make trades continuously with traders over the course of a day, while the theoretical DRP is simulated to costlessly rebalance *once* per day. Despite the divergences, the daily correlation of percent returns to the returns of the DRP was extremely high at ρ = 0.9996.

Blade's close tracking of the DRP is what enables it to hit its no impermanent loss benchmark.


import { Callout } from 'vocs/components'

## How Blade Makes Money for LPs

Blade makes money for LPs through arbitrage. This requires significantly more sophisticated formulas than can be supported on-chain, given gas prices and block time constraints. Thus, Blade does not rely on the Constant Product Market Maker (CPMM) used by most DEXs. Instead, Blade has a unique architecture called the Formula Market Maker (FMM), which enables off-chain computation without compromising custody.

#### FMM Architecture

Blade's FMM is a hybrid mechanism that has both on-chain and off-chain components. Unlike CPMMs whose pricing formulas only consider token ratios in pools, the FMM pricing function utilizes both token ratios and external real-time market prices from centralized and decentralized oracles. Blade's FMM performs pricing computations off-chain then verifies and validates them on-chain to prevent malicious quotes and determine if there have been any significant price changes between the time pricing data was pulled off-chain and applied to an on-chain swap. This design is highly efficient--keeping the hard work of solving formulas off-chain and verifying them on-chain avoids high gas costs while keeping the entire system trustless and transparent.

While the above describes how the FMM operates on the Polygon, Optimism, and Arbitrum versions of Blade, on **Ethereum** it performs the comparative price computations and validations off-chain against the on-chain data. This further reduced Blade's gas usage on Ethereum, resulting in even lower gas costs for both traders and LPs—*both relative to the previous iteration and other leading DEXs.*

#### No Impermanent Loss

There's a major misconception that impermanent loss (IL) is an unavoidable feature of DEX liquidity pools. The misconception came about because most DEXs utilize a CPMM. CPMMs *are* inherently prone to IL due to how they balance liquidity pool assets. Tokens on CPMM-based DEXs are priced by a constant function (x\*y=k) and IL is caused by arbitrageurs exploiting discrepancies between the prices set by the CPMM and external market prices. While arbitrage activity keeps CPMM prices in line with the rest of the market, the profit arbitrageurs extract is siphoned from LP holdings.

> 💡 Despite its name, *impermanent loss* is a real risk that can have lasting and detrimental effects on LP returns. LPs realize this loss if upon withdrawing their stake from the pool, the value of the assets they retrieve is lower (at current market prices) than if they had simply held them.

Impermanent loss can be avoided by using a more sophisticated market maker with better pricing information. Blade's FMM uses both the token ratios in pools and decentralized price oracles to balance assets, instead of a constant function. The price oracles make it so that when external market prices change, Blade's prices update without the need for arbitrage trades. **The absence of impermanent loss contributes to superior LP yields!**

<Callout type="note">
  Note: This doesn't mean that Blade LPs are always profitable; all yield-generating opportunities come with a degree of risk. Blade tracks the rebalancing portfolio you may have learned about in [Modern Portfolio Theory](https://en.wikipedia.org/wiki/Modern_portfolio_theory). This portfolio provides optimal risk-adjusted beta exposure while generating free alpha from volatility along the way. It's the approach that won a Nobel Prize in 1990.
</Callout>


import { Callout } from 'vocs/components'

## How LPs Earn from Arbitrage

Rather than from trading fees, Blade generates LP returns by pursuing a statistical arbitrage strategy similar to many traditional finance asset managers. However, it does so permissionlessly according to a formula that anyone can observe, predict, and verify for themselves. This ensures composability and enables non-custodial liquidity.

The specific strategy is a Daily Rebalancing Portfolio (DRP). This is a common strategy for commodities trading.

> **Example of how rebalancing works:** Imagine a $2,000 dual-asset portfolio with target allocations of 50% ETH and 50% USDC. On day one, ETH doubles in price, raising the ETH allocation in the portfolio from $1,000 to $2,000. The portfolio allocation is now 66% ETH ($2,000) and 33% USDC ($1,000) and must be rebalanced back to 50/50. This is accomplished by selling $500 worth of ETH for USDC, returning the portfolio to 50% ETH ($1,500) and 50% USDC ($1,500).

Daily rebalancing works whenever assets have high daily volatility and mean reversion relative to monthly/yearly volatility. This is because daily rebalancing has the effect of systematically buying low and selling high each day. It generates profits each day, which are the source of yield for Blade LPs. This is a well-researched phenomenon that earned Harry Markowitz the [Nobel Prize](https://www.nobelprize.org/prizes/economic-sciences/1990/press-release/?ref=docs.sushi.com) in Economics in 1990.

> **Example of how rebalancing profits:** Imagine the aforementioned 50/50 ETH-USDC portfolio. On day two, ETH drops to its original value of $1,000. The portfolio again must be rebalanced by selling $375 USDC for ETH, resulting in $1,125 in ETH and $1,125 USDC, totaling $2,250. This is a 1.125x return. If the same assets had simply been held for the two days, the return would only be 1x (no return).

👉 [**Spreadsheet**](https://docs.google.com/spreadsheets/d/1cZbJ18QvBuIcTofajTeAzVAdT5CmoUGzIN2nr12-8os/edit#gid=0) **showing how this works.**

👉 **Research on** [**Portfolio Rebalancing**](https://seekingalpha.com/article/4046116-investors-alpha-systematic-portfolio-rebalancing?ref=docs.sushi.com) **and** [**A Mathematical and Empirical Analysis of Rebalancing Alpha**](https://www.researchgate.net/publication/228179008_Optimal_Rebalancing_A_Scalable_Solution?ref=docs.sushi.com)

It turns out that blue-chip crypto assets, specifically ETH and WBTC, trade like commodities, just like gold and oil. This means a daily rebalancing statistical arbitrage strategy will work for them.

> **Evidence:** A Hurst Exponent test we ran (below) on the price movements of ETH from late 2015 through May 2023 shows that from mid-2018 onward ETH has typically been either memoryless or mean reverting, whereas prior to that it was noticeably momentum driven. This verifies that ETH prices seem to be more mean reverting as the asset has matured, making it a prime candidate for rebalancing. This is typically the case with blue-chip crypto assets, such as the Core Assets included in Clipper's Core pools.

<Callout type="note">
  In a memoryless price series, variance over 90-day windows should be 3x the variance at the 30-day window. A momentum price series will be above 3, and a mean-reverting series will be below 3.
</Callout>

<div align="center">
  ![Hurst Exponent Analysis](/images/blade/hurst-exponent-analysis.png)
</div>

This strategy is especially attractive because Blade rebalances without having to pay transaction costs that otherwise create "performance drag." Instead, Blade executes its trades with the noisy order flow from traders. Volume in Blade's pools turns over extremely fast—sometimes multiple times per week. This means that traders will quickly rebalance Blade's pools for it. In other words, traders pay the transaction costs instead of Blade, eliminating performance drag.

👉 **Research on** [**Rebalancing Portfolios With and Without Transaction Costs**](https://www.cs.cmu.edu/~avrim/Papers/portfolio.pdf?ref=docs.sushi.com)

#### The Diversified Portfolio Also Reduces Risk

A well-diversified, rebalancing portfolio has other benefits as well. Modern Portfolio Theory states that such a portfolio results in better long-term returns at a lower level of risk than investing solely in any one asset. Many financial advisors recommend a classic personal portfolio of [60% stocks and 40% bonds](https://www.nytimes.com/2015/04/12/business/mutfund/the-value-of-a-classic-in-a-turbocharged-world.html). Theoretically, this is an optimal way to gain exposure to an asset class. This long-term additional return further enhances Blade's yields.

👉 **Research on** [**Universal Portfolios**](https://isl.stanford.edu/~cover/papers/paper93.pdf?ref=docs.sushi.com)**, which increase long-term return while decreasing risk**


## Why Blade Has Better Trading Prices

**Because Blade generates more efficient returns for LPs, it can afford to offer better prices to traders.**

With \~$10M in liquidity (TVL), Blade has best priced trades up to $10k. As TVL grows, Blade will have best prices on larger trades--e.g., $50M TVL would correspond to best prices on trades up to $50k.

Below are the results of a sampling study against 0x API for a $10K USDC\<>ETH trade over several days in August 2023. [The results](https://docs.google.com/presentation/d/1QLYkVzOBrMvy8axKhID_ag0IVEaARIfN/edit#slide=id.p6) show Blade beat 0x 92.5% of the time on both legs of the trade and 99.6% of the time on at least one leg.

***Note:** Blade is "Clipper" in the chart below; Clipper was the initial name of Blade*

<div align="center">
  ![Blade vs 0x Performance Comparison](/images/blade/blade-0x-performance-comparison.png)
</div>


## Blade vs. CPMMs vs. HODLing

Blade's rebalancing strategy generally performs better than CPMMs (used by most DEXs) or HODLing, but it of course depends on market behavior.

#### Blade vs. The CPMM

Both Blade and the CPMM provide beta exposure (return attributed to overall market returns) to the assets in their respective pools. However, the similarities end there. Instead of rebalancing as conceived of in Modern Portfolio Theory, the CPMM trades according to its inherent x\*y = k function. While Blade provides alpha, the CPMM generates *negative* alpha, better known as impermanent loss. At best, if prices haven't moved by the end of the period the CPMM generates no loss. If prices have moved in either direction, there is substantial loss. The CPMM generates no profit from short-term volatility and loses money from long-term volatility. Meanwhile, yield comes not from the rebalancing process but rather from arbitrary fees charged to traders on top of trade prices.

In other words, impermanent loss is not an attribute of all DEXs, it is an attribute solely of CPMM-based AMMs. Conceptually, the CPMM "sells low and buys high" as prices change, which is the opposite of Blade's strategy (and common sense). The below figure shows how CPMMs only account for an asset's beginning and ending prices. In contrast, Blade's strategy accounts for price movements in the interim and profits from volatility.

<div align="center">
  ![CPMM vs Blade Strategy Comparison](/images/blade/cppm-blade-comparison.png)
</div>

As you can see, the attributes of the CPMM are not very favorable to LPs. Why then is it used by all first-generation DEXs? Because it is extremely simple to implement. It is also simple to calculate on-chain, which makes gas costs low. This tradeoff between gas and complexity is what Blade's FMM architecture overcomes.

👉 **See Appendix for math on the CPMM vs** Blade

#### Comparing Yields

Because the DeFi community is so used to CPMM DEXs, APY comparisons assume all pools are structured as CPMMs with trading fees and impermanent loss. Because Blade does not have explicit trading fees or impermanent loss, it's difficult to directly compare Blade's bottom-line LP figures with the top-line revenue numbers CPMM-based DEXs use. To ensure full transparency and keep LPs informed, Blade reports comparable metrics and historical earnings on Blade's data dashboard.

#### Blade vs. HODLing

Blade has an objectively better risk-return profile than HODLing and should outperform it in current market regimes. However, there are price series' that could result in better returns from HODLing. To provide concrete data, below are several months of Blade's performance vs. HODLing an equivalent initial portfolio.

| Month      | Blade's Performance (bps) | HODL Performance (bps) |
| ---------- | ------------------------- | ---------------------- |
| April 2023 | +213                      | +185                   |
| May 2023   | -5                        | -14                    |
| June 2023  | +472                      | +458                   |
| July 2023  | -169                      | -177                   |


## FAQs

#### General

**Who is the team behind Blade?**

Blade was built by Shipyard Software, a leading design shop that develops custom-built DEXs, under Sushi Labs.

**Can I use a hardware wallet on Blade?**

Yes, any hardware wallet that is compatible with your crypto assets' token standards can be used with Blade.

#### Liquidity

**Who can be a Blade LP?**

The only requirement is that your wallet is not on the OFAC list.

**Is there a limit on how much liquidity I can deposit?**

No.

**Is there any lockup period for LP deposits?**

No.

**How does a token's current balance in a Core pool affect the value of a deposit?**

LPs will be granted a larger number of pool tokens (and therefore, a higher percentage of pool ownership) for depositing assets that are currently undersupplied in the pool.

By looking at the star rating next to each asset in Core pools, you can see how its supply in the pool will impact your deposit. (i.e., an asset with a 3-star rating is undersupplied, therefore a deposit of this asset may be more likely to increase in value. An asset with a 1-star or 0-star rating is oversupplied in the pool, therefore a deposit of this asset may be less likely to increase in value.)

**On the Blade data page, what is "Profit Yield"?**

This net trading gain figure is the sum of the positive difference between Blade input and output on swaps, according to on-chain price oracles. This figure is the best entirely on-chain auditable proxy for Blade LP's excess gains over and above the DRP benchmark. This is what the DAO takes its fees from.

**On the Blade data page, what is "Comparable APY"? How does it relate to impermanent loss?**

Top-line yield that includes the impermanent loss (IL) avoided by Blade's FMM design. These APYs are directly comparable with the APYs reported by most other DEXs like SushiSwap.

The annualized yields (APYs) shared by these DEXs are calculated from "fees" that include a great deal of IL. Blade's innovative FMM design not only allows LPs to avoid the impermanent loss that other DEXs face but also to calculate the counterfactual of the amount of IL that LPs *would have* suffered. We call that counterfactual amount "avoided IL".

Avoided IL is calculated by comparing Blade LPs' gain/loss on a crypto-basis (i.e., measured in crypto, not USD) to the crypto-basis loss of the CPMM mechanism used by SushiSwap, etc. This crypto-basis loss can be calculated from (and will change based on) the difference in dollar values of the assets at the start and end of a time period. Comparable APY is then calculated by taking **Blade**'s profit yield and adding it to the avoided IL.

We believe Comparable APY represents the best and most accurate expression of Blade's "yield" when LPs are considering which DEX to deposit into.

#### Transactions

**Should I be concerned about front running, MEV, or sandwich attacks when trading on Blade?**

These kinds of attacks can happen with decentralized exchanges that do not offer traders guaranteed rates in swaps. Bots watch pending transactions and can construct ways to give traders a worse rate, pocketing the surplus.

A unique aspect of Blade is that all signed quotes are firm, so you do not need to worry about bots stealing from your intended transactions.

**Why is my transaction pending for so long?**

The most likely explanation is that the gas price associated with your transaction was too low for miners to consider including it in a new block. Depending on your wallet, you may be able to cancel your pending transaction or re-submit it with a higher gas price. Etherscan maintains a [**detailed "Gas Tracker" page**](https://etherscan.io/gastracker) with frequently updated estimates of execution price and timeliness.

**Will my gas costs be refunded?**

As is typical for interactions on blockchains, any gas that was not consumed by a transaction on Blade will be refunded to its sender.


## Liquidity Pools

Blade's pools are multi-asset liquidity pools composed of Blade Core Assets (*usually ETH, WBTC, USDC, USDT, DAI, and the native token of the given chain*). These assets are commodities that comprise 70% of all trade volume in DeFi.

Unlike most DEX liquidity pools, Blade LPs earn yield on a *pro rata* portion of the entire pool, not just the asset(s) they deposit. Upon deposit, LPs receive LP tokens which represent their fractional ownership of the underlying pool. LP tokens have no value other than this representation.

There is one liquidity pool on each chain. The benefit of using one unified pool is to consolidate liquidity, rather than fragmenting it across multiple pools to achieve the same pairings. This increases capital efficiency, allowing for higher yields with lower fees.


import { Callout } from 'vocs/components'

## Depositing & Withdrawing

### Depositing

The only requirement for providing liquidity on Blade is that your wallet is not on the OFAC list. To deposit, simply connect your wallet and follow the on-screen prompts.

#### Blade LP Tokens

Upon deposit, you will receive LP tokens. These tokens represent your fractional ownership of the underlying pool and have **no value** other than this representation. Their purpose is to enable Blade to normalize each LP's deposits and withdrawal amounts by calculating their pool ownership value per token. Hold on to your LP tokens, **you will need them for withdrawal**.

The rewards you collect as an LP will be added to the overall value of your deposit and can be withdrawn at the same time as your principal.

### Withdrawing LP Deposits & Rewards

<Callout type="note">
  Blade is a non-custodial mechanism. Even if the Blade web page goes down, unlocking and burning LP tokens to withdraw assets are operations that are always available by directly interacting with the smart contracts on the blockchain.
</Callout>

To withdraw, you must redeem (burn) your LP tokens. You will have the option to withdraw either a single asset or a pro rata share of all tokens in the multi-asset pool.

If you choose the second option, the relative composition of tokens is determined by each asset's external market prices, which Blade uses to calculate the value per token for the pool. This is done by taking the value of the assets at those external market prices and dividing that value by the total number of tokens in the pool.


import Swagger from '../../components/swagger';

<Swagger url="/openapi.yaml" />


## Pricing API Documentation

### Overview

The Pricing API provides token prices across multiple chains.
The `sushi` package [also exposes](/sdk/price) wrapper functions for this API — `getPrice` and `getPrices` — under the `sushi/evm` export.

### Endpoints

* `GET /price/v1/{chainId}`: Returns a map of token address → price (in USD) for the specified `chainId`.
* `GET /price/v1/{chainId}/{address}`: Returns a single token price (in USD) for `address` on the specified `chainId`.

### Example

```ts twoslash
// Fetch prices for many tokens (address → number)
const chainId = 1
const PRICES_API_URL = new URL('https://api.sushi.com/price/v1/' + chainId)

console.log(PRICES_API_URL.toString())
const pricesRes = await fetch(PRICES_API_URL.toString())
const prices = await pricesRes.json() as Record<string, number>
console.log(prices)

// Fetch price for a single token
const address = '0x6b3595068778dd592e39a122f4f5a5cf09c90fe2' // SUSHI on mainnet
const PRICE_API_URL = new URL(`https://api.sushi.com/price/v1/${chainId}/${address}`)

console.log(PRICE_API_URL.toString())
const priceRes = await fetch(PRICE_API_URL.toString())
const price = await priceRes.json() as number
console.log(price)
```

### Response

* Multiple prices (`/price/v1/{chainId}`): object mapping token address to numeric USD price.
* Single price (`/price/v1/{chainId}/{address}`): a single numeric USD price.

Examples:

```jsonc
// GET /price/v1/1
{
  "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2": 2523.45,
  "0x6b3595068778dd592e39a122f4f5a5cf09c90fe2": 1.12
}

// GET /price/v1/1/0x6b3595068778dd592e39a122f4f5a5cf09c90fe2
1.12
```


## Quote API Documentation

### Overview

The Quote API provides functionality to generate a quote.
The `sushi` package [also exposes](/sdk/quote) a wrapper function for this API called `getQuote`, available under the `sushi/evm` export.

### Example

```ts twoslash
import { type QuoteResponse } from 'sushi/evm'

const chainId = 1

const QUOTE_API_URL = new URL('https://api.sushi.com/quote/v7/' + chainId)

// TokenA & TokenB
const inputCurrency = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE'
const outputCurrency = '0x6B3595068778DD592e39A122f4f5a5cF09C90fE2'

// Amount
const amount = 1000000000000000

// Max Slippage
const maxSlippage = 0.005

const { searchParams } = QUOTE_API_URL
searchParams.set('tokenIn', inputCurrency)
searchParams.set('tokenOut', outputCurrency)
searchParams.set('amount', amount.toString())
searchParams.set('maxSlippage', maxSlippage.toString())

// Make call to API
console.log(QUOTE_API_URL.toString())
const res = await fetch(QUOTE_API_URL.toString())
const data = await res.json() as QuoteResponse
console.log(data)
```


## Swap API Documentation

### Overview

The Swap API provides functionality to generate swap call data necessary for executing a swap transaction.
The `sushi` package [also exposes](/sdk/swap) a wrapper function for this API called `getSwap`, available under the `sushi/evm` export.

### Example

```ts twoslash
import { createPublicClient, createWalletClient, http, type Hex } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'
import { type SwapResponse } from 'sushi/evm'

const publicClient = createPublicClient({
  chain: mainnet,
  transport: http(),
})

const chainId = 1

const SWAP_API_URL = new URL('https://api.sushi.com/swap/v7/' + chainId)

// TokenA & TokenB
const inputCurrency = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE'
const outputCurrency = '0x6B3595068778DD592e39A122f4f5a5cF09C90fE2'

// Amount
const amount = 1000000000000000

// Max Slippage
const maxSlippage = 0.005

// Sender
const sender = '0x' // replace with your own address

// Api Key, get yours at https://sushi.com/portal
// const apiKey = "sushi_abcdefghijklmnopqr"

const { searchParams } = SWAP_API_URL
searchParams.set('tokenIn', inputCurrency)
searchParams.set('tokenOut', outputCurrency)
searchParams.set('amount', amount.toString())
searchParams.set('maxSlippage', maxSlippage.toString())
searchParams.set('sender', sender)
// searchParams.set('apiKey', apiKey)

// Make call to API
console.log(SWAP_API_URL.toString())
const res = await fetch(SWAP_API_URL.toString())
const data = await res.json() as SwapResponse
console.log(data)

// If the swap status is 'Success'
if (data.status === 'Success') {
  const { tx } = data
  // Simulate a call to the blockchain for the swap
  const callResult = await publicClient.call({
    account: tx.from,
    data: tx.data,
    to: tx.to,
    value: tx.value,
  })
  // Returns the simulated amount out
  console.log('Output: ', callResult)

  // Send a transaction
  const PRIVATE_KEY = process.env.PRIVATE_KEY as Hex
  const walletClient = createWalletClient({
    chain: mainnet,
    transport: http(),
  })
  const hash = await walletClient.sendTransaction({ 
    account: privateKeyToAccount(PRIVATE_KEY),
    data: tx.data,
    to: tx.to,
    value: tx.value,
  })
  console.log('Tx: ', hash)
}
```

### Response

The endpoint returns a `SwapResponse`, which includes the route status and, on success, the prepared transaction to execute the swap.

* Status: one of `Success`, `Partial`, or `NoWay`.
* Tokens: array of involved tokens with `address`, `decimals`, `symbol`, and `name`.
* Token indexes: `tokenFrom` and `tokenTo` are indexes into `tokens` and are also expanded to the full token objects in the response.
* Pricing: `swapPrice` (price tokenIn → tokenOut) and `priceImpact` (as a fraction, e.g. `0.005` for 0.5%).
* Amounts: `amountIn` and `assumedAmountOut` as stringified integers in token base units.
* Transaction: `tx` with `from`, `to`, `gasPrice` (number), `data` (hex), and `value` (stringified integer, may be omitted or "0" for ERC-20 → ERC-20). When `simulate=true` is passed, `tx.gas` is also included as a string.

Example (Success):

```json
{
  "status": "Success",
  "tokens": [
    {
      "address": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
      "decimals": 18,
      "symbol": "ETH",
      "name": "Ether"
    },
    {
      "address": "0x6b3595068778dd592e39a122f4f5a5cf09c90fe2",
      "decimals": 18,
      "symbol": "SUSHI",
      "name": "SushiToken"
    }
  ],
  "tokenFrom": 0,
  "tokenTo": 1,
  "swapPrice": 2300.12,
  "priceImpact": 0.0012,
  "amountIn": "1000000000000000",
  "assumedAmountOut": "1234567890000000000",
  "tx": {
    "from": "0x0000000000000000000000000000000000000000",
    "to": "0x0000000000000000000000000000000000000000",
    "gasPrice": 1000000000,
    "data": "0x…",
    "value": "1000000000000000"
    // when simulate=true, a string field "gas" is also included
  }
}
```

If `status` is `NoWay`, only the `status` field is returned, indicating that no route satisfying the constraints was found. `Partial` indicates a route is available but cannot fully satisfy the requested amount under the given constraints.

Errors are returned with RFC 7807 problem details; see API error references under [Errors](/api/errors).


## Estimate Gas

This problem occurs when the gas estimation fails.

Your client application did everything correctly. Unfortunately our API encountered a condition that resulted in this problem.

| **Type URI**                                                                                     | **Title**          | **Status** |
| ------------------------------------------------------------------------------------------------ | ------------------ | ---------- |
| [https://docs.sushi.com/api/errors/estimate-gas](https://docs.sushi.com/api/errors/estimate-gas) | Estimate Gas Error | 422        |

**Example of an <code>estimate-gas</code> problem details:**

```json
{
  "type": "https://docs.sushi.com/api/errors/estimate-gas",
  "title": "Estimate Gas Error",
  "details": "string",
  "status": 422,
  "code": "422-02"
}
```


## API Errors

Below is a list of all API error types with their type URI, title, and HTTP status.

| **Type URI**                                                                                                         | **Title**              | **Status** |
| -------------------------------------------------------------------------------------------------------------------- | ---------------------- | ---------- |
| [https://docs.sushi.com/api/errors/estimate-gas](https://docs.sushi.com/api/errors/estimate-gas)                     | Estimate Gas Error     | 422        |
| [https://docs.sushi.com/api/errors/insufficient-allowance](https://docs.sushi.com/api/errors/insufficient-allowance) | Insufficient Allowance | 422        |
| [https://docs.sushi.com/api/errors/insufficient-balance](https://docs.sushi.com/api/errors/insufficient-balance)     | Insufficient Bllowance | 422        |
| [https://docs.sushi.com/api/errors/invalid-api-key](https://docs.sushi.com/api/errors/invalid-api-key)               | Invalid Api Key        | 401        |
| [https://docs.sushi.com/api/errors/no-fresh-data](https://docs.sushi.com/api/errors/no-fresh-data)                   | No Fresh Data          | 500        |
| [https://docs.sushi.com/api/errors/not-found](https://docs.sushi.com/api/errors/not-found)                           | Not Found              | 404        |
| [https://docs.sushi.com/api/errors/ratelimit-exceeded](https://docs.sushi.com/api/errors/ratelimit-exceeded)         | Ratelimit Exceeded     | 429        |
| [https://docs.sushi.com/api/errors/server](https://docs.sushi.com/api/errors/server)                                 | Server                 | 500        |
| [https://docs.sushi.com/api/errors/service-unavailable](https://docs.sushi.com/api/errors/service-unavailable)       | Service Unavailable    | 503        |
| [https://docs.sushi.com/api/errors/unauthorized](https://docs.sushi.com/api/errors/unauthorized)                     | Unauthorized           | 403        |
| [https://docs.sushi.com/api/errors/validation](https://docs.sushi.com/api/errors/validation)                         | Validation             | 422        |


## Insufficient Allowance

This problem occurs when the spender doesn't have sufficient allowance.

Your client asked for an estimation of a swap in which the spender doesn't have sufficient allowance. This prevents the estimation from completing successfully.

| **Type URI**                                                                                                         | **Title**              | **Status** |
| -------------------------------------------------------------------------------------------------------------------- | ---------------------- | ---------- |
| [https://docs.sushi.com/api/errors/insufficient-allowance](https://docs.sushi.com/api/errors/insufficient-allowance) | Insufficient Allowance | 422        |

**Example of an <code>insufficient-allowance</code> problem details:**

```json
{
  "type": "https://docs.sushi.com/api/errors/insufficient-allowance",
  "title": "Insufficient Allowance Error",
  "details": "Spender has insufficent allowance",
  "status": 422,
  "code": "422-04",
  "token": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
  "spender": "0x85cd07ea01423b1e937929b44e4ad8c40bbb5e71",
  "sender": "0x19b3eb3af5d93b77a5619b047de0eed7115a19e7",
  "allowance": "1000000",
  "amount": "5000000"
}
```


## Insufficient Balance

This problem occurs when the spender doesn't have sufficient balance.

Your client asked for an estimation of a swap in which the spender doesn't have sufficient balance. This prevents the estimation from completing successfully.

| **Type URI**                                                                                                     | **Title**              | **Status** |
| ---------------------------------------------------------------------------------------------------------------- | ---------------------- | ---------- |
| [https://docs.sushi.com/api/errors/insufficient-balance](https://docs.sushi.com/api/errors/insufficient-balance) | Insufficient Bllowance | 422        |

**Example of an <code>insufficient-balance</code> problem details:**

```json
{
  "type": "https://docs.sushi.com/api/errors/insufficient-balance",
  "title": "Insufficient Balance Error",
  "details": "Spender has insufficent balance",
  "status": 422,
  "code": "422-03",
  "token": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
  "sender": "0x19b3eb3af5d93b77a5619b047de0eed7115a19e7",
  "balance": "1000000",
  "amount": "5000000"
}
```


## Invalid Api Key

This problem occurs when the provided API key is invalid or missing.

Your client application tried to access a resource that requires an API key, but the key was either invalid or not provided. Please check your API key and try again. It can be provided as a query parameter or in the authorization header.

| **Type URI**                                                                                           | **Title**       | **Status** |
| ------------------------------------------------------------------------------------------------------ | --------------- | ---------- |
| [https://docs.sushi.com/api/errors/invalid-api-key](https://docs.sushi.com/api/errors/invalid-api-key) | Invalid Api Key | 401        |

**Example of an <code>invalid-api-key</code> problem details:**

```json
{
  "type": "https://docs.sushi.com/api/errors/invalid-api-key",
  "title": "Invalid or Missing API Key",
  "details": "Invalid API key",
  "status": 401,
  "code": "401-01",
}
```


## No Fresh Data

This problem occurs when the API does not have fresh data available.

Your client application did everything correctly. Unfortunately our API encountered a condition that resulted in this problem.

| **Type URI**                                                                                       | **Title**     | **Status** |
| -------------------------------------------------------------------------------------------------- | ------------- | ---------- |
| [https://docs.sushi.com/api/errors/no-fresh-data](https://docs.sushi.com/api/errors/no-fresh-data) | No Fresh Data | 500        |

**Example of an <code>no-fresh-data</code> problem details:**

```json
{
  "type": "https://docs.sushi.com/api/errors/no-fresh-data",
  "title": "No Fresh Data Error",
  "details": "Network 1 data timeout",
  "status": 500,
  "code": "500-02",
}
```


## Not Found

This problem occurs when the requested resource could not be found.

Your client application tried to access a resource that does not exist (or could not be found). Please review how your users initiated such a request.

| **Type URI**                                                                               | **Title** | **Status** |
| ------------------------------------------------------------------------------------------ | --------- | ---------- |
| [https://docs.sushi.com/api/errors/not-found](https://docs.sushi.com/api/errors/not-found) | Not Found | 404        |

**Example of an <code>not-found</code> problem details:**

```json
{
  "type": "https://docs.sushi.com/api/errors/not-found",
  "title": "Not Found",
  "detail": "The requested resource was not found",
  "status": 404,
  "code": "404-01"
}
```


## Ratelimit Exceeded

This problem occurs when the provided API key has exceeded its rate limit.

Your client application tried to access a resource that requires an API key, but the key has exceeded its rate limit. Please try again later.

| **Type URI**                                                                                                 | **Title**          | **Status** |
| ------------------------------------------------------------------------------------------------------------ | ------------------ | ---------- |
| [https://docs.sushi.com/api/errors/ratelimit-exceeded](https://docs.sushi.com/api/errors/ratelimit-exceeded) | Ratelimit Exceeded | 429        |

**Example of an <code>ratelimit-exceeded</code> problem details:**

```json
{
  "type": "https://docs.sushi.com/api/errors/ratelimit-exceeded",
  "title": "Rate Limit Exceeded",
  "details": "API key rate limit exceeded",
  "status": 429,
  "code": "429-01",
}
```


## Server

This problem occurs when the server encounters an unexpected condition that prevents it from fulfilling the request.

Your client application did everything correct. Unfortunately our API encountered a condition that resulted in this problem.

| **Type URI**                                                                         | **Title** | **Status** |
| ------------------------------------------------------------------------------------ | --------- | ---------- |
| [https://docs.sushi.com/api/errors/server](https://docs.sushi.com/api/errors/server) | Server    | 500        |

**Example of an <code>server</code> problem details:**

```json
{
  "type": "https://docs.sushi.com/api/errors/server",
  "title": "Server",
  "detail": "The server encountered an unexpected error",
  "status": 500,
  "code": "500-01"
}
```


## Service Unavailable

This problem occurs when the service requested is currently unavailable and the server is not ready to handle the request

Your client application did everything correct. Unfortunately our API is currently unavailable.

| **Type URI**                                                                                                   | **Title**           | **Status** |
| -------------------------------------------------------------------------------------------------------------- | ------------------- | ---------- |
| [https://docs.sushi.com/api/errors/service-unavailable](https://docs.sushi.com/api/errors/service-unavailable) | Service Unavailable | 503        |

**Example of an <code>service-unavailable</code> problem details:**

```json
{
  "type": "https://docs.sushi.com/api/errors/service-unavailable",
  "title": "Service Unavailable",
  "detail": "The service is currently unavailable",
  "status": 503,
  "code": "503-01"
}
```


## Unauthorized

This problem occurs when the provided API key has blacklisted / not-whitelisted your IP address or origin.

Your client application tried to access a resource that requires an API key, but the key has either blacklisted or not whitelisted your IP address or origin. Please check your API key and try again. It can be provided as a query parameter or in the authorization header.

| **Type URI**                                                                                     | **Title**    | **Status** |
| ------------------------------------------------------------------------------------------------ | ------------ | ---------- |
| [https://docs.sushi.com/api/errors/unauthorized](https://docs.sushi.com/api/errors/unauthorized) | Unauthorized | 403        |

**Example of an <code>unauthorized</code> problem details:**

```json
{
  "type": "https://docs.sushi.com/api/errors/unauthorized",
  "title": "Unauthorized",
  "details": "IP not whitelisted",
  "status": 403,
  "code": "403-01",
}
```


## Validation

This problem occurs when the request is deemed unprocessable.

Your client issued a request that failed validation. Certain validation libraries return multi-errors and cannot be easily parsed into discreet types. This problem type, afforded the provider with the ability to surface all validation errors and negate the need for a trial and error workflow on your side.

Please review your request to determine if you can remain within appropriate business rules. Consider validating your request against available metadata (e.g. schemas) prior to sending to the server.

| **Type URI**                                                                                 | **Title**  | **Status** |
| -------------------------------------------------------------------------------------------- | ---------- | ---------- |
| [https://docs.sushi.com/api/errors/validation](https://docs.sushi.com/api/errors/validation) | Validation | 422        |

**Example of an <code>validation</code> problem details:**

```json
{
  "type": "https://docs.sushi.com/api/errors/validation",
  "title": "Validation Error",
  "detail": "The request is invalid.",
  "status": 422,
  "code": "422-01",
  "errors": [
    { "detail": "Required", "parameter": "tokenIn" },
    { "detail": "Required", "parameter": "tokenOut" },
    { "detail": "Required", "parameter": "sender" },
    { "detail": "Required", "parameter": "amount" }
  ]
}
```


import Swagger from "../../../components/swagger";
import spec from "../../../public/blade-v2-openapi.json";

<Swagger spec={spec} defaultModelsExpandDepth={-1} docExpansion="list" defaultModelRendering="example" />


## clAMM

The **Concentrated Liquidity Automated Market Maker (clAMM)** allows liquidity providers to focus their capital within specific price ranges rather than across the entire price curve. This enables more efficient use of liquidity, reducing slippage for trades within those ranges, and increasing the potential fee earnings for liquidity providers. Uniswap V3 introduced this model, allowing liquidity providers to have better control over their positions.


## cpAMM

The **Constant Product Automated Market Maker (cpAMM)** uses a simple formula: x \* y = k, where x and y represent the reserves of two assets, and k is a constant. This ensures that the product of the two asset reserves always remains the same. It’s the most widely used AMM model, popularized by Uniswap V2. The cpAMM provides liquidity for any price point, though with higher slippage for large trades, particularly for volatile or low-liquidity pairs.


## AMM

SushiSwap is a decentralized exchange protocol originally forked from Uniswap, sharing its core Automated Market Maker (AMM) design.

### V2: Decentralized Liquidity Pools

V2 is a decentralized exchange protocol that enables token swaps using automated liquidity pools.

#### Key Features:

* **Automated Market Maker (AMM):** Trades occur through smart contracts, with users providing liquidity by depositing token pairs.
* **Constant Product Formula:** Maintains pool balance using the formula `x * y = k`.
* **Fee Structure:** A 0.30% trading fee is distributed to liquidity providers (LPs).
* **Token Pair Swaps:** Facilitates ERC-20 to ERC-20 token swaps seamlessly.

V2 introduced a simple, reliable way to trade tokens in a decentralized manner.

***

### V3: Concentrated Liquidity & Customization

V3 enhances the decentralized exchange experience by introducing more flexibility and efficiency for liquidity providers and traders.

#### Key Features:

* **Concentrated Liquidity:** Allows LPs to allocate capital to specific price ranges for improved efficiency.
* **Custom Fee Tiers:** Offers different fee levels (e.g., 0.01%, 0.05%, 0.30%, 1.00%) tailored to market conditions.
* **Active Position Management:** LPs can dynamically manage their positions for optimized returns.
* **NFT-Based Positions:** Each liquidity position is represented as a non-fungible token (NFT), this makes every position unique and transferable.

V3 is designed to offer advanced tools for more precise and efficient liquidity management.


## cpAMM

The **Liquidity Book Automated Market Maker (lbAMM)** is a more advanced AMM model that divides liquidity into "bins," each corresponding to a specific price range. This allows for more granular liquidity management, ensuring minimal slippage as trades happen within each price bin. Liquidity providers can select specific price bins, offering more control over liquidity placement. This structure helps reduce impermanent loss and increases capital efficiency, making it ideal for volatile or unevenly distributed assets. This approach was introduced by Trader Joe on the Avalanche network.


## Introduction

The Sushi Aggregator is a robust DeFi tool designed to optimize trade execution across multiple decentralized exchanges (DEXs). It enables users to achieve the best possible rates by aggregating liquidity from various sources, thereby minimizing slippage and maximizing returns.

At its core, the Sushi Aggregator relies on three key components:

**1. Extractor:** Extractor continuously gathers real-time liquidity source state from the blockchain—such as token reserves, swap fees, and pool balances—from various DEXs. This data is then fed into Tines, ensuring accurate calculations for route optimization and enabling quick adaptation to changing market conditions.

**2. Tines Pathfinding Algorithm:** Tines, the off-chain routing engine, uses the Dijkstra shortest path algorithm to calculate the most efficient trading routes. It considers multiple factors, such as liquidity, fees, gas cost, and price impact, to create an optimal path for executing trades.

**2. RouteProcessor Contract:** Once Tines determines the best route, the RouteProcessor smart contract comes into play. This on-chain contract is responsible for executing the multi-hop or multi-platform trades precisely as calculated by Tines. It handles all token swaps and ensures smooth and secure execution of the proposed route without requiring users to interact with multiple DEXs.

By combining the computational efficiency of off-chain optimization with the reliability of on-chain execution, the Sushi Aggregator provides a seamless and efficient trading experience, catering to both casual users and sophisticated traders.