// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.24;

interface IBurnProxy {
  /**
   * @dev Burns all tokens held by this contract and updates the total burned tokens count.
   *
   *      The function retrieves the balance of token to burn
   *      held by the contract itself. If the balance is non-zero, it proceeds to burn
   *      those tokens however possible. After burning the tokens, it updates
   *      state variable to reflect the new total amount of burned tokens.
   *      Finally, it emits a `Burned` event indicating
   *      the address that initiated the burn and the amount of tokens burned.
   *
   * Emits a `Burned` event with the caller's address and the amount burned.
   */
  function burn() external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.24;

// OpenZeppelin
import '@openzeppelin/contracts/interfaces/IERC20.sol';

// Interfaces
import '../interfaces/IBurnProxy.sol';

interface IVolt is IERC20 {
  function burn(uint256 amount) external;
}

contract VoltBurnProxy is IBurnProxy {
  // -----------------------------------------
  // Type declarations
  // -----------------------------------------

  // -----------------------------------------
  // State variables
  // -----------------------------------------
  /**
   * @notice The total amount of Volt burned through the Volt burn proxy
   */
  uint256 public totalVoltBurned;

  // -----------------------------------------
  // Events
  // -----------------------------------------
  /**
   * Emitted when burning all Volt tokens hold by the Volt burn proxy
   * @param caller the function caller
   * @param amount the amount burned
   */
  event Burned(address indexed caller, uint256 indexed amount);

  // -----------------------------------------
  // Errors
  // -----------------------------------------

  // -----------------------------------------
  // Modifiers
  // -----------------------------------------

  // -----------------------------------------
  // Constructor
  // -----------------------------------------

  // -----------------------------------------
  // Receive function
  // -----------------------------------------
  /**
   * @dev Receive function to handle plain Ether transfers.
   * Always revert.
   */
  receive() external payable {
    revert('noop');
  }

  // -----------------------------------------
  // Fallback function
  // -----------------------------------------
  /**
   * @dev Fallback function to handle non-function calls or Ether transfers if receive() doesn't exist.
   * Always revert.
   */
  fallback() external {
    revert('noop');
  }

  // -----------------------------------------
  // External functions
  // -----------------------------------------
  /**
   * @dev Burns tokens held by this contract and updates the total burned tokens count.
   *
   *      The function retrieves the balance of tokens (Volt tokens)
   *      held by the contract itself. If the balance is non-zero, it proceeds to burn
   *      those tokens by calling the `burn` method on the Volt contract. After burning
   *      the tokens, it updates the `totalVoltBurned` state variable to reflect the new
   *      total amount of burned tokens. Finally, it emits a `Burned` event indicating
   *      the address that initiated the burn and the amount of tokens burned.
   *
   * Emits a `Burned` event with the caller's address and the amount burned.
   */
  function burn() external {
    IVolt volt = IVolt(0x66b5228CfD34d9f4d9f03188d67816286C7c0b74);
    uint256 toBurn = volt.balanceOf(address(this));

    // noop if nothing to burn
    if (toBurn == 0) {
      return;
    }

    // Burn tokens hold by the proxy
    volt.burn(toBurn);

    // Update State
    totalVoltBurned += toBurn;

    // Emit events
    emit Burned(msg.sender, toBurn);
  }

  // -----------------------------------------
  // Public functions
  // -----------------------------------------

  // -----------------------------------------
  // Internal functions
  // -----------------------------------------

  // -----------------------------------------
  // Private functions
  // -----------------------------------------
}

{
  "compilationTarget": {
    "contracts/proxy/VoltBurnProxy.sol": "VoltBurnProxy"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "none"
  },
  "optimizer": {
    "enabled": true,
    "runs": 1888
  },
  "remappings": [],
  "viaIR": true
}