# CCIP v2.0.0 SiloedLockReleaseTokenPool API Reference
Source: https://docs.chain.link/ccip/evm/api-reference/v2.0.0/siloed-lock-release-token-pool

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

`SiloedLockReleaseTokenPool` is a `TokenPool` implementation that uses separate lockboxes per remote chain for lock and release operations.

If you use this pool, tokens are locked into and released from chain-specific lockboxes rather than a single shared liquidity pool.

This approach preserves total token supply while isolating liquidity across chains.

Use this variant when you need per-chain liquidity isolation instead of a shared lockbox model.

> 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.
- Use this pool when you want to isolate liquidity per destination chain.
- You are responsible for configuring a lockbox for each supported chain.
- If a lockbox is not configured for a chain, transfers to that chain will revert.

## Contract

`pools/SiloedLockReleaseTokenPool.sol`

## Import

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

If you have not installed the package:

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

## Inheritance

- `TokenPool`
- `ITypeAndVersion`

## Constructor

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

| Parameter            | Type      | Description                                               |
| -------------------- | --------- | --------------------------------------------------------- |
| `token`              | `IERC20`  | Token being bridged.                                      |
| `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

### getAllLockBoxConfigs

```solidity
function getAllLockBoxConfigs() external view returns (LockBoxConfig[] memory lockBoxConfigs)
```

> Returns all configured lockbox mappings.

Returns:

| Type                     | Description                               |
| ------------------------ | ----------------------------------------- |
| `LockBoxConfig[] memory` | List of lockbox configurations per chain. |

### configureLockBoxes

```solidity
function configureLockBoxes(LockBoxConfig[] calldata lockBoxConfigs) public onlyOwner
```

> Owner-only function to configure lockboxes for each remote chain. Incorrect configuration will cause transfers to fail.

| Parameter        | Type                       | Description                     |
| ---------------- | -------------------------- | ------------------------------- |
| `lockBoxConfigs` | `LockBoxConfig[] calldata` | Mapping of chains to lockboxes. |

### getLockBox

```solidity
function getLockBox(uint64 remoteChainSelector) public view returns (ILockBox)
```

> Returns the lockbox configured for a specific remote chain.

| Parameter             | Type     | Description                     |
| --------------------- | -------- | ------------------------------- |
| `remoteChainSelector` | `uint64` | Identifier of the remote chain. |

Returns:

| Type       | Description                  |
| ---------- | ---------------------------- |
| `ILockBox` | Lockbox used for that chain. |

## 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

```solidity
error LockBoxNotConfigured(uint64 remoteChainSelector);
```

Thrown when no lockbox is configured for the specified chain.

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

> Locks tokens into the lockbox configured for the destination chain.

- Tokens are transferred from the sender into the chain-specific lockbox.
- Reverts if no lockbox is configured.

### \_releaseOrMint

```solidity
function _releaseOrMint(
  address receiver,
  uint256 amount,
  uint64 remoteChainSelector
) internal override
```

> Releases tokens from the lockbox associated with the transfer for the destination chain.

- Tokens are transferred from the chain-specific lockbox to the receiver.
- Reverts if no lockbox is configured.

### \_preflightCheck

No-op override.

### \_postflightCheck

No-op override.

## Security model

- Each chain uses a separate lockbox for custody.
- Correct token transfers require accurate lockbox configuration and sufficient per-chain liquidity.
- Only authorized CCIP components (OnRamp and OffRamp) can trigger token movements.
- Missing or incorrect lockbox configuration causes transfers to fail.

## Notes

- This pool preserves total token supply using lock-and-release mechanics.
- Liquidity is isolated per chain rather than shared.
- Each chain maintains its own isolated liquidity pool, and transfers depend on the balance of the corresponding lockbox.
- Each lockbox must be pre-funded before transfers to that chain can succeed.
- Liquidity fragmentation can cause transfers to fail even if total system liquidity is sufficient.
- Compared to `LockReleaseTokenPool`, this model trades shared liquidity for per-chain isolation.
- Use `LockReleaseTokenPool` if you prefer a shared liquidity model.

## Related Interfaces & Contracts

- [`TokenPool`](/ccip/evm/api-reference/v2.0.0/token-pool)
- [`ILockBox`](/ccip/evm/api-reference/v2.0.0/i-lockbox)
- [`ERC20LockBox`](/ccip/evm/api-reference/v2.0.0/erc20-lockbox)
- [`LockReleaseTokenPool`](/ccip/evm/api-reference/v2.0.0/lock-release-token-pool)
- [`SiloedUSDCTokenPool`](/ccip/evm/api-reference/v2.0.0/siloed-usdc-token-pool)