Symbiotic Burners

https://github.com/symbioticfi/burners
Admin
Symbiotic Burners contains the default burner contracts for the Symbiotic Protocol, a flexible and...
Tokens:8,819
Snippets:63
Trust Score:7.1
License:MIT
Update:9 months ago
Show doc for...
Tokens:
Raw
### Deploy wstETH Burner

Source: https://github.com/symbioticfi/burners/blob/main/specs/Burners.md

Deploys the wstETH Burner contract using Forge. This script handles the process of setting up the necessary components for burning wstETH collateral within the Symbiotic protocol.

```shell
forge script script/deploy/genesis/wstETH_Burner.s.sol:wstETH_BurnerScript --broadcast --rpc-url=$ETH_RPC_URL
```

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

### Deploy rETH Burner

Source: https://github.com/symbioticfi/burners/blob/main/specs/Burners.md

Deploys the rETH Burner contract using Forge. This script is responsible for initializing the rETH Burner, enabling the unwrap and burn functionality for rETH collateral.

```shell
forge script script/deploy/genesis/rETH_Burner.s.sol:rETH_BurnerScript --broadcast --rpc-url=$ETH_RPC_URL
```

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

### Deploy Burner Router Entity Contract

Source: https://github.com/symbioticfi/burners/blob/main/specs/BurnerRouter.md

Deploys a specific Burner Router contract instance using a Forge script. This requires specifying collateral and vault addresses, along with other parameters for receiver configurations and delays. The script signature indicates the expected arguments.

```shell
forge script script/deploy/BurnerRouter.s.sol:BurnerRouterScript 0x0000000000000000000000000000000000000000 0x0000000000000000000000000000000000000000 0 0x0000000000000000000000000000000000000000 [(0x0000000000000000000000000000000000000000,0x0000000000000000000000000000000000000000),(0x0000000000000000000000000000000000000000,0x0000000000000000000000000000000000000000)] [(0x0000000000000000000000000000000000000000,0x0000000000000000000000000000000000000000,0x0000000000000000000000000000000000000000),(0x0000000000000000000000000000000000000000,0x0000000000000000000000000000000000000000,0x0000000000000000000000000000000000000000)] --sig "run(address,address,uint48,address,(address,address)[],(address,address,address)[])" --broadcast --rpc-url=$ETH_RPC_URL
```

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

### Deploy Burner Router Factory Contract

Source: https://github.com/symbioticfi/burners/blob/main/specs/BurnerRouter.md

Deploys the BurnerRouterFactory contract using a Forge script. This factory is responsible for creating new Burner Router instances. Ensure the .env file is sourced for environment variables like RPC URLs.

```shell
source .env
forge script script/deploy/genesis/BurnerRouterFactory.s.sol:BurnerRouterFactoryScript --broadcast --rpc-url=$ETH_RPC_URL
```

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

### Create BurnerRouter Instance with Factory (Solidity)

Source: https://context7.com/symbioticfi/burners/llms.txt

Deploys a new BurnerRouter contract instance using a deterministic address provided by the BurnerRouterFactory. This function requires initialization parameters such as the owner, collateral type, delay periods, and receiver configurations.

```solidity
// Deploy factory with implementation address
BurnerRouterFactory factory = new BurnerRouterFactory(burnerRouterImplementation);

// Setup initialization parameters
IBurnerRouter.InitParams memory params = IBurnerRouter.InitParams({
    owner: 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb,
    collateral: 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0, // wstETH
    delay: 86400, // 1 day delay for receiver changes
    globalReceiver: 0x0000000000000000000000000000000000000001,
    networkReceivers: new IBurnerRouter.NetworkReceiver[](0),
    operatorNetworkReceivers: new IBurnerRouter.OperatorNetworkReceiver[](0)
});

// Create burner router
address burnerRouter = factory.create(params);
// Returns: address of deployed BurnerRouter contract
```

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

### Deploy swETH Burner

Source: https://github.com/symbioticfi/burners/blob/main/specs/Burners.md

Deploys the swETH Burner contract using Forge. This script ensures the swETH Burner is correctly deployed, enabling the process of withdrawing and burning swETH collateral.

```shell
forge script script/deploy/genesis/swETH_Burner.s.sol:swETH_BurnerScript --broadcast --rpc-url=$ETH_RPC_URL
```

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

### Deploy ETHx Burner

Source: https://github.com/symbioticfi/burners/blob/main/specs/Burners.md

Deploys the ETHx Burner contract using Forge. This script is used to deploy the ETHx Burner, enabling the withdrawal and burning mechanisms for ETHx collateral.

```shell
forge script script/deploy/genesis/ETHx_Burner.s.sol:ETHx_BurnerScript --broadcast --rpc-url=$ETH_RPC_URL
```

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

### BurnerRouterFactory.create

Source: https://context7.com/symbioticfi/burners/llms.txt

Deploys a new BurnerRouter contract instance using a deterministic address derived from initialization parameters.

```APIDOC
## BurnerRouterFactory.create

### Description
Creates a new BurnerRouter contract instance using a deterministic address based on initialization parameters.

### Method
`CREATE` (Contract Deployment)

### Endpoint
N/A (Smart Contract Function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **params** (IBurnerRouter.InitParams) - Required - Initialization parameters for the BurnerRouter.
  - **owner** (address) - Required - The owner of the BurnerRouter.
  - **collateral** (address) - Required - The address of the collateral token (e.g., wstETH).
  - **delay** (uint256) - Required - The delay in seconds for receiver changes.
  - **globalReceiver** (address) - Required - The initial global receiver address.
  - **networkReceivers** (IBurnerRouter.NetworkReceiver[]) - Optional - An array of network-specific receivers.
  - **operatorNetworkReceivers** (IBurnerRouter.OperatorNetworkReceiver[]) - Optional - An array of operator-specific network receivers.

### Request Example
```solidity
// Deploy factory with implementation address
BurnerRouterFactory factory = new BurnerRouterFactory(burnerRouterImplementation);

// Setup initialization parameters
IBurnerRouter.InitParams memory params = IBurnerRouter.InitParams({
    owner: 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb,
    collateral: 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0, // wstETH
    delay: 86400, // 1 day delay for receiver changes
    globalReceiver: 0x0000000000000000000000000000000000000001,
    networkReceivers: new IBurnerRouter.NetworkReceiver[](0),
    operatorNetworkReceivers: new IBurnerRouter.OperatorNetworkReceiver[](0)
});

// Create burner router
address burnerRouter = factory.create(params);
```

### Response
#### Success Response (200)
- **burnerRouter** (address) - The address of the deployed BurnerRouter contract.

#### Response Example
```
0xDeployedBurnerRouterAddress
```
```

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

### Deploy sfrxETH Burner

Source: https://github.com/symbioticfi/burners/blob/main/specs/Burners.md

Deploys the sfrxETH Burner contract using Forge. This script handles the deployment of the sfrxETH Burner, which is essential for managing sfrxETH collateral withdrawals and burns.

```shell
forge script script/deploy/genesis/sfrxETH_Burner.s.sol:sfrxETH_BurnerScript --broadcast --rpc-url=$ETH_RPC_URL
```

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

### Deploy mETH Burner

Source: https://github.com/symbioticfi/burners/blob/main/specs/Burners.md

Deploys the mETH Burner contract using Forge. This script facilitates the deployment of the mETH Burner, allowing for the withdrawal and burning of mETH collateral.

```shell
forge script script/deploy/genesis/mETH_Burner.s.sol:mETH_BurnerScript --broadcast --rpc-url=$ETH_RPC_URL
```

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

### Initiate wstETH Withdrawal with wstETH_Burner

Source: https://context7.com/symbioticfi/burners/llms.txt

Initiates the withdrawal process for wstETH by unwrapping it to stETH and subsequently creating withdrawal requests with the Lido protocol. This involves transferring wstETH to the burner contract and then calling `triggerWithdrawal` with a maximum number of requests to process.

```solidity
// Deploy wstETH burner
address wstETH = 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0;
address lidoWithdrawalQueue = 0x889edC2eDab5f40e902b864aD4d7AdE8E412F9B1;
wstETH_Burner burner = new wstETH_Burner(wstETH, lidoWithdrawalQueue);

// Transfer slashed wstETH to burner
IERC20(wstETH).transfer(address(burner), 50 ether);

// Trigger withdrawal (creates Lido withdrawal requests)
uint256 maxRequests = 10;
uint256[] memory requestIds = burner.triggerWithdrawal(maxRequests);

// Returns array of Lido withdrawal request IDs
// Each ID can be used later to claim and burn ETH
```

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

### Batch Claim and Burn Lido Withdrawals with wstETH_Burner

Source: https://context7.com/symbioticfi/burners/llms.txt

Efficiently claims multiple finalized Lido withdrawal requests and burns all received ETH in a single transaction. This function requires calculating checkpoint hints for efficient processing and then calls `triggerBurnBatch` with the request IDs and hints.

```solidity
// Multiple finalized requests
uint256[] memory requestIds = new uint256[](3);
requestIds[0] = 100;
requestIds[1] = 101;
requestIds[2] = 102;

// Calculate hints for efficient claiming
uint256[] memory hints = IWithdrawalQueue(lidoWithdrawalQueue).findCheckpointHints(
    requestIds,
    1,
    IWithdrawalQueue(lidoWithdrawalQueue).getLastCheckpointIndex()
);

// Batch burn - claims all requests and burns ETH
burner.triggerBurnBatch(requestIds, hints);

// All ETH from all requests is claimed and burned atomically
```

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

### Initiate mETH Withdrawal with mETH_Burner

Source: https://context7.com/symbioticfi/burners/llms.txt

Creates a withdrawal request with the Mantle Staking contract for mETH collateral. After transferring mETH to the burner, `triggerWithdrawal` is called to initiate the process. A withdrawal request ID is returned, which is required for the subsequent `triggerBurn` function after the withdrawal finalizes.

```solidity
// Deploy mETH burner
address mETH = 0xd5F7838F5C461fefF7FE49ea5ebaF7728bB0ADfa;
mETH_Burner burner = new mETH_Burner(mETH);

// Transfer slashed mETH to burner
IERC20(mETH).transfer(address(burner), 25 ether);

// Trigger withdrawal request
uint256 requestId = burner.triggerWithdrawal();

// Returns Mantle Staking withdrawal request ID
// Must wait for finalization before calling triggerBurn
```

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

### swETH_Burner: Initiate Withdrawal

Source: https://context7.com/symbioticfi/burners/llms.txt

Initiates swETH withdrawal from the Swell Exit contract. It can create multiple withdrawal requests based on the provided limit. Returns the range of NFT token IDs representing the created withdrawal requests.

```Solidity
// Deploy swETH burner
address swETH = 0xf951E335afb289353dc249e82926178EaC7DEd78;
address swEXIT = 0x48C11b86807627AF70a34662D4865cF854251663;
swETH_Burner burner = new swETH_Burner(swETH, swEXIT);

// Transfer slashed swETH
IERC20(swETH).transfer(address(burner), 100 ether);

// Trigger withdrawal with max requests limit
uint256 maxRequests = 5;
(uint256 firstRequestId, uint256 lastRequestId) = burner.triggerWithdrawal(maxRequests);

// Returns range of NFT token IDs representing withdrawal requests
// firstRequestId = 500, lastRequestId = 504 means 5 requests created
```

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

### BurnerRouter.onSlash

Source: https://context7.com/symbioticfi/burners/llms.txt

Handles the routing of slashed collateral by the vault during slashing events.

```APIDOC
## BurnerRouter.onSlash

### Description
Called by the vault during slashing events to route slashed collateral to appropriate receivers based on network and operator configuration.

### Method
`EXTERNAL` (Smart Contract Function)

### Endpoint
N/A (Smart Contract Function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **subnetwork** (bytes32) - Required - Identifier for the subnetwork where slashing occurred.
- **operator** (address) - Required - The address of the operator responsible for the slashed collateral.
- **slashedAmount** (uint256) - Required - The amount of collateral that was slashed.
- **captureTimestamp** (uint48) - Required - The timestamp when the slashing event was captured.

### Request Example
```solidity
// Vault calls onSlash when slashing occurs
bytes32 subnetwork = 0x0000000000000000000000001234567890123456789012345678901234567890;
address operator = 0x123;
uint256 slashedAmount = 100 ether;
uint48 captureTimestamp = uint48(block.timestamp);

// BurnerRouter automatically routes funds
burnerRouter.onSlash(subnetwork, operator, slashedAmount, captureTimestamp);
```

### Response
#### Success Response (200)
None (This is an internal contract function that updates state).

#### Response Example
None
```

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

### Claim and Burn Finalized Lido Withdrawal with wstETH_Burner

Source: https://context7.com/symbioticfi/burners/llms.txt

Claims a finalized Lido withdrawal request and permanently burns the received ETH. It first checks if the withdrawal request is finalized using Lido's withdrawal queue and then calls `triggerBurn` to execute the claim and burn operation. The ETH is destroyed via `SelfDestruct`.

```solidity
// Wait for Lido withdrawal to be finalized
uint256 requestId = requestIds[0];

// Check if request is finalized using Lido's withdrawal queue
bool isFinalized = IWithdrawalQueue(lidoWithdrawalQueue).getWithdrawalStatus(requestId).isFinalized;
require(isFinalized, "Withdrawal not ready");

// Claim withdrawal and burn ETH
burner.triggerBurn(requestId);

// ETH is claimed from Lido and permanently destroyed via SelfDestruct
// Request ID is removed from burner's tracking
```

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

### sfrxETH_Burner: Initiate Withdrawal

Source: https://context7.com/symbioticfi/burners/llms.txt

Creates a withdrawal request with the Frax Ether Redemption Queue for sfrxETH. After transferring slashed sfrxETH to the burner, it calls `triggerWithdrawal` which returns a Frax redemption NFT ID.

```Solidity
// Deploy sfrxETH burner
address sfrxETH = 0xac3E018457B222d93114458476f3E3416Abbe38F;
address fraxRedemptionQueue = 0x82bA8da44Cd5261762e629dd5c605b17715727bd;
sfrxETH_Burner burner = new sfrxETH_Burner(sfrxETH, fraxRedemptionQueue);

// Transfer slashed sfrxETH
IERC20(sfrxETH).transfer(address(burner), 15 ether);

// Trigger withdrawal
uint256 requestId = burner.triggerWithdrawal();

// Returns Frax redemption NFT ID
// Wait for redemption maturity before burning
```

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

### swETH_Burner: Finalize Withdrawal and Burn ETH

Source: https://context7.com/symbioticfi/burners/llms.txt

Finalizes a specific swETH withdrawal request and burns the received ETH. It first checks if the request is ready for finalization using the Swell Exit contract's `canFinalize` function.

```Solidity
uint256 requestId = 500;

// Check if request is finalizable
bool canFinalize = ISwEXIT(swEXIT).canFinalize(requestId);
require(canFinalize, "Withdrawal not ready");

// Finalize and burn
burner.triggerBurn(requestId);

// Request NFT is burned, ETH is claimed and destroyed
```

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

### ETHx_Burner: Initiate Withdrawal

Source: https://context7.com/symbioticfi/burners/llms.txt

Initiates ETHx withdrawal through the Stader User Withdraw Manager contract. It transfers slashed ETHx to the burner and then calls `triggerWithdrawal` with a maximum number of requests, returning an array of Stader withdrawal request IDs.

```Solidity
// Deploy ETHx burner
address ethx = 0xA35b1B31Ce002FBF2058D22F30f95D405200A15b;
address userWithdrawManager = 0x9F0491B32DBce587c50c4C43AB303b06478193A7;
ETHx_Burner burner = new ETHx_Burner(ethx, userWithdrawManager);

// Transfer slashed ETHx
IERC20(ethx).transfer(address(burner), 30 ether);

// Trigger withdrawal
uint256 maxRequests = 8;
uint256[] memory requestIds = burner.triggerWithdrawal(maxRequests);

// Returns array of Stader withdrawal request IDs
```

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

### Handle Slashing Events with BurnerRouter.onSlash (Solidity)

Source: https://context7.com/symbioticfi/burners/llms.txt

This function is invoked by a vault during slashing events to route the collateral to the appropriate receivers. It utilizes network and operator configurations stored within the BurnerRouter to determine the destination for the slashed funds.

```solidity
// Vault calls onSlash when slashing occurs
bytes32 subnetwork = 0x0000000000000000000000001234567890123456789012345678901234567890;
address operator = 0x123;
uint256 slashedAmount = 100 ether;
uint48 captureTimestamp = uint48(block.timestamp);

// BurnerRouter automatically routes funds
burnerRouter.onSlash(subnetwork, operator, slashedAmount, captureTimestamp);

// Check receiver balance
address receiver = burnerRouter.operatorNetworkReceiver(network, operator);
uint256 receiverBalance = burnerRouter.balanceOf(receiver);
// receiverBalance will include accumulated slashed amounts
```

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

### ETHx_Burner: Claim Finalized Withdrawal and Burn ETH

Source: https://context7.com/symbioticfi/burners/llms.txt

Claims a finalized Stader withdrawal and burns the received ETH. It verifies the finalization status of the withdrawal request using `withdrawRequests` and a predefined `finalizeDelay` before proceeding with the burn.

```Solidity
uint256 requestId = requestIds[0];

// Verify finalization
IUserWithdrawalManager.WithdrawRequest memory request = 
    IUserWithdrawalManager(userWithdrawManager).withdrawRequests(requestId);
require(request.requestBlock + finalizeDelay <= block.number, "Not finalized");

// Claim and burn
burner.triggerBurn(requestId);

// ETH received from Stader is permanently destroyed
```

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

### Unwrap and Burn rETH with rETH_Burner

Source: https://context7.com/symbioticfi/burners/llms.txt

Directly unwraps rETH to ETH via RocketPool and burns the resulting ETH in a single step. This bypasses any withdrawal waiting periods, offering a faster burning mechanism. The ETH is destroyed immediately upon receipt.

```solidity
// Deploy rETH burner
address rETH = 0xae78736Cd615f374D3085123A210448E74Fc6393;
rETH_Burner burner = new rETH_Burner(rETH);

// Transfer slashed rETH to burner
IERC20(rETH).transfer(address(burner), 10 ether);

// Get burner balance
uint256 burnAmount = IERC20(rETH).balanceOf(address(burner));

// Trigger burn (unwraps rETH -> ETH and burns in one call)
burner.triggerBurn(burnAmount);

// rETH is converted to ETH via RocketPool's burn function
// ETH is immediately destroyed via SelfDestruct
// No withdrawal waiting period required
```

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

### Configure Network-Specific Receivers with BurnerRouter.setNetworkReceiver (Solidity)

Source: https://context7.com/symbioticfi/burners/llms.txt

Enables the configuration of specific receiver addresses for particular slashing networks, overriding the general global receiver. Similar to setting the global receiver, this function employs a delay and confirmation process.

```solidity
address network = 0xNetworkContractAddress;
address networkSpecificReceiver = 0xNetworkReceiverAddress;

// Set network-specific receiver (becomes pending)
burnerRouter.setNetworkReceiver(network, networkSpecificReceiver);

// After delay, accept the receiver
burnerRouter.acceptNetworkReceiver(network);

// When slashing occurs on this network, funds route to networkSpecificReceiver
// instead of globalReceiver
```

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

### sfrxETH_Burner: Redeem Mature Withdrawal and Burn ETH

Source: https://context7.com/symbioticfi/burners/llms.txt

Redeems a mature Frax withdrawal request and burns the received ETH. It first checks the maturity of the request against the current block timestamp before proceeding with the burn.

```Solidity
uint256 requestId = 789;

// Check maturity
IFraxEtherRedemptionQueue.RedemptionQueueItem memory item = 
    IFraxEtherRedemptionQueue(fraxRedemptionQueue).redemptionQueueItem(requestId);
require(item.maturity <= block.timestamp, "Not matured");

// Burn redemption NFT and destroy ETH
burner.triggerBurn(requestId);

// ETH is claimed from Frax and permanently burned
```

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

### Set Global Receiver with Delay using BurnerRouter.setGlobalReceiver (Solidity)

Source: https://context7.com/symbioticfi/burners/llms.txt

Allows the owner to set a new global receiver address for slashed funds. This operation includes a security delay mechanism, requiring a subsequent confirmation step to activate the new receiver.

```solidity
// Only owner can set receivers
address newGlobalReceiver = 0xNewReceiverAddress;

// Set new global receiver (becomes pending for delay period)
burnerRouter.setGlobalReceiver(newGlobalReceiver);

// Query pending receiver
(address pendingReceiver, uint48 timestamp) = burnerRouter.pendingGlobalReceiver();

// Wait for delay period to pass
vm.warp(timestamp);

// Accept the pending receiver
burnerRouter.acceptGlobalReceiver();

// Verify receiver is now active
address activeReceiver = burnerRouter.globalReceiver();
assert(activeReceiver == newGlobalReceiver);
```

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

### BurnerRouter.setGlobalReceiver

Source: https://context7.com/symbioticfi/burners/llms.txt

Sets a new global receiver for slashed funds, incorporating a time delay for enhanced security.

```APIDOC
## BurnerRouter.setGlobalReceiver

### Description
Sets a new global receiver for slashed funds with a time delay for security. The new receiver becomes pending until accepted.

### Method
`EXTERNAL` (Smart Contract Function)

### Endpoint
N/A (Smart Contract Function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **newGlobalReceiver** (address) - Required - The address of the new global receiver.

### Request Example
```solidity
// Only owner can set receivers
address newGlobalReceiver = 0xNewReceiverAddress;

// Set new global receiver (becomes pending for delay period)
burnerRouter.setGlobalReceiver(newGlobalReceiver);

// Query pending receiver
(address pendingReceiver, uint48 timestamp) = burnerRouter.pendingGlobalReceiver();

// Wait for delay period to pass
// vm.warp(timestamp); // Example using a testing utility

// Accept the pending receiver
burnerRouter.acceptGlobalReceiver();

// Verify receiver is now active
address activeReceiver = burnerRouter.globalReceiver();
// assert(activeReceiver == newGlobalReceiver);
```

### Response
#### Success Response (200)
None (This function updates the pending global receiver state).

#### Response Example
None
```

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

### BurnerRouter.triggerTransfer

Source: https://context7.com/symbioticfi/burners/llms.txt

Initiates the transfer of accumulated slashed collateral from the router to a designated receiver.

```APIDOC
## BurnerRouter.triggerTransfer

### Description
Transfers accumulated slashed collateral from the router to the designated receiver address.

### Method
`EXTERNAL` (Smart Contract Function)

### Endpoint
N/A (Smart Contract Function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **receiver** (address) - Required - The address to which the collateral should be transferred.

### Request Example
```solidity
address receiver = 0x0000000000000000000000000000000000000001;

// Check available balance before transfer
uint256 availableBalance = burnerRouter.balanceOf(receiver);
require(availableBalance > 0, "No balance to claim");

// Trigger transfer to receiver
uint256 transferredAmount = burnerRouter.triggerTransfer(receiver);
```

### Response
#### Success Response (200)
- **transferredAmount** (uint256) - The amount of collateral tokens successfully transferred to the receiver.

#### Response Example
```
100000000000000000000 // Example amount in wei
```

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

### Claim and Burn mETH Withdrawal with mETH_Burner

Source: https://context7.com/symbioticfi/burners/llms.txt

Claims a finalized mETH withdrawal request from the Mantle Staking contract and burns the received ETH. Before calling `triggerBurn`, it verifies that the withdrawal request is finalized by checking its status and ensuring the current block number is past the request's block number. The claimed ETH is then permanently destroyed.

```solidity
uint256 requestId = 12345;

// Verify request is finalized
IStaking.WithdrawalRequest memory request = IStaking(staking).withdrawalRequests(requestId); // Assuming 'staking' is the address of the Mantle Staking contract
require(request.claimed == false && block.number >= request.blockNumber, "Not ready");

// Claim and burn
burner.triggerBurn(requestId);

// ETH received from Mantle is permanently destroyed
```

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

### BurnerRouter.setNetworkReceiver

Source: https://context7.com/symbioticfi/burners/llms.txt

Configures network-specific receivers that take precedence over the global receiver for designated networks.

```APIDOC
## BurnerRouter.setNetworkReceiver

### Description
Configures network-specific receivers that override the global receiver for specific slashing networks. These settings also involve a delay and acceptance mechanism.

### Method
`EXTERNAL` (Smart Contract Function)

### Endpoint
N/A (Smart Contract Function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **network** (address) - Required - The address representing the network for which the receiver is being set.
- **networkSpecificReceiver** (address) - Required - The address of the network-specific receiver.

### Request Example
```solidity
address network = 0xNetworkContractAddress;
address networkSpecificReceiver = 0xNetworkReceiverAddress;

// Set network-specific receiver (becomes pending)
burnerRouter.setNetworkReceiver(network, networkSpecificReceiver);

// After delay, accept the receiver
// burnerRouter.acceptNetworkReceiver(network);

// When slashing occurs on this network, funds route to networkSpecificReceiver
// instead of globalReceiver
```

### Response
#### Success Response (200)
None (This function updates the pending network receiver state).

#### Response Example
None
```

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

### Set Operator-Network Receiver in BurnerRouter

Source: https://context7.com/symbioticfi/burners/llms.txt

Sets an operator-and-network-specific receiver address for fund routing with the highest priority. After a delay, the receiver must be accepted using `acceptOperatorNetworkReceiver`. This function is crucial for establishing a prioritized fund routing hierarchy.

```solidity
address network = 0xNetworkContractAddress;
address operator = 0xOperatorAddress;
address operatorReceiver = 0xOperatorSpecificReceiver;

// Set operator-network receiver (highest priority)
burnerRouter.setOperatorNetworkReceiver(network, operator, operatorReceiver);

// After delay period
burnerRouter.acceptOperatorNetworkReceiver(network, operator);

// Priority order for fund routing:
// 1. operatorNetworkReceiver (if set)
// 2. networkReceiver (if set)
// 3. globalReceiver (fallback)
```

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

### Transfer Accumulated Collateral with BurnerRouter.triggerTransfer (Solidity)

Source: https://context7.com/symbioticfi/burners/llms.txt

Initiates the transfer of accumulated slashed collateral from the BurnerRouter to a specified receiver address. This function requires a non-zero available balance for the receiver and resets the router's balance for that receiver upon successful transfer.

```solidity
address receiver = 0x0000000000000000000000000000000000000001;

// Check available balance before transfer
uint256 availableBalance = burnerRouter.balanceOf(receiver);
require(availableBalance > 0, "No balance to claim");

// Trigger transfer to receiver
uint256 transferredAmount = burnerRouter.triggerTransfer(receiver);

// After transfer:
// - receiver has collateral tokens
// - router balance for receiver is reset to 0
// - router lastBalance is decremented by transferredAmount
```
Tokens:
Raw