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

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

`BurnFromMintTokenPool` is a `TokenPool` implementation that burns tokens using `burnFrom` on the source chain and mints tokens on the destination chain.

If you use this pool, tokens are transferred to the pool and burned from the pool’s own balance using `burnFrom(address(this), amount)`.

Use this variant when your token requires `burnFrom` and permits the pool contract to burn tokens from its own balance.

> 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 requires `burnFrom` instead of direct `burn`.
- You are responsible for ensuring the token supports the required `burnFrom` behavior.

## Contract

`pools/BurnFromMintTokenPool.sol`

## Import

```solidity
import {BurnFromMintTokenPool} from "chainlink-ccip/pools/BurnFromMintTokenPool.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 `burnFrom` 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 from the pool’s balance using `burnFrom(address(this), amount)`.

- Tokens are first transferred to the pool, then burned from the pool’s own balance.
- The underlying token must allow the pool to call `burnFrom(address(this), amount)`, including any required permissions or allowances.

### \_releaseOrMint

Inherited from `BurnMintTokenPoolAbstract`.

> Mints tokens to the receiver on the destination chain.

## Security model

- The pool depends on the underlying token correctly implementing `burnFrom` and mint functionality.
- The pool must be able to call `burnFrom(address(this), amount)` on the token, including any required allowance or permissions.
- Only authorized CCIP components (OnRamp and OffRamp) can trigger token movements.
- If the token restricts `burnFrom` or requires additional approvals, burn operations will fail.

## Notes

- Tokens are transferred to the pool before being burned.
- The pool may require allowance to call `burnFrom(address(this), amount)` depending on the token implementation.
- If your token does not support `burnFrom(address(this), amount)`, use a different pool variant.
- 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)
- [`BurnMintTokenPool`](/ccip/evm/api-reference/v2.0.0/burn-mint-token-pool)
- [`BurnWithFromMintTokenPool`](/ccip/evm/api-reference/v2.0.0/burn-with-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)