Sushi

https://docs.sushi.com
Admin
Sushi is a decentralized finance (DeFi) platform featuring an Automated Market Maker (AMM), a swap...
Tokens:67,776
Snippets:579
Trust Score:9.8
Update:4 days ago
Show doc for...
Tokens:
Raw
### sushi/evm Utils Usage Example

Source: https://docs.sushi.com/sdk/reference/evm/utils

Example demonstrating how to import and use the normalizeEvmAddress and addGasMargin functions from the 'sushi/evm' module.

```APIDOC
## sushi/evm Utils

### Description
Low-level EVM utility functions for address normalization, create2 computation, and gas margin calculation.

### Functions

#### normalizeEvmAddress
- **Signature**: `normalizeEvmAddress(address: string): string`
- **Purpose**: Normalize an EVM address.

#### getCreate2Address
- **Signature**: `getCreate2Address(...): string`
- **Purpose**: Compute a create2 contract address.

#### addGasMargin
- **Signature**: `addGasMargin(gas: bigint): bigint`
- **Purpose**: Add a safety margin to a gas value.

### Usage Example
```ts
import { addGasMargin, normalizeEvmAddress } from 'sushi/evm'

const address = normalizeEvmAddress('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48')
const gas = addGasMargin(100_000n)
```

### Notes
These are low-level helpers. Prefer higher-level SDK APIs unless you are building routing, pool, or contract integrations.
```

--------------------------------

### SushiSwapV2Pool Usage Example

Source: https://docs.sushi.com/sdk/guides/pools-v2

Example of creating a SushiSwapV2Pool instance and performing a quote.

```APIDOC
## SushiSwapV2Pool

### Description
Class for local SushiSwap V2 pool math. Does not fetch reserves from chain; you must provide current reserves.

### Constructor
`new SushiSwapV2Pool(reserve0: Amount, reserve1: Amount)`

### Methods
- `getAddress(tokenA: EvmToken, tokenB: EvmToken): string` - Computes the pool address.
- `getOutputAmount(inputAmount: Amount): [Amount]` - Quotes exact input.
- `getInputAmount(outputAmount: Amount): [Amount]` - Quotes exact output.
- `getLiquidityMinted(totalSupply: Amount, reserve0: Amount, reserve1: Amount, amount0: Amount, amount1: Amount): Amount` - Computes minted liquidity.
- `getLiquidityValue(token: EvmToken, totalSupply: Amount, reserve: Amount): Amount` - Computes liquidity value.

### Properties
- `token0Price` - Price of token0 in terms of token1.
- `token1Price` - Price of token1 in terms of token0.
- `priceOf(token: EvmToken): Amount` - Price of the given token.

### Example
```ts
import { Amount } from 'sushi'
import { EvmToken, SushiSwapV2Pool } from 'sushi/evm'

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

const tokenB = new EvmToken({
  chainId: 1,
  address: '0x6B3595068778DD592e39A122f4f5a5cF09C90fE2',
  symbol: 'SUSHI',
  name: 'SushiToken',
  decimals: 18,
})

const poolAddress = SushiSwapV2Pool.getAddress(tokenA, tokenB)

const pool = new SushiSwapV2Pool(
  new Amount(tokenA, 1_000_000_000n),
  new Amount(tokenB, 500_000_000_000_000_000_000n),
)

const [outputAmount] = pool.getOutputAmount(new Amount(tokenA, 1_000_000n))
```
```

--------------------------------

### Construct Price from base and quote amounts and get quote

Source: https://docs.sushi.com/sdk/concepts/primitives

Shows how to create a Price from base and quote amounts and use getQuote to convert a base amount to a quote amount. The example uses SUSHI as base and USDC as quote.

```TypeScript
import { Amount, Price } from 'sushi'
import { EvmToken } from 'sushi/evm'

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

const SUSHI = new EvmToken({
  chainId: 1,
  address: '0x6b3595068778dd592e39a122f4f5a5cf09c90fe2',
  symbol: 'SUSHI',
  name: 'SushiToken',
  decimals: 18,
})

const price = new Price({
  baseAmount: Amount.fromHuman(SUSHI, '1'),
  quoteAmount: Amount.fromHuman(USDC, '2.5'),
})

const quote = price.getQuote(Amount.fromHuman(SUSHI, '4'))

quote.toString() // '10'
```

--------------------------------

### Example Mutation Variables

Source: https://docs.sushi.com/launchpad/integrators

Example JSON variables for the UpdateLaunchpadMetadata mutation. The deadline is a decimal string representing a Unix timestamp.

```json
{
  "input": {
    "chainId": 4663,
    "tokenAddress": "0x...",
    "expectedRevision": 0,
    "metadata": {
      "description": "A Launchpad token",
      "links": [
        {
          "kind": "homepage",
          "url": "https://example.com/",
          "label": "Website"
        }
      ]
    },
    "image": "<canonical base64 without a data URL prefix>",
    "deadline": "<current Unix time + 600>"
  },
  "signature": "0x..."
}
```

--------------------------------

### Install Sushi via npm

Source: https://docs.sushi.com/

Use this command to install the Sushi package using the npm package manager.

```bash
npm install sushi
```

--------------------------------

### Price Usage Example

Source: https://docs.sushi.com/sdk/reference/sushi/currency

Demonstrates creating a Price from base and quote amounts and using its methods.

```APIDOC
## Price Usage Example

### Description
Shows how to create a Price instance and use its invert and toSignificant methods.

### Code Example
```ts
import { Amount, Price, type Currency } from 'sushi'

declare const base: Currency
declare const quote: Currency

const price = new Price({
  baseAmount: Amount.fromHuman(base, '1'),
  quoteAmount: Amount.fromHuman(quote, '2'),
})

price.invert()
price.toSignificant(4)
```

### Methods
- `invert()` - Inverts the price.
- `toSignificant(significantDigits)` - Formats the price to a significant number of digits.
```

--------------------------------

### Example variables for Launchpad tokens query

Source: https://docs.sushi.com/launchpad/integrators

Example input variables for the LaunchpadTokens query. Uses chainId 4663 (Robinhood Chain), providers SUSHI_V2, first 20, sorted by CREATED_AT descending.

```json
{
  "input": {
    "chainId": 4663,
    "providers": ["SUSHI_V2"],
    "first": 20,
    "sortBy": "CREATED_AT",
    "sortDirection": "DESC"
  }
}
```

--------------------------------

### Amount Usage Example

Source: https://docs.sushi.com/sdk/reference/sushi/currency

Demonstrates constructing an Amount from a human-readable string and performing arithmetic operations.

```APIDOC
## Amount Usage Example

### Description
Shows how to create an Amount from a human decimal and perform addition.

### Code Example
```ts
import { Amount, type Currency } from 'sushi'

declare const currency: Currency

const one = Amount.fromHuman(currency, '1')
const two = one.addHuman('1')

two.toString() // '2'
two.toJSON()
```

### Methods
- `new Amount(currency, amount)` - Construct from raw units.
- `Amount.fromHuman(currency, value)` - Parse a human decimal using currency decimals.
- `Amount.tryFromHuman(currency, value)` - Safe parse returning `undefined` on failure.
- `add`, `sub`, `mul`, `div` - Raw-unit arithmetic.
- `addHuman`, `subHuman`, `mulHuman` - Human-value helpers.
- `gt`, `gte`, `lt`, `lte`, `eq` - Compare raw values.
- `wrap` - Wrap the underlying currency.
- `toJSON` - Serialize safely.
- `toString`, `toSignificant` - Format for display.
```

--------------------------------

### Chain Exports Usage Example

Source: https://docs.sushi.com/sdk/reference/sushi/chain

Example demonstrating how to use the chain exports from the sushi package, including ChainId, getChainById, getChainByKey, chains, and isChainId.

```APIDOC
## Chain Exports Usage Example

### Description
Demonstrates usage of the chain exports from the sushi package, including ChainId, getChainById, getChainByKey, chains, and isChainId.

### Exports
- **chains** (array) - All known chains.
- **ChainId** (enum-like) - Lookup from uppercase chain keys to chain IDs.
- **chainIds** (array) - Known chain ID array.
- **isChainId** (function) - Type guard for unknown numbers.
- **getChainById** (function) - Lookup by chain ID.
- **MainnetChainId** (type) - Mainnet type.
- **isMainnetChainId** (function) - Mainnet guard.
- **TestnetChainId** (type) - Testnet type.
- **isTestnetChainId** (function) - Testnet guard.
- **ChainKey** (type) - Chain key type.
- **isChainKey** (function) - Chain key guard.
- **getChainByKey** (function) - Lookup by chain key.

### Example Code
```ts twoslash
import { ChainId, chains, getChainById, getChainByKey, isChainId } from 'sushi'

const ethereum = getChainById(ChainId.ETHEREUM)
const base = getChainByKey('base')

for (const chain of chains) {
  console.log(chain.name)
}

if (isChainId(1)) {
  getChainById(1)
}
```
```

--------------------------------

### Importing SVM configuration constants

Source: https://docs.sushi.com/sdk/reference/svm/config

Example showing how to import specific SVM configuration constants from the sushi/svm package.

```ts
import { SVM_WNATIVE, WSOL, svmDefaultQuoteCurrency } from 'sushi/svm'
```

--------------------------------

### Import and use EVM chain functions

Source: https://docs.sushi.com/sdk/reference/evm/chain

Example showing how to import EvmChainId, getEvmChainById, and getEvmChainByKey from 'sushi/evm' and retrieve chain objects.

```APIDOC
## Import and use EVM chain functions

### Description
This example demonstrates how to import and use EVM chain functions from the sushi/evm module.

### Code
```ts
import { EvmChainId, getEvmChainById, getEvmChainByKey } from 'sushi/evm'

const ethereum = getEvmChainById(EvmChainId.ETHEREUM)
const base = getEvmChainByKey('base')

ethereum.viemChain
```
```

--------------------------------

### Fetch prices for many tokens and a single token using the Pricing API

Source: https://docs.sushi.com/api/examples/pricing

TypeScript example using fetch to call the Pricing API. It first fetches prices for many tokens on chainId 1, then fetches a single token price for the SUSHI address. The example constructs URLs using the base 'https://api.sushi.com/price/v1/' and logs the URLs and responses.

```TypeScript
// 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)
```

--------------------------------

### Import and use token list constants

Source: https://docs.sushi.com/sdk/reference/evm/token-list

Example showing how to import and use the DEFAULT_ACTIVE_LIST_URLS and DEFAULT_LIST_OF_LISTS constants from the sushi/evm module.

```APIDOC
## Import and use token list constants

### Description
This example demonstrates how to import and use the token list URL constants from the sushi/evm module.

### Code
```ts
import { DEFAULT_ACTIVE_LIST_URLS, DEFAULT_LIST_OF_LISTS } from 'sushi/evm'

DEFAULT_ACTIVE_LIST_URLS
DEFAULT_LIST_OF_LISTS
```
```

--------------------------------

### RedSnwapperProxy contract example

Source: https://docs.sushi.com/contracts/red-snwapper

A proxy contract demonstrating how to pre-fund RedSnwapper with tokens or ETH before executing a swap call.

```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));
  }
}
```

--------------------------------

### MvmToken and serializedMvmTokenSchema usage

Source: https://docs.sushi.com/sdk/reference/mvm/currency

Example showing how to create an MvmToken instance and parse its serialized JSON using the serializedMvmTokenSchema.

```APIDOC
## MvmToken and serializedMvmTokenSchema

### Description
Creates a new MvmToken instance and validates its serialized form using the serializedMvmTokenSchema.

### Imports
```ts
import { MvmToken, serializedMvmTokenSchema } from 'sushi/mvm'
```

### Example
```ts
const token = new MvmToken({
  chainId: -1,
  address: '0x1::aptos_coin::AptosCoin',
  symbol: 'APT',
  name: 'Aptos Coin',
  decimals: 8,
})

const parsed = serializedMvmTokenSchema().parse(token.toJSON())
```

### Parameters
- **chainId** (number) - Required - The chain ID for the token.
- **address** (string) - Required - The Move type-tag address, e.g., '0x1::aptos_coin::AptosCoin'.
- **symbol** (string) - Required - The token symbol.
- **name** (string) - Required - The token name.
- **decimals** (number) - Required - The number of decimals for the token.

### Returns
- **token** (MvmToken) - A new MvmToken instance.
- **parsed** (SerializedMvmToken) - The parsed serialized token from the schema.
```

--------------------------------

### Initialize Fraction and Percent

Source: https://docs.sushi.com/sdk/reference/sushi/math

Demonstrates creating a Fraction with BigInt values and a Percent instance for slippage calculations.

```ts
import { Fraction, Percent } from 'sushi'

const ratio = new Fraction({ numerator: 1n, denominator: 3n })
const doubled = ratio.mul(2n)
const slippage = new Percent({ numerator: 5n, denominator: 1000n })
```

--------------------------------

### Get native ETH and wrap it

Source: https://docs.sushi.com/sdk/reference/evm/currency

Uses EvmNative.fromChainId(1) to get the native ETH currency and then calls wrap() to get the wrapped native representation (WETH).

```TypeScript
import { EvmNative } from 'sushi/evm'

const eth = EvmNative.fromChainId(1)
const weth = eth.wrap()
```

--------------------------------

### Initialize SushiSwapV2Pool and calculate output amount

Source: https://docs.sushi.com/sdk/guides/pools-v2

Demonstrates how to instantiate a SushiSwapV2Pool with token amounts and calculate the output amount for a given input. Reserves must be provided manually as the class does not fetch them from the chain.

```ts
import { Amount } from 'sushi'
import { EvmToken, SushiSwapV2Pool } from 'sushi/evm'

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

const tokenB = new EvmToken({
  chainId: 1,
  address: '0x6B3595068778DD592e39A122f4f5a5cF09C90fE2',
  symbol: 'SUSHI',
  name: 'SushiToken',
  decimals: 18,
})

const poolAddress = SushiSwapV2Pool.getAddress(tokenA, tokenB)

const pool = new SushiSwapV2Pool(
  new Amount(tokenA, 1_000_000_000n),
  new Amount(tokenB, 500_000_000_000_000_000_000n),
)

const [outputAmount] = pool.getOutputAmount(new Amount(tokenA, 1_000_000n))
```

--------------------------------

### Launch and Buy with ERC-20

Source: https://docs.sushi.com/launchpad/creators

Deploys a token and performs an initial buy using an ERC-20 quote token. The caller must approve the Launchpad proxy to transfer the amountIn.

```solidity
function launchAndBuy(
  TokenConfig calldata tokenConfig,
  address quoteToken,
  LiquidityMode liquidityMode,
  FeeDisposition feeDisposition,
  InitialBuy calldata initialBuy
)
  external
  payable
  returns (
    address token,
    address pool,
    uint256[] memory positionIds,
    uint256 amountOut
  );
```

--------------------------------

### launchAndBuyNative

Source: https://docs.sushi.com/launchpad/creators

Launches a new token and performs an initial buy using the native token. The native token is wrapped into WETH and used as the quote token. Requires msg.value to be at least launchFee() + initialBuy.amountIn.

```APIDOC
## launchAndBuyNative

### Description
Launches a new token and performs an initial buy using the native token. The native token is wrapped into WETH and used as the quote token. Requires msg.value to be at least launchFee() + initialBuy.amountIn.

### Function Signature
function launchAndBuyNative(TokenConfig calldata tokenConfig, LiquidityMode liquidityMode, FeeDisposition feeDisposition, InitialBuy calldata initialBuy) external payable returns (address token, address pool, uint256[] memory positionIds, uint256 amountOut);

### Parameters
- tokenConfig (TokenConfig) - Required - Token name and symbol. name limited to 64 bytes, symbol to 16 bytes.
- liquidityMode (LiquidityMode) - Required - STANDARD or MOON.
- feeDisposition (FeeDisposition) - Required - DIRECT_PAYOUT, BURN_LAUNCH_TOKEN_FEES, or BUYBACK_AND_BURN.
- initialBuy (InitialBuy) - Required - Contains amountIn, amountOutMinimum, and recipient.
  - amountIn (uint256) - Exact amount of the native token to spend, in its smallest unit. No ERC-20 approval is required.
  - amountOutMinimum (uint256) - Minimum launch-token amount the recipient must receive.
  - recipient (address) - Address that receives the purchased launch tokens. It cannot be zero, the Launchpad proxy, its custodian or fee executor, or the newly created pool.

### Payable
Send at least launchFee() + initialBuy.amountIn as msg.value; no ERC-20 approval is required.

### Returns
- token (address) - The deployed token address.
- pool (address) - The V3 pool address.
- positionIds (uint256[]) - Position NFT IDs: one for Standard Mode or seven for Moon Mode.
- amountOut (uint256) - The amount of launch tokens received by the recipient.

### Revert Conditions
The recipient and exact-input/minimum-output rules are the same as for launchAndBuy.
```

--------------------------------

### Insufficient Allowance Error Example

Source: https://docs.sushi.com/api/errors/insufficient-allowance

Example of the problem details JSON returned when a spender has insufficient allowance.

```APIDOC
## Insufficient Allowance Error

### Description
This error occurs when the spender does not have sufficient allowance for a swap estimation. The estimation cannot complete successfully.

### Type URI
https://docs.sushi.com/api/errors/insufficient-allowance

### Status
422

### Example Response Body
{
  "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"
}
```

--------------------------------

### Launch and Buy with Native Token

Source: https://docs.sushi.com/launchpad/creators

Deploys a token and performs an initial buy using the native token. The function wraps the native token into WETH; msg.value must cover both the launch fee and the initial buy amount.

```solidity
function launchAndBuyNative(
  TokenConfig calldata tokenConfig,
  LiquidityMode liquidityMode,
  FeeDisposition feeDisposition,
  InitialBuy calldata initialBuy
)
  external
  payable
  returns (
    address token,
    address pool,
    uint256[] memory positionIds,
    uint256 amountOut
  );
```

--------------------------------

### launchAndBuy

Source: https://docs.sushi.com/launchpad/creators

Launches a new token and performs an initial buy using an ERC-20 quote token. The caller must approve the Launchpad proxy to transfer the amountIn. Requires msg.value to pay the launchFee and amountIn is transferred separately.

```APIDOC
## launchAndBuy

### Description
Launches a new token and performs an initial buy using an ERC-20 quote token. The caller must approve the Launchpad proxy to transfer the amountIn. Requires msg.value to pay the launchFee and amountIn is transferred separately.

### Function Signature
function launchAndBuy(TokenConfig calldata tokenConfig, address quoteToken, LiquidityMode liquidityMode, FeeDisposition feeDisposition, InitialBuy calldata initialBuy) external payable returns (address token, address pool, uint256[] memory positionIds, uint256 amountOut);

### Parameters
- tokenConfig (TokenConfig) - Required - Token name and symbol. name limited to 64 bytes, symbol to 16 bytes.
- quoteToken (address) - Required - ERC-20 token with an allowlisted USD price feed.
- liquidityMode (LiquidityMode) - Required - STANDARD or MOON.
- feeDisposition (FeeDisposition) - Required - DIRECT_PAYOUT, BURN_LAUNCH_TOKEN_FEES, or BUYBACK_AND_BURN.
- initialBuy (InitialBuy) - Required - Contains amountIn, amountOutMinimum, and recipient.
  - amountIn (uint256) - Exact amount of the quote token to spend, in its smallest unit. The caller must approve the Launchpad proxy to transfer at least this amount.
  - amountOutMinimum (uint256) - Minimum launch-token amount the recipient must receive.
  - recipient (address) - Address that receives the purchased launch tokens. It cannot be zero, the Launchpad proxy, its custodian or fee executor, or the newly created pool.

### Payable
msg.value pays the current native launchFee(); amountIn is transferred separately from the caller.

### Returns
- token (address) - The deployed token address.
- pool (address) - The V3 pool address.
- positionIds (uint256[]) - Position NFT IDs: one for Standard Mode or seven for Moon Mode.
- amountOut (uint256) - The amount of launch tokens received by the recipient.

### Revert Conditions
The swap must consume the complete input and satisfy amountOutMinimum. Otherwise token deployment, pool creation, and the purchase all revert.
```

--------------------------------

### Server Error Example

Source: https://docs.sushi.com/api/errors/server

Example of a server problem details response, showing the structure of the error object returned by the API.

```APIDOC
## Server Error

### Description
The server encountered an unexpected condition that prevented it from fulfilling the request. The client application did everything correct, but the API encountered a condition that resulted in this problem.

### Type URI
https://docs.sushi.com/api/errors/server

### Title
Server

### Status
500

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

--------------------------------

### TypeScript example: Fetch swap data and execute transaction

Source: https://docs.sushi.com/api/examples/swap

Uses viem clients and the sushi/evm SwapResponse type to call the Swap API, simulate the swap, and send the transaction. Requires a private key and sender address; an API key can be added via the apiKey search param. Logs the API URL, response data, simulated output, and transaction hash.

```TypeScript
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 = '0x...' 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)
}
```

--------------------------------

### Import and use erc20Abi with viem

Source: https://docs.sushi.com/sdk/reference/evm/abi

Example showing how to import an ABI from the sushi/evm module and use it with viem's readContract to read contract data.

```APIDOC
## Import and use erc20Abi with viem

### Description
Demonstrates importing the erc20Abi from the sushi/evm module and using it with viem's readContract to read the decimals of an ERC-20 token.

### Code Example
```ts
import { erc20Abi } from 'sushi/evm'

const decimals = await publicClient.readContract({
  address: tokenAddress,
  abi: erc20Abi,
  functionName: 'decimals',
})
```
```

--------------------------------

### GET /rfq/v2/pool/{chainId}

Source: https://docs.sushi.com/api/blade/swagger

Retrieves pool information and liquidity data for a specified chain. This endpoint is used to get details about the liquidity pool on a given blockchain network.

```APIDOC
## GET /rfq/v2/pool/{chainId}

### Description
Get pool information and liquidity data for a specified chain.

### Method
GET

### Endpoint
/rfq/v2/pool/{chainId}

### Parameters
#### Path Parameters
- **chainId** (string) - Required - The blockchain network identifier.

```

--------------------------------

### EvmNative

Source: https://docs.sushi.com/sdk/reference/evm/currency

Creates an EVM native asset instance. Provides a static factory method to get the native asset for a chain ID and a wrap method to get the wrapped representation.

```APIDOC
## EvmNative

### Description
Represents the native asset of an EVM chain. Use `EvmNative.fromChainId` to get the native asset for a chain, and `wrap()` to get the wrapped representation.

### Static Methods
- **fromChainId(chainId)** - Returns the native asset for the given chain ID.

### Members
- **wrap()** - Returns the wrapped representation (e.g., WETH).

### Example
```ts
import { EvmNative } from 'sushi/evm'

const eth = EvmNative.fromChainId(1)
const weth = eth.wrap()
```
```

--------------------------------

### GraphQL query: launchpad.token with inline fragment for SushiV2LaunchpadToken

Source: https://docs.sushi.com/launchpad/integrators

Use this query when you already know the token address. It fetches common token fields plus V2-only fields via an inline fragment on SushiV2LaunchpadToken. Fee values are basis points (2000 means 20%). metadata is always present; without creator-authored metadata, links is empty, description is nullable, and revision is 0.

```graphql
query LaunchpadToken($chainId: LaunchpadChainId!, $address: EvmAddress!) {
  launchpad {
    token(chainId: $chainId, address: $address) {
      address
      creator
      provider
      factoryAddress
      name
      symbol
      initialSupply
      initialFdvUsd
      indexingStatus
      metadata {
        description
        links {
          kind
          url
          label
        }
        revision
        updatedAt
      }
      pool {
        address
        feeTier
        quoteToken {
          address
          name
          symbol
          decimals
        }
      }
      ... on SushiV2LaunchpadToken {
        launchCreator
        currentSupply
        feeReceiver
        feeReceiverLocked
        liquidityMode
        feeDisposition
        feeSplit {
          sushiFeeBps
          nonSushiFeeBps
        }
        devBuy {
          quoteSpent
          launchTokenReceived
        }
        burns {
          directFeeBurned
          buybackBurned
          protocolBurned
          totalBurned
        }
        poolInitializedAt
      }
    }
  }
}
```

--------------------------------

### getSvmCurrencyAddress

Source: https://docs.sushi.com/sdk/reference/svm/currency

Get token/native address representation.

```APIDOC
## getSvmCurrencyAddress

### Description
Get token/native address representation.
```

--------------------------------

### InsufficientInputAmountError

Source: https://docs.sushi.com/sdk/reference/evm/dex

Example of creating and using the InsufficientInputAmountError class from the sushi/evm DEX module.

```APIDOC
## InsufficientInputAmountError

### Description
Creates an error instance for insufficient input amount in DEX operations.

### Import
```ts
import { InsufficientInputAmountError } from 'sushi/evm'
```

### Usage
```ts
const error = new InsufficientInputAmountError()

if (error instanceof InsufficientInputAmountError) {
  console.log('Input amount is too small')
}
```
```

--------------------------------

### Response examples for multiple and single price endpoints

Source: https://docs.sushi.com/api/examples/pricing

JSONC examples showing the response format for the multiple prices endpoint and the single price endpoint. The multiple prices response is an object mapping token addresses to numeric USD prices, while the single price response is a single numeric USD price.

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

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

--------------------------------

### LowercaseMap

Source: https://docs.sushi.com/sdk/reference/sushi/utils

A Map subclass that lowercases string keys for get, has, set, and delete operations.

```APIDOC
## LowercaseMap

### Description
A Map subclass that lowercases string keys for get, has, set, and delete operations.

### Constructor
new LowercaseMap<K extends string, V>(entries?: readonly (readonly [K, V])[] | null)

### Methods
- **set(key: K, value: V): this** - Sets a key-value pair, lowercasing the key.
- **get(key: K): V | undefined** - Gets a value by key, lowercasing the key.
- **has(key: K): boolean** - Checks if a key exists, lowercasing the key.
- **delete(key: K): boolean** - Deletes a key, lowercasing the key.

### Example
```ts
import { LowercaseMap } from 'sushi'

const map = new LowercaseMap<string, number>()

map.set('ABC', 1)
map.get('abc') // 1
```
```

--------------------------------

### Accessing Chain Registry Utilities

Source: https://docs.sushi.com/sdk/reference/sushi/chain

Demonstrates how to import and use chain registry utilities such as getChainById, getChainByKey, and isChainId, as well as iterating over all known chains.

```ts
import { ChainId, chains, getChainById, getChainByKey, isChainId } from 'sushi'

const ethereum = getChainById(ChainId.ETHEREUM)
const base = getChainByKey('base')

for (const chain of chains) {
  console.log(chain.name)
}

if (isChainId(1)) {
  getChainById(1)
}
```

--------------------------------

### Get native address with getNativeAddress

Source: https://docs.sushi.com/sdk/reference/sushi/utils

Retrieves the native address representation for a specified chain.

```ts
import { ChainId, getNativeAddress } from 'sushi'

const native = getNativeAddress(ChainId.ETHEREUM)
```

--------------------------------

### GET /price/v1/{chainId}

Source: https://docs.sushi.com/api/examples/pricing

Returns a map of token address to price (in USD) for the specified chainId.

```APIDOC
## GET /price/v1/{chainId}

### Description
Returns a map of token address to price (in USD) for the specified chainId.

### Method
GET

### Endpoint
/price/v1/{chainId}

### Parameters
#### Path Parameters
- **chainId** (number) - Required - The chain ID for which to fetch token prices.

### Response
#### Success Response (200)
- **token address** (string) - The token address.
- **price** (number) - The price in USD.

#### Response Example
{
  "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2": 2523.45,
  "0x6b3595068778dd592e39a122f4f5a5cf09c90fe2": 1.12
}
```

--------------------------------

### Use Fraction and Percent for precise rational arithmetic

Source: https://docs.sushi.com/sdk/concepts/primitives

Shows how to create a Fraction from bigint numerator and denominator, perform multiplication, and create a Percent for slippage. Percent extends Fraction and is useful for slippage, fees, and price impact values.

```TypeScript
import { Fraction, Percent } from 'sushi'

const oneThird = new Fraction({ numerator: 1n, denominator: 3n })
const doubled = oneThird.mul(2n)
const slippage = new Percent({ numerator: 5n, denominator: 1000n })

doubled.toSignificant(4)
```

--------------------------------

### JSON example: Successful SwapResponse

Source: https://docs.sushi.com/api/examples/swap

Shows the structure of a successful SwapResponse, including tokens, token indexes, swapPrice, priceImpact, amounts, and transaction details. Note that when simulate=true, a string field 'gas' is also included in the tx object.

```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
  }
}
```

--------------------------------

### normalizeSvmAddress

Source: https://docs.sushi.com/sdk/reference/svm/utils

Normalizes an SVM address. Import from 'sushi/svm' and call with an address string to get the normalized form.

```APIDOC
## normalizeSvmAddress

### Description
Normalizes an SVM address to its canonical form.

### Import
```ts
import { normalizeSvmAddress } from 'sushi/svm'
```

### Usage
```ts
const normalized = normalizeSvmAddress(address)
```

### Parameters
- **address** (string) - Required - The SVM address to normalize.

### Returns
- **normalized address** (string) - The normalized SVM address.
```

--------------------------------

### Generate a quote using the Quote API

Source: https://docs.sushi.com/api/examples/quote

This example demonstrates how to construct a URL for the Quote API with specific parameters like chain ID, input/output tokens, amount, and slippage, and then fetch the quote data.

```ts
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)
```

--------------------------------

### GET /price/v1/{chainId}

Source: https://docs.sushi.com/api/swagger

Returns prices for the specified chain ID. This endpoint is part of the price endpoints.

```APIDOC
## GET /price/v1/{chainId}

### Description
Returns prices for specified chainId.

### Method
GET

### Endpoint
/price/v1/{chainId}

### Parameters
#### Path Parameters
- **chainId** (integer) - Required - The chain ID for which to return prices.

```

--------------------------------

### GET /swap/v7/{chainId}

Source: https://docs.sushi.com/api/swagger

Generates a swap for a given chain ID. This endpoint is part of the swap endpoints.

```APIDOC
## GET /swap/v7/{chainId}

### Description
Generates a swap.

### Method
GET

### Endpoint
/swap/v7/{chainId}

### Parameters
#### Path Parameters
- **chainId** (integer) - Required - The chain ID for which to generate a swap.

```

--------------------------------

### GET /quote/v7/{chainId}

Source: https://docs.sushi.com/api/swagger

Generates a quote for a given chain ID. This endpoint is part of the swap endpoints.

```APIDOC
## GET /quote/v7/{chainId}

### Description
Generates a quote.

### Method
GET

### Endpoint
/quote/v7/{chainId}

### Parameters
#### Path Parameters
- **chainId** (integer) - Required - The chain ID for which to generate a quote.

```

--------------------------------

### Import sushi primitives

Source: https://docs.sushi.com/sdk/reference/sushi

Import the core chain-agnostic primitives from the root sushi entrypoint.

```ts
import { Amount, ChainId, Fraction, Price } from 'sushi'
```

--------------------------------

### Simulate and send swap transaction

Source: https://docs.sushi.com/sdk/guides/swap

Builds a swap with simulate: true, then uses viem public and wallet clients to call and send the transaction when the swap status is 'Success'. When simulation is enabled, successful responses may include tx.gas.

```TypeScript
import { getSwap } from 'sushi/evm'
import { createPublicClient, createWalletClient, http } from 'viem'
import { mainnet } from 'viem/chains'

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

const swap = await getSwap({
  chainId: 1,
  tokenIn: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
  tokenOut: '0x6B3595068778DD592e39A122f4f5a5cF09C90fE2',
  amount: 1_000_000_000_000_000_000n,
  sender: '0x0000000000000000000000000000000000000000',
  maxSlippage: 0.005,
  simulate: true,
})

if (swap.status === 'Success') {
  await publicClient.call({
    account: swap.tx.from,
    to: swap.tx.to,
    data: swap.tx.data,
    value: swap.tx.value,
  })

  await walletClient.sendTransaction({
    account: swap.tx.from,
    to: swap.tx.to,
    data: swap.tx.data,
    value: swap.tx.value,
  })
}
```

--------------------------------

### Estimate Gas Error Response

Source: https://docs.sushi.com/api/errors/estimate-gas

Example of the problem details JSON returned when an estimate-gas error occurs.

```APIDOC
## Estimate Gas Error

### Description
This error occurs when gas estimation fails. The client application did everything correctly, but the API encountered a condition that resulted in this problem.

### Error Details
- **Type URI**: https://docs.sushi.com/api/errors/estimate-gas
- **Title**: Estimate Gas Error
- **Status**: 422

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

--------------------------------

### Handle invalid hex strings

Source: https://docs.sushi.com/sdk/reference/sushi/validate

Invalid values that do not start with the 0x prefix will throw a Zod error.

```ts
import { hex } from 'sushi'

hex().parse('abcdef') // throws: missing 0x prefix
```
Tokens:
Raw