> ## Documentation Index
> Fetch the complete documentation index at: https://base-a060aa97-roethke-b20-upgrade-pages.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# IB20.seizeWithMemo

> Moves tokens from a holder to a safekeeping account in a single admin call without changing totalSupply.

## Signature

```solidity IB20.sol theme={null}
function seizeWithMemo(address from, address to, uint256 amount, bytes32 memo) external;
```

| Field | Value |
| - | - |
| Selector | `0xf916d81b` |
| Canonical signature | `seizeWithMemo(address,address,uint256,bytes32)` |

## Description

Moves `amount` from `from` to `to` in a single admin operation. `totalSupply` does not change. Emits, in order, `Transfer(from, to, amount)`, `Memo(caller, memo)`, and `Seized(caller, from, to, amount)`. A memo of `bytes32(0)` is permitted.

This is not a burn and not a mint. After the call, `to` is an ordinary holder and can transfer, burn, or hold the tokens.

Seize skips allowance and the transfer policies (`TRANSFER_SENDER_POLICY`, `TRANSFER_RECEIVER_POLICY`). It uses two dedicated policy scopes instead:

| Scope | Account | Passes when |
| - | - | - |
| `SEIZE_EXEMPT_POLICY` | `from` | `isAuthorized` returns `false` (inverted check) |
| `SEIZE_RECEIVER_POLICY` | `to` | `isAuthorized` returns `true` |

`SEIZE_EXEMPT_POLICY` is inverted: when the scope is unset (ID `0`, always-allow), every account is authorized and therefore no account is seizable. Attach a blocklist and add the holder to make them seizable.

`SEIZE_RECEIVER_POLICY` defaults to always-allow when unset, so an unconfigured token accepts any destination.

## Parameters

| Parameter | Type | Description |
| - | - | - |
| `from` | `address` | Account whose balance is being seized. Must be non-zero and distinct from `to`. |
| `to` | `address` | Destination for the seized balance. Must be non-zero and distinct from `from`. |
| `amount` | `uint256` | Amount to seize. Must not exceed `from`'s balance. |
| `memo` | `bytes32` | Memo payload. `bytes32(0)` is allowed. |

## Reverts

| Error | Condition |
| - | - |
| `ContractPaused(SEIZE)` | `SEIZE` is paused. Pausing `TRANSFER`, `MINT`, or `BURN` does not block seize. |
| `AccessControlUnauthorizedAccount(caller, SEIZE_ROLE)` | Caller does not hold `SEIZE_ROLE`. |
| `InvalidReceiver(to)` | `to` is `address(0)`, or `from == to`. |
| `InvalidSender(from)` | `from` is `address(0)`. |
| `AccountNotSeizable(from)` | `from` is authorized under `SEIZE_EXEMPT_POLICY` (scope unset, or holder not on the attached blocklist). |
| `PolicyForbids(SEIZE_RECEIVER_POLICY, policyId)` | `to` is not authorized under `SEIZE_RECEIVER_POLICY`. |
| `InsufficientBalance(from, balance, amount)` | `from`'s balance is below `amount`. |

## Events

Emitted on success, in this order:

1. `Transfer(from, to, amount)`
2. `Memo(caller, memo)`
3. `Seized(caller, from, to, amount)`: topic0: `0xa9aec5d8b86e2fa2fd6ac3af62f2622e3dfdab1967d4cbbb56a5df7d74cb887c`

## Access Control

`SEIZE_ROLE` gates this function. The `SEIZE` pausable feature provides a second switch: a caller holding `SEIZE_ROLE` still cannot seize while `SEIZE` is paused.

## Example

```solidity Usage Example lines wrap expandable highlight={9,19} theme={null}
// Grant the seizer role
token.grantRole(token.SEIZE_ROLE(), seizer);

// Create a blocklist, add the holder, attach it to the holder scope
uint64 seizableId = POLICY_REGISTRY.createPolicy(policyAdmin, IPolicyRegistry.PolicyType.BLOCKLIST);
address[] memory holders = new address[](1);
holders[0] = alice;
POLICY_REGISTRY.updateBlocklist(seizableId, true, holders);
token.updatePolicy(token.SEIZE_EXEMPT_POLICY(), seizableId);

// Optionally restrict destinations
uint64 destId = POLICY_REGISTRY.createPolicy(policyAdmin, IPolicyRegistry.PolicyType.ALLOWLIST);
address[] memory dests = new address[](1);
dests[0] = treasury;
POLICY_REGISTRY.updateAllowlist(destId, true, dests);
token.updatePolicy(token.SEIZE_RECEIVER_POLICY(), destId);

// Execute the seize
token.seizeWithMemo(alice, treasury, amount, keccak256("court-order-123"));
```

<Note>
  `AccountNotSeizable` selector: `0x91dbbc8d`. This error fires when the holder scope is unset or the holder is not on the attached blocklist, not when the holder is on a transfer blocklist. Transfer and seize scopes are independent.
</Note>