# CCIP v2.0.0 BurnMintTokenPool API Reference
Source: https://docs.chain.link/ccip/evm/api-reference/v2.0.0/burn-mint-token-pool

> For the complete documentation index, see [llms.txt](/llms.txt).

`BurnMintTokenPool` is a `TokenPool` implementation for bridging third-party tokens by burning tokens on the source chain and minting tokens on the destination chain.

If you use this pool, tokens are burned directly from the sender using the token’s standard `burn(amount)` path, rather than being transferred to the pool and burned from the pool’s balance.

Use this variant when your token supports direct burn operations and allows the pool to burn tokens from the sender.

> This contract is not intended to be called directly by applications. It is used by CCIP infrastructure during token transfers.

## Usage Boundary

**You do not call this contract directly.**

- The Router and OnRamp/OffRamp contracts invoke this pool during cross-chain token transfers.
- You choose this pool when configuring how a token is bridged across chains.
- Choose this pool only if your token supports direct `burn(amount)` instead of `burnFrom`.
- You are responsible for ensuring the pool has permission (for example, allowance or role-based access) to burn tokens from the sender.

## Contract

`pools/BurnMintTokenPool.sol`

## Import

```solidity
import {BurnMintTokenPool} from "chainlink-ccip/pools/BurnMintTokenPool.sol";
```

If you have not installed the package:

```bash
npm install @chainlink/contracts-ccip@2.0.0
```

## Inheritance

- `BurnMintTokenPoolAbstract`
- `ITypeAndVersion`

## Constructor

```solidity
constructor(
  IBurnMintERC20 token,
  uint8 localTokenDecimals,
  address advancedPoolHooks,
  address rmnProxy,
  address router
) TokenPool(
  token,
  localTokenDecimals,
  advancedPoolHooks,
  rmnProxy,
  router
)
```

| Parameter            | Type             | Description                                               |
| -------------------- | ---------------- | --------------------------------------------------------- |
| `token`              | `IBurnMintERC20` | Token that supports direct burn and mint functionality.   |
| `localTokenDecimals` | `uint8`          | Number of decimals used by the token on the local chain.  |
| `advancedPoolHooks`  | `address`        | Optional hook contract for custom pool behavior.          |
| `rmnProxy`           | `address`        | RMN proxy used for curse checks.                          |
| `router`             | `address`        | Address of the CCIP Router that interacts with this pool. |

## External API

No new public or external functions are declared.

All callable interfaces are inherited from `TokenPool`.

## typeAndVersion

```solidity
function typeAndVersion() external pure virtual override returns (string memory)
```

Returns:

| Type            | Description                           |
| --------------- | ------------------------------------- |
| `string memory` | Contract type and version identifier. |

## Events

No new events declared.

For a cross-contract event index, see [Events](/ccip/evm/api-reference/v2.0.0/events).

## Errors

No new custom errors declared.

For a cross-contract error index, see [Errors](/ccip/evm/api-reference/v2.0.0/errors).

## Internal Functions

### \_lockOrBurn

```solidity
function _lockOrBurn(
  uint64 /* remoteChainSelector */,
  uint256 amount
) internal override
```

> Burns tokens directly from the sender using the token’s `burn(amount)` implementation.

- Tokens are burned from the sender rather than transferred to the pool.
- The pool must have permission to call `burn(amount)` or an equivalent function that burns tokens from the sender.

### \_releaseOrMint

Inherited from `BurnMintTokenPoolAbstract`.

> Mints tokens to the receiver on the destination chain.

## Security model

- The pool depends on the underlying token correctly implementing `burn` and mint functionality.
- The pool must have permission to burn tokens directly from the sender, including any required allowances or role-based permissions.
- Only authorized CCIP components (OnRamp and OffRamp) can trigger token movements.
- If the token restricts burn operations or requires additional approvals, burn operations will fail.

## Notes

- Tokens are burned directly from the sender rather than transferred to the pool.
- This pool does not require the pool contract to hold tokens before burning.
- The pool may require allowance or role-based permissions to burn tokens from the sender.
- If your token does not support direct `burn(amount)`, use `BurnFromMintTokenPool` instead.
- Pool configuration and access behavior are fixed at deployment. Changing them requires deploying a new pool.

## Related Interfaces & Contracts

- [`BurnMintTokenPoolAbstract`](/ccip/evm/api-reference/v2.0.0/burn-mint-token-pool-abstract)
- [`BurnFromMintTokenPool`](/ccip/evm/api-reference/v2.0.0/burn-from-mint-token-pool)
- [`IBurnMintERC20`](/ccip/evm/api-reference/v2.0.0/i-burn-mint-erc20)
- [`TokenPool`](/ccip/evm/api-reference/v2.0.0/token-pool)
- [`LockReleaseTokenPool`](/ccip/evm/api-reference/v2.0.0/lock-release-token-pool)
- [`RateLimiter`](/ccip/evm/api-reference/v2.0.0/rate-limiter)
- [`TokenAdminRegistry`](/ccip/evm/api-reference/v2.0.0/token-admin-registry)