@keep-network/tbtc-v2 0.1.1-dev.80 → 0.1.1-dev.83

package/artifacts/solcInputs/{4f6d4f5cd1e3d835e20ed55926a445cd.json → 21fcfd91cc383ddf1b3799814408151d.json}

@@ -2,7 +2,7 @@
   "language": "Solidity",
   "sources": {
     "contracts/bank/Bank.sol": {
-      "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\n\nimport \"./IReceiveBalanceApproval.sol\";\nimport \"../vault/IVault.sol\";\n\n/// @title Bitcoin Bank\n/// @notice Bank is a central component tracking Bitcoin balances. Balances can\n///         be transferred between holders and holders can approve their\n///         balances to be spent by others. Balances in the Bank are updated for\n///         depositors who deposit their Bitcoin into the Bridge and only the\n///         Bridge can increase balances.\n/// @dev Bank is a governable contract and the Governance can upgrade the Bridge\n///      address.\ncontract Bank is Ownable {\n    address public bridge;\n\n    /// @notice The balance of a given account in the Bank. Zero by default.\n    mapping(address => uint256) public balanceOf;\n\n    /// @notice The remaining amount of balance a spender will be\n    ///         allowed to transfer on behalf of an owner using\n    ///         `transferBalanceFrom`. Zero by default.\n    mapping(address => mapping(address => uint256)) public allowance;\n\n    /// @notice Returns the current nonce for EIP2612 permission for the\n    ///         provided balance owner for a replay protection. Used to\n    ///         construct EIP2612 signature provided to `permit` function.\n    mapping(address => uint256) public nonce;\n\n    uint256 public immutable cachedChainId;\n    bytes32 public immutable cachedDomainSeparator;\n\n    /// @notice Returns EIP2612 Permit message hash. Used to construct EIP2612\n    ///         signature provided to `permit` function.\n    bytes32 public constant PERMIT_TYPEHASH =\n        keccak256(\n            \"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\"\n        );\n\n    event BalanceTransferred(\n        address indexed from,\n        address indexed to,\n        uint256 amount\n    );\n\n    event BalanceApproved(\n        address indexed owner,\n        address indexed spender,\n        uint256 amount\n    );\n\n    event BalanceIncreased(address indexed owner, uint256 amount);\n\n    event BalanceDecreased(address indexed owner, uint256 amount);\n\n    event BridgeUpdated(address newBridge);\n\n    modifier onlyBridge() {\n        require(msg.sender == address(bridge), \"Caller is not the bridge\");\n        _;\n    }\n\n    constructor() {\n        cachedChainId = block.chainid;\n        cachedDomainSeparator = buildDomainSeparator();\n    }\n\n    /// @notice Allows the Governance to upgrade the Bridge address.\n    /// @dev The function does not implement any governance delay and does not\n    ///      check the status of the Bridge. The Governance implementation needs\n    ///      to ensure all requirements for the upgrade are satisfied before\n    ///      executing this function.\n    function updateBridge(address _bridge) external onlyOwner {\n        require(_bridge != address(0), \"Bridge address must not be 0x0\");\n        bridge = _bridge;\n        emit BridgeUpdated(_bridge);\n    }\n\n    /// @notice Moves the given `amount` of balance from the caller to\n    ///         `recipient`.\n    /// @dev Requirements:\n    ///       - `recipient` cannot be the zero address,\n    ///       - the caller must have a balance of at least `amount`.\n    function transferBalance(address recipient, uint256 amount) external {\n        _transferBalance(msg.sender, recipient, amount);\n    }\n\n    /// @notice Sets `amount` as the allowance of `spender` over the caller's\n    ///         balance.\n    /// @dev If the `amount` is set to `type(uint256).max` then\n    ///      `transferBalanceFrom` will not reduce an allowance.\n    ///      Beware that changing an allowance with this function brings the\n    ///      risk that someone may use both the old and the new allowance by\n    ///      unfortunate transaction ordering. Please use\n    ///      `increaseBalanceAllowance` and `decreaseBalanceAllowance` to\n    ///      eliminate the risk.\n    function approveBalance(address spender, uint256 amount) external {\n        _approveBalance(msg.sender, spender, amount);\n    }\n\n    /// @notice Sets the `amount` as an allowance of a smart contract `spender`\n    ///         over the caller's balance and calls the `spender` via\n    ///         `receiveBalanceApproval`.\n    /// @dev If the `amount` is set to `type(uint256).max`, the potential\n    ///     `transferBalanceFrom` executed in `receiveBalanceApproval` of\n    ///      `spender` will not reduce an allowance. Beware that changing an\n    ///      allowance with this function brings the risk that `spender` may use\n    ///      both the old and the new allowance by unfortunate transaction\n    ///      ordering. Please use `increaseBalanceAllowance` and\n    ///      `decreaseBalanceAllowance` to eliminate the risk.\n    function approveBalanceAndCall(\n        address spender,\n        uint256 amount,\n        bytes memory extraData\n    ) external {\n        _approveBalance(msg.sender, spender, amount);\n        IReceiveBalanceApproval(spender).receiveBalanceApproval(\n            msg.sender,\n            amount,\n            extraData\n        );\n    }\n\n    /// @notice Atomically increases the balance allowance granted to `spender`\n    ///         by the caller by the given `addedValue`.\n    function increaseBalanceAllowance(address spender, uint256 addedValue)\n        external\n    {\n        _approveBalance(\n            msg.sender,\n            spender,\n            allowance[msg.sender][spender] + addedValue\n        );\n    }\n\n    /// @notice Atomically decreases the balance allowance granted to `spender`\n    ///         by the caller by the given `subtractedValue`.\n    function decreaseBalanceAllowance(address spender, uint256 subtractedValue)\n        external\n    {\n        uint256 currentAllowance = allowance[msg.sender][spender];\n        require(\n            currentAllowance >= subtractedValue,\n            \"Can not decrease balance allowance below zero\"\n        );\n        unchecked {\n            _approveBalance(\n                msg.sender,\n                spender,\n                currentAllowance - subtractedValue\n            );\n        }\n    }\n\n    /// @notice Moves `amount` of balance from `spender` to `recipient` using the\n    ///         allowance mechanism. `amount` is then deducted from the caller's\n    ///         allowance unless the allowance was made for `type(uint256).max`.\n    /// @dev Requirements:\n    ///      - `recipient` cannot be the zero address,\n    ///      - `spender` must have a balance of at least `amount`,\n    ///      - the caller must have allowance for `spender`'s balance of at\n    ///        least `amount`.\n    function transferBalanceFrom(\n        address spender,\n        address recipient,\n        uint256 amount\n    ) external {\n        uint256 currentAllowance = allowance[spender][msg.sender];\n        if (currentAllowance != type(uint256).max) {\n            require(\n                currentAllowance >= amount,\n                \"Transfer amount exceeds allowance\"\n            );\n            unchecked {\n                _approveBalance(spender, msg.sender, currentAllowance - amount);\n            }\n        }\n        _transferBalance(spender, recipient, amount);\n    }\n\n    /// @notice EIP2612 approval made with secp256k1 signature.\n    ///         Users can authorize a transfer of their balance with a signature\n    ///         conforming EIP712 standard, rather than an on-chain transaction\n    ///         from their address. Anyone can submit this signature on the\n    ///         user's behalf by calling the permit function, paying gas fees,\n    ///         and possibly performing other actions in the same transaction.\n    /// @dev The deadline argument can be set to `type(uint256).max to create\n    ///      permits that effectively never expire.  If the `amount` is set\n    ///      to `type(uint256).max` then `transferBalanceFrom` will not\n    ///      reduce an allowance. Beware that changing an allowance with this\n    ///      function brings the risk that someone may use both the old and the\n    ///      new allowance by unfortunate transaction ordering. Please use\n    ///      `increaseBalanceAllowance` and `decreaseBalanceAllowance` to\n    ///      eliminate the risk.\n    function permit(\n        address owner,\n        address spender,\n        uint256 amount,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external {\n        /* solhint-disable-next-line not-rely-on-time */\n        require(deadline >= block.timestamp, \"Permission expired\");\n\n        // Validate `s` and `v` values for a malleability concern described in EIP2.\n        // Only signatures with `s` value in the lower half of the secp256k1\n        // curve's order and `v` value of 27 or 28 are considered valid.\n        require(\n            uint256(s) <=\n                0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,\n            \"Invalid signature 's' value\"\n        );\n        require(v == 27 || v == 28, \"Invalid signature 'v' value\");\n\n        bytes32 digest = keccak256(\n            abi.encodePacked(\n                \"\\x19\\x01\",\n                DOMAIN_SEPARATOR(),\n                keccak256(\n                    abi.encode(\n                        PERMIT_TYPEHASH,\n                        owner,\n                        spender,\n                        amount,\n                        nonce[owner]++,\n                        deadline\n                    )\n                )\n            )\n        );\n        address recoveredAddress = ecrecover(digest, v, r, s);\n        require(\n            recoveredAddress != address(0) && recoveredAddress == owner,\n            \"Invalid signature\"\n        );\n        _approveBalance(owner, spender, amount);\n    }\n\n    /// @notice Increases balances of the provided `recipients` by the provided\n    ///         `amounts`. Can only be called by the Bridge.\n    /// @dev Requirements:\n    ///       - length of `recipients` and `amounts` must be the same.\n    function increaseBalances(\n        address[] calldata recipients,\n        uint256[] calldata amounts\n    ) external onlyBridge {\n        require(\n            recipients.length == amounts.length,\n            \"Arrays must have the same length\"\n        );\n        for (uint256 i = 0; i < recipients.length; i++) {\n            _increaseBalance(recipients[i], amounts[i]);\n        }\n    }\n\n    /// @notice Increases balance of the provided `recipient` by the provided\n    ///         `amount`. Can only be called by the Bridge.\n    function increaseBalance(address recipient, uint256 amount)\n        external\n        onlyBridge\n    {\n        _increaseBalance(recipient, amount);\n    }\n\n    /// @notice Increases the given smart contract `vault`'s balance and\n    ///         notifies the `vault` contract. Called by the Bridge after\n    ///         the deposits routed by depositors to that `vault` have been\n    ///         swept by the Bridge. This way, the depositor does not have to\n    ///         issue a separate  transaction to the `vault` contract.\n    ///         Can be called only by the Bridge.\n    /// @dev Requirements:\n    ///       - `vault` must implement `IVault` interface,\n    ///       - length of `depositors` and `depositedAmounts` must be the same.\n    /// @param vault Address of `IVault` recipient contract.\n    /// @param depositors Addresses of depositors whose deposits have been swept.\n    /// @param depositedAmounts Amounts deposited by individual depositors and\n    ///        swept. The `vault`'s balance in the Bank will be increased by the\n    ///        sum of all elements in this array.\n    function increaseBalanceAndCall(\n        address vault,\n        address[] calldata depositors,\n        uint256[] calldata depositedAmounts\n    ) external onlyBridge {\n        require(\n            depositors.length == depositedAmounts.length,\n            \"Arrays must have the same length\"\n        );\n        uint256 totalAmount = 0;\n        for (uint256 i = 0; i < depositedAmounts.length; i++) {\n            totalAmount += depositedAmounts[i];\n        }\n        _increaseBalance(vault, totalAmount);\n        IVault(vault).receiveBalanceIncrease(depositors, depositedAmounts);\n    }\n\n    /// @notice Decreases caller's balance by the provided `amount`. There is no\n    ///         way to restore the balance so do not call this function unless\n    ///         you really know what you are doing!\n    function decreaseBalance(uint256 amount) external {\n        balanceOf[msg.sender] -= amount;\n        emit BalanceDecreased(msg.sender, amount);\n    }\n\n    /// @notice Returns hash of EIP712 Domain struct with `TBTC Bank` as\n    ///         a signing domain and Bank contract as a verifying contract.\n    ///         Used to construct EIP2612 signature provided to `permit`\n    ///         function.\n    /* solhint-disable-next-line func-name-mixedcase */\n    function DOMAIN_SEPARATOR() public view returns (bytes32) {\n        // As explained in EIP-2612, if the DOMAIN_SEPARATOR contains the\n        // chainId and is defined at contract deployment instead of\n        // reconstructed for every signature, there is a risk of possible replay\n        // attacks between chains in the event of a future chain split.\n        // To address this issue, we check the cached chain ID against the\n        // current one and in case they are different, we build domain separator\n        // from scratch.\n        if (block.chainid == cachedChainId) {\n            return cachedDomainSeparator;\n        } else {\n            return buildDomainSeparator();\n        }\n    }\n\n    function _increaseBalance(address recipient, uint256 amount) internal {\n        require(\n            recipient != address(this),\n            \"Can not increase balance for Bank\"\n        );\n        balanceOf[recipient] += amount;\n        emit BalanceIncreased(recipient, amount);\n    }\n\n    function _transferBalance(\n        address spender,\n        address recipient,\n        uint256 amount\n    ) private {\n        require(\n            recipient != address(0),\n            \"Can not transfer to the zero address\"\n        );\n        require(\n            recipient != address(this),\n            \"Can not transfer to the Bank address\"\n        );\n\n        uint256 spenderBalance = balanceOf[spender];\n        require(spenderBalance >= amount, \"Transfer amount exceeds balance\");\n        unchecked {\n            balanceOf[spender] = spenderBalance - amount;\n        }\n        balanceOf[recipient] += amount;\n        emit BalanceTransferred(spender, recipient, amount);\n    }\n\n    function _approveBalance(\n        address owner,\n        address spender,\n        uint256 amount\n    ) private {\n        require(spender != address(0), \"Can not approve to the zero address\");\n        allowance[owner][spender] = amount;\n        emit BalanceApproved(owner, spender, amount);\n    }\n\n    function buildDomainSeparator() private view returns (bytes32) {\n        return\n            keccak256(\n                abi.encode(\n                    keccak256(\n                        \"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"\n                    ),\n                    keccak256(bytes(\"TBTC Bank\")),\n                    keccak256(bytes(\"1\")),\n                    block.chainid,\n                    address(this)\n                )\n            );\n    }\n}\n"
+      "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\n\nimport \"./IReceiveBalanceApproval.sol\";\nimport \"../vault/IVault.sol\";\n\n/// @title Bitcoin Bank\n/// @notice Bank is a central component tracking Bitcoin balances. Balances can\n///         be transferred between balance owners, and balance owners can\n///         approve their balances to be spent by others. Balances in the Bank\n///         are updated for depositors who deposited their Bitcoin into the\n///         Bridge and only the Bridge can increase balances.\n/// @dev Bank is a governable contract and the Governance can upgrade the Bridge\n///      address.\ncontract Bank is Ownable {\n    address public bridge;\n\n    /// @notice The balance of the given account in the Bank. Zero by default.\n    mapping(address => uint256) public balanceOf;\n\n    /// @notice The remaining amount of balance a spender will be\n    ///         allowed to transfer on behalf of an owner using\n    ///         `transferBalanceFrom`. Zero by default.\n    mapping(address => mapping(address => uint256)) public allowance;\n\n    /// @notice Returns the current nonce for an EIP2612 permission for the\n    ///         provided balance owner to protect against replay attacks. Used\n    ///         to construct an EIP2612 signature provided to the `permit`\n    ///         function.\n    mapping(address => uint256) public nonce;\n\n    uint256 public immutable cachedChainId;\n    bytes32 public immutable cachedDomainSeparator;\n\n    /// @notice Returns an EIP2612 Permit message hash. Used to construct\n    ///         an EIP2612 signature provided to the `permit` function.\n    bytes32 public constant PERMIT_TYPEHASH =\n        keccak256(\n            \"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\"\n        );\n\n    event BalanceTransferred(\n        address indexed from,\n        address indexed to,\n        uint256 amount\n    );\n\n    event BalanceApproved(\n        address indexed owner,\n        address indexed spender,\n        uint256 amount\n    );\n\n    event BalanceIncreased(address indexed owner, uint256 amount);\n\n    event BalanceDecreased(address indexed owner, uint256 amount);\n\n    event BridgeUpdated(address newBridge);\n\n    modifier onlyBridge() {\n        require(msg.sender == address(bridge), \"Caller is not the bridge\");\n        _;\n    }\n\n    constructor() {\n        cachedChainId = block.chainid;\n        cachedDomainSeparator = buildDomainSeparator();\n    }\n\n    /// @notice Allows the Governance to upgrade the Bridge address.\n    /// @dev The function does not implement any governance delay and does not\n    ///      check the status of the Bridge. The Governance implementation needs\n    ///      to ensure all requirements for the upgrade are satisfied before\n    ///      executing this function.\n    ///      Requirements:\n    ///      - The new Bridge address must not be zero.\n    /// @param _bridge The new Bridge address.\n    function updateBridge(address _bridge) external onlyOwner {\n        require(_bridge != address(0), \"Bridge address must not be 0x0\");\n        bridge = _bridge;\n        emit BridgeUpdated(_bridge);\n    }\n\n    /// @notice Moves the given `amount` of balance from the caller to\n    ///         `recipient`.\n    /// @dev Requirements:\n    ///       - `recipient` cannot be the zero address,\n    ///       - the caller must have a balance of at least `amount`.\n    /// @param recipient The recipient of the balance.\n    /// @param amount The amount of the balance transferred.\n    function transferBalance(address recipient, uint256 amount) external {\n        _transferBalance(msg.sender, recipient, amount);\n    }\n\n    /// @notice Sets `amount` as the allowance of `spender` over the caller's\n    ///         balance.\n    /// @dev If the `amount` is set to `type(uint256).max`,\n    ///      `transferBalanceFrom` will not reduce an allowance.\n    ///      Beware that changing an allowance with this function brings the\n    ///      risk that someone may use both the old and the new allowance by\n    ///      unfortunate transaction ordering. Please use\n    ///      `increaseBalanceAllowance` and `decreaseBalanceAllowance` to\n    ///      eliminate the risk.\n    /// @param spender The address that will be allowed to spend the balance.\n    /// @param amount The amount the spender is allowed to spend.\n    function approveBalance(address spender, uint256 amount) external {\n        _approveBalance(msg.sender, spender, amount);\n    }\n\n    /// @notice Sets the `amount` as an allowance of a smart contract `spender`\n    ///         over the caller's balance and calls the `spender` via\n    ///         `receiveBalanceApproval`.\n    /// @dev If the `amount` is set to `type(uint256).max`, the potential\n    ///     `transferBalanceFrom` executed in `receiveBalanceApproval` of\n    ///      `spender` will not reduce an allowance. Beware that changing an\n    ///      allowance with this function brings the risk that `spender` may use\n    ///      both the old and the new allowance by unfortunate transaction\n    ///      ordering. Please use `increaseBalanceAllowance` and\n    ///      `decreaseBalanceAllowance` to eliminate the risk.\n    /// @param spender The smart contract that will be allowed to spend the\n    ///        balance.\n    /// @param amount The amount the spender contract is allowed to spend.\n    /// @param extraData Extra data passed to the `spender` contract via\n    ///        `receiveBalanceApproval` call.\n    function approveBalanceAndCall(\n        address spender,\n        uint256 amount,\n        bytes memory extraData\n    ) external {\n        _approveBalance(msg.sender, spender, amount);\n        IReceiveBalanceApproval(spender).receiveBalanceApproval(\n            msg.sender,\n            amount,\n            extraData\n        );\n    }\n\n    /// @notice Atomically increases the caller's balance allowance granted to\n    ///         `spender` by the given `addedValue`.\n    /// @param spender The spender address for which the allowance is increased.\n    /// @param addedValue The amount by which the allowance is increased.\n    function increaseBalanceAllowance(address spender, uint256 addedValue)\n        external\n    {\n        _approveBalance(\n            msg.sender,\n            spender,\n            allowance[msg.sender][spender] + addedValue\n        );\n    }\n\n    /// @notice Atomically decreases the caller's balance allowance granted to\n    ///         `spender` by the given `subtractedValue`.\n    /// @dev Requirements:\n    ///      - `spender` must not be the zero address,\n    ///      - the current allowance for `spender` must not be lower than\n    ///        the `subtractedValue`.\n    /// @param spender The spender address for which the allowance is decreased.\n    /// @param subtractedValue The amount by which the allowance is decreased.\n    function decreaseBalanceAllowance(address spender, uint256 subtractedValue)\n        external\n    {\n        uint256 currentAllowance = allowance[msg.sender][spender];\n        require(\n            currentAllowance >= subtractedValue,\n            \"Can not decrease balance allowance below zero\"\n        );\n        unchecked {\n            _approveBalance(\n                msg.sender,\n                spender,\n                currentAllowance - subtractedValue\n            );\n        }\n    }\n\n    /// @notice Moves `amount` of balance from `spender` to `recipient` using the\n    ///         allowance mechanism. `amount` is then deducted from the caller's\n    ///         allowance unless the allowance was made for `type(uint256).max`.\n    /// @dev Requirements:\n    ///      - `recipient` cannot be the zero address,\n    ///      - `spender` must have a balance of at least `amount`,\n    ///      - the caller must have an allowance for `spender`'s balance of at\n    ///        least `amount`.\n    /// @param spender The address from which the balance is transferred.\n    /// @param recipient The address to which the balance is transferred.\n    /// @param amount The amount of balance that is transferred.\n    function transferBalanceFrom(\n        address spender,\n        address recipient,\n        uint256 amount\n    ) external {\n        uint256 currentAllowance = allowance[spender][msg.sender];\n        if (currentAllowance != type(uint256).max) {\n            require(\n                currentAllowance >= amount,\n                \"Transfer amount exceeds allowance\"\n            );\n            unchecked {\n                _approveBalance(spender, msg.sender, currentAllowance - amount);\n            }\n        }\n        _transferBalance(spender, recipient, amount);\n    }\n\n    /// @notice An EIP2612 approval made with secp256k1 signature. Users can\n    ///         authorize a transfer of their balance with a signature\n    ///         conforming to the EIP712 standard, rather than an on-chain\n    ///         transaction from their address. Anyone can submit this signature\n    ///         on the user's behalf by calling the `permit` function, paying\n    ///         gas fees, and possibly performing other actions in the same\n    ///         transaction.\n    /// @dev The deadline argument can be set to `type(uint256).max to create\n    ///      permits that effectively never expire.  If the `amount` is set\n    ///      to `type(uint256).max` then `transferBalanceFrom` will not\n    ///      reduce an allowance. Beware that changing an allowance with this\n    ///      function brings the risk that someone may use both the old and the\n    ///      new allowance by unfortunate transaction ordering. Please use\n    ///      `increaseBalanceAllowance` and `decreaseBalanceAllowance` to\n    ///      eliminate the risk.\n    /// @param owner The balance owner who signed the permission.\n    /// @param spender The address that will be allowed to spend the balance.\n    /// @param amount The amount the spender is allowed to spend.\n    /// @param deadline The UNIX time until which the permit is valid.\n    /// @param v V part of the permit signature.\n    /// @param r R part of the permit signature.\n    /// @param s S part of the permit signature.\n    function permit(\n        address owner,\n        address spender,\n        uint256 amount,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external {\n        /* solhint-disable-next-line not-rely-on-time */\n        require(deadline >= block.timestamp, \"Permission expired\");\n\n        // Validate `s` and `v` values for a malleability concern described in EIP2.\n        // Only signatures with `s` value in the lower half of the secp256k1\n        // curve's order and `v` value of 27 or 28 are considered valid.\n        require(\n            uint256(s) <=\n                0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,\n            \"Invalid signature 's' value\"\n        );\n        require(v == 27 || v == 28, \"Invalid signature 'v' value\");\n\n        bytes32 digest = keccak256(\n            abi.encodePacked(\n                \"\\x19\\x01\",\n                DOMAIN_SEPARATOR(),\n                keccak256(\n                    abi.encode(\n                        PERMIT_TYPEHASH,\n                        owner,\n                        spender,\n                        amount,\n                        nonce[owner]++,\n                        deadline\n                    )\n                )\n            )\n        );\n        address recoveredAddress = ecrecover(digest, v, r, s);\n        require(\n            recoveredAddress != address(0) && recoveredAddress == owner,\n            \"Invalid signature\"\n        );\n        _approveBalance(owner, spender, amount);\n    }\n\n    /// @notice Increases balances of the provided `recipients` by the provided\n    ///         `amounts`. Can only be called by the Bridge.\n    /// @dev Requirements:\n    ///       - length of `recipients` and `amounts` must be the same,\n    ///       - none of `recipients` addresses must point to the Bank.\n    /// @param recipients Balance increase recipients.\n    /// @param amounts Amounts by which balances are increased.\n    function increaseBalances(\n        address[] calldata recipients,\n        uint256[] calldata amounts\n    ) external onlyBridge {\n        require(\n            recipients.length == amounts.length,\n            \"Arrays must have the same length\"\n        );\n        for (uint256 i = 0; i < recipients.length; i++) {\n            _increaseBalance(recipients[i], amounts[i]);\n        }\n    }\n\n    /// @notice Increases balance of the provided `recipient` by the provided\n    ///         `amount`. Can only be called by the Bridge.\n    /// @dev Requirements:\n    ///      - `recipient` address must not point to the Bank.\n    /// @param recipient Balance increase recipient.\n    /// @param amount Amount by which the balance is increased.\n    function increaseBalance(address recipient, uint256 amount)\n        external\n        onlyBridge\n    {\n        _increaseBalance(recipient, amount);\n    }\n\n    /// @notice Increases the given smart contract `vault`'s balance and\n    ///         notifies the `vault` contract about it.\n    ///         Can be called only by the Bridge.\n    /// @dev Requirements:\n    ///       - `vault` must implement `IVault` interface,\n    ///       - length of `recipients` and `amounts` must be the same.\n    /// @param vault Address of `IVault` recipient contract.\n    /// @param recipients Balance increase recipients.\n    /// @param amounts Amounts by which balances are increased.\n    function increaseBalanceAndCall(\n        address vault,\n        address[] calldata recipients,\n        uint256[] calldata amounts\n    ) external onlyBridge {\n        require(\n            recipients.length == amounts.length,\n            \"Arrays must have the same length\"\n        );\n        uint256 totalAmount = 0;\n        for (uint256 i = 0; i < amounts.length; i++) {\n            totalAmount += amounts[i];\n        }\n        _increaseBalance(vault, totalAmount);\n        IVault(vault).receiveBalanceIncrease(recipients, amounts);\n    }\n\n    /// @notice Decreases caller's balance by the provided `amount`. There is no\n    ///         way to restore the balance so do not call this function unless\n    ///         you really know what you are doing!\n    /// @dev Requirements:\n    ///      - The caller must have a balance of at least `amount`.\n    /// @param amount The amount by which the balance is decreased.\n    function decreaseBalance(uint256 amount) external {\n        balanceOf[msg.sender] -= amount;\n        emit BalanceDecreased(msg.sender, amount);\n    }\n\n    /// @notice Returns hash of EIP712 Domain struct with `TBTC Bank` as\n    ///         a signing domain and Bank contract as a verifying contract.\n    ///         Used to construct an EIP2612 signature provided to the `permit`\n    ///         function.\n    /* solhint-disable-next-line func-name-mixedcase */\n    function DOMAIN_SEPARATOR() public view returns (bytes32) {\n        // As explained in EIP-2612, if the DOMAIN_SEPARATOR contains the\n        // chainId and is defined at contract deployment instead of\n        // reconstructed for every signature, there is a risk of possible replay\n        // attacks between chains in the event of a future chain split.\n        // To address this issue, we check the cached chain ID against the\n        // current one and in case they are different, we build domain separator\n        // from scratch.\n        if (block.chainid == cachedChainId) {\n            return cachedDomainSeparator;\n        } else {\n            return buildDomainSeparator();\n        }\n    }\n\n    function _increaseBalance(address recipient, uint256 amount) internal {\n        require(\n            recipient != address(this),\n            \"Can not increase balance for Bank\"\n        );\n        balanceOf[recipient] += amount;\n        emit BalanceIncreased(recipient, amount);\n    }\n\n    function _transferBalance(\n        address spender,\n        address recipient,\n        uint256 amount\n    ) private {\n        require(\n            recipient != address(0),\n            \"Can not transfer to the zero address\"\n        );\n        require(\n            recipient != address(this),\n            \"Can not transfer to the Bank address\"\n        );\n\n        uint256 spenderBalance = balanceOf[spender];\n        require(spenderBalance >= amount, \"Transfer amount exceeds balance\");\n        unchecked {\n            balanceOf[spender] = spenderBalance - amount;\n        }\n        balanceOf[recipient] += amount;\n        emit BalanceTransferred(spender, recipient, amount);\n    }\n\n    function _approveBalance(\n        address owner,\n        address spender,\n        uint256 amount\n    ) private {\n        require(spender != address(0), \"Can not approve to the zero address\");\n        allowance[owner][spender] = amount;\n        emit BalanceApproved(owner, spender, amount);\n    }\n\n    function buildDomainSeparator() private view returns (bytes32) {\n        return\n            keccak256(\n                abi.encode(\n                    keccak256(\n                        \"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"\n                    ),\n                    keccak256(bytes(\"TBTC Bank\")),\n                    keccak256(bytes(\"1\")),\n                    block.chainid,\n                    address(this)\n                )\n            );\n    }\n}\n"
     },
     "@openzeppelin/contracts/access/Ownable.sol": {
       "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n        _;\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby removing any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"
@@ -17,7 +17,7 @@
       "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n}\n"
     },
     "contracts/vault/TBTCVault.sol": {
-      "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\nimport \"@keep-network/random-beacon/contracts/Governable.sol\";\n\nimport \"./IVault.sol\";\nimport \"../bank/Bank.sol\";\nimport \"../token/TBTC.sol\";\n\n/// @title TBTC application vault\n/// @notice TBTC is a fully Bitcoin-backed ERC-20 token pegged to the price of\n///         Bitcoin. It facilitates Bitcoin holders to act on the Ethereum\n///         blockchain and access the decentralized finance (DeFi) ecosystem.\n///         TBTC Vault mints and redeems TBTC based on Bitcoin balances in the\n///         Bank.\n/// @dev TBTC Vault is the owner of TBTC token contract and is the only contract\n///      minting the token.\ncontract TBTCVault is IVault, Governable {\n    Bank public bank;\n    TBTC public tbtcToken;\n\n    event Minted(address indexed to, uint256 amount);\n\n    event Redeemed(address indexed from, uint256 amount);\n\n    modifier onlyBank() {\n        require(msg.sender == address(bank), \"Caller is not the Bank\");\n        _;\n    }\n\n    constructor(Bank _bank, TBTC _tbtcToken) {\n        require(\n            address(_bank) != address(0),\n            \"Bank can not be the zero address\"\n        );\n\n        require(\n            address(_tbtcToken) != address(0),\n            \"TBTC token can not be the zero address\"\n        );\n\n        bank = _bank;\n        tbtcToken = _tbtcToken;\n\n        _transferGovernance(msg.sender);\n    }\n\n    /// @notice Allows the governance of the TBTCVault to recover any ERC20\n    ///         token sent mistakenly to the TBTC token contract address.\n    /// @param token Address of the recovered ERC20 token contract.\n    /// @param recipient Address the recovered token should be sent to.\n    /// @param amount Recovered amount.\n    function recoverERC20(\n        IERC20 token,\n        address recipient,\n        uint256 amount\n    ) external onlyGovernance {\n        tbtcToken.recoverERC20(token, recipient, amount);\n    }\n\n    /// @notice Allows the governance of the TBTCVault to recover any ERC721\n    ///         token sent mistakenly to the TBTC token contract address.\n    /// @param token Address of the recovered ERC721 token contract.\n    /// @param recipient Address the recovered token should be sent to.\n    /// @param tokenId Identifier of the recovered token.\n    /// @param data Additional data.\n    function recoverERC721(\n        IERC721 token,\n        address recipient,\n        uint256 tokenId,\n        bytes calldata data\n    ) external onlyGovernance {\n        tbtcToken.recoverERC721(token, recipient, tokenId, data);\n    }\n\n    /// @notice Transfers the given `amount` of the Bank balance from caller\n    ///         to TBTC Vault, and mints `amount` of TBTC to the caller.\n    /// @dev TBTC Vault must have an allowance for caller's balance in the Bank\n    ///      for at least `amount`.\n    /// @param amount Amount of TBTC to mint.\n    function mint(uint256 amount) external {\n        address minter = msg.sender;\n        require(\n            bank.balanceOf(minter) >= amount,\n            \"Amount exceeds balance in the bank\"\n        );\n        _mint(minter, amount);\n        bank.transferBalanceFrom(minter, address(this), amount);\n    }\n\n    /// @notice Transfers the given `amount` of the Bank balance from the caller\n    ///         to TBTC Vault and mints `amount` of TBTC to the caller.\n    /// @dev Can only be called by the Bank via `approveBalanceAndCall`.\n    /// @param owner The owner who approved their Bank balance.\n    /// @param amount Amount of TBTC to mint.\n    function receiveBalanceApproval(\n        address owner,\n        uint256 amount,\n        bytes memory\n    ) external override onlyBank {\n        require(\n            bank.balanceOf(owner) >= amount,\n            \"Amount exceeds balance in the bank\"\n        );\n        _mint(owner, amount);\n        bank.transferBalanceFrom(owner, address(this), amount);\n    }\n\n    /// @notice Mints the same amount of TBTC as the deposited amount for each\n    ///         depositor in the array. Can only be called by the Bank after the\n    ///         Bridge swept deposits and Bank increased balance for the\n    ///         vault.\n    /// @dev Fails if `depositors` array is empty. Expects the length of\n    ///      `depositors` and `depositedAmounts` is the same.\n    function receiveBalanceIncrease(\n        address[] calldata depositors,\n        uint256[] calldata depositedAmounts\n    ) external override onlyBank {\n        require(depositors.length != 0, \"No depositors specified\");\n        for (uint256 i = 0; i < depositors.length; i++) {\n            _mint(depositors[i], depositedAmounts[i]);\n        }\n    }\n\n    /// @notice Burns `amount` of TBTC from the caller's account and transfers\n    ///         `amount` back to the caller's balance in the Bank.\n    /// @dev Caller must have at least `amount` of TBTC approved to\n    ///       TBTC Vault.\n    /// @param amount Amount of TBTC to redeem.\n    function redeem(uint256 amount) external {\n        _redeem(msg.sender, amount);\n    }\n\n    /// @notice Burns `amount` of TBTC from the caller's account and transfers\n    ///         `amount` back to the caller's balance in the Bank.\n    /// @dev This function is doing the same as `redeem` but it allows to\n    ///      execute redemption without an additional approval transaction.\n    ///      The function can be called only via `approveAndCall` of TBTC token.\n    /// @param from TBTC token holder executing redemption.\n    /// @param amount Amount of TBTC to redeem.\n    /// @param token TBTC token address.\n    function receiveApproval(\n        address from,\n        uint256 amount,\n        address token,\n        bytes calldata\n    ) external {\n        require(token == address(tbtcToken), \"Token is not TBTC\");\n        require(msg.sender == token, \"Only TBTC caller allowed\");\n        _redeem(from, amount);\n    }\n\n    // slither-disable-next-line calls-loop\n    function _mint(address minter, uint256 amount) internal {\n        emit Minted(minter, amount);\n        tbtcToken.mint(minter, amount);\n    }\n\n    function _redeem(address redeemer, uint256 amount) internal {\n        emit Redeemed(redeemer, amount);\n        tbtcToken.burnFrom(redeemer, amount);\n        bank.transferBalance(redeemer, amount);\n    }\n}\n"
+      "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\nimport \"@keep-network/random-beacon/contracts/Governable.sol\";\n\nimport \"./IVault.sol\";\nimport \"../bank/Bank.sol\";\nimport \"../token/TBTC.sol\";\n\n/// @title TBTC application vault\n/// @notice TBTC is a fully Bitcoin-backed ERC-20 token pegged to the price of\n///         Bitcoin. It facilitates Bitcoin holders to act on the Ethereum\n///         blockchain and access the decentralized finance (DeFi) ecosystem.\n///         TBTC Vault mints and unmints TBTC based on Bitcoin balances in the\n///         Bank.\n/// @dev TBTC Vault is the owner of TBTC token contract and is the only contract\n///      minting the token.\ncontract TBTCVault is IVault, Governable {\n    Bank public bank;\n    TBTC public tbtcToken;\n\n    event Minted(address indexed to, uint256 amount);\n\n    event Unminted(address indexed from, uint256 amount);\n\n    modifier onlyBank() {\n        require(msg.sender == address(bank), \"Caller is not the Bank\");\n        _;\n    }\n\n    constructor(Bank _bank, TBTC _tbtcToken) {\n        require(\n            address(_bank) != address(0),\n            \"Bank can not be the zero address\"\n        );\n\n        require(\n            address(_tbtcToken) != address(0),\n            \"TBTC token can not be the zero address\"\n        );\n\n        bank = _bank;\n        tbtcToken = _tbtcToken;\n\n        _transferGovernance(msg.sender);\n    }\n\n    /// @notice Allows the governance of the TBTCVault to recover any ERC20\n    ///         token sent mistakenly to the TBTC token contract address.\n    /// @param token Address of the recovered ERC20 token contract.\n    /// @param recipient Address the recovered token should be sent to.\n    /// @param amount Recovered amount.\n    function recoverERC20(\n        IERC20 token,\n        address recipient,\n        uint256 amount\n    ) external onlyGovernance {\n        tbtcToken.recoverERC20(token, recipient, amount);\n    }\n\n    /// @notice Allows the governance of the TBTCVault to recover any ERC721\n    ///         token sent mistakenly to the TBTC token contract address.\n    /// @param token Address of the recovered ERC721 token contract.\n    /// @param recipient Address the recovered token should be sent to.\n    /// @param tokenId Identifier of the recovered token.\n    /// @param data Additional data.\n    function recoverERC721(\n        IERC721 token,\n        address recipient,\n        uint256 tokenId,\n        bytes calldata data\n    ) external onlyGovernance {\n        tbtcToken.recoverERC721(token, recipient, tokenId, data);\n    }\n\n    /// @notice Transfers the given `amount` of the Bank balance from caller\n    ///         to TBTC Vault, and mints `amount` of TBTC to the caller.\n    /// @dev TBTC Vault must have an allowance for caller's balance in the Bank\n    ///      for at least `amount`.\n    /// @param amount Amount of TBTC to mint.\n    function mint(uint256 amount) external {\n        address minter = msg.sender;\n        require(\n            bank.balanceOf(minter) >= amount,\n            \"Amount exceeds balance in the bank\"\n        );\n        _mint(minter, amount);\n        bank.transferBalanceFrom(minter, address(this), amount);\n    }\n\n    /// @notice Transfers the given `amount` of the Bank balance from the caller\n    ///         to TBTC Vault and mints `amount` of TBTC to the caller.\n    /// @dev Can only be called by the Bank via `approveBalanceAndCall`.\n    /// @param owner The owner who approved their Bank balance.\n    /// @param amount Amount of TBTC to mint.\n    function receiveBalanceApproval(\n        address owner,\n        uint256 amount,\n        bytes memory\n    ) external override onlyBank {\n        require(\n            bank.balanceOf(owner) >= amount,\n            \"Amount exceeds balance in the bank\"\n        );\n        _mint(owner, amount);\n        bank.transferBalanceFrom(owner, address(this), amount);\n    }\n\n    /// @notice Mints the same amount of TBTC as the deposited amount for each\n    ///         depositor in the array. Can only be called by the Bank after the\n    ///         Bridge swept deposits and Bank increased balance for the\n    ///         vault.\n    /// @dev Fails if `depositors` array is empty. Expects the length of\n    ///      `depositors` and `depositedAmounts` is the same.\n    function receiveBalanceIncrease(\n        address[] calldata depositors,\n        uint256[] calldata depositedAmounts\n    ) external override onlyBank {\n        require(depositors.length != 0, \"No depositors specified\");\n        for (uint256 i = 0; i < depositors.length; i++) {\n            _mint(depositors[i], depositedAmounts[i]);\n        }\n    }\n\n    /// @notice Burns `amount` of TBTC from the caller's account and transfers\n    ///         `amount` back to the caller's balance in the Bank.\n    /// @dev Caller must have at least `amount` of TBTC approved to\n    ///       TBTC Vault.\n    /// @param amount Amount of TBTC to unmint.\n    function unmint(uint256 amount) external {\n        _unmint(msg.sender, amount);\n    }\n\n    /// @notice Burns `amount` of TBTC from the caller's account and transfers\n    ///         `amount` back to the caller's balance in the Bank.\n    /// @dev This function is doing the same as `unmint` but it allows to\n    ///      execute unminting without an additional approval transaction.\n    ///      The function can be called only via `approveAndCall` of TBTC token.\n    /// @param from TBTC token holder executing unminting.\n    /// @param amount Amount of TBTC to unmint.\n    /// @param token TBTC token address.\n    function receiveApproval(\n        address from,\n        uint256 amount,\n        address token,\n        bytes calldata\n    ) external {\n        require(token == address(tbtcToken), \"Token is not TBTC\");\n        require(msg.sender == token, \"Only TBTC caller allowed\");\n        _unmint(from, amount);\n    }\n\n    // slither-disable-next-line calls-loop\n    function _mint(address minter, uint256 amount) internal {\n        emit Minted(minter, amount);\n        tbtcToken.mint(minter, amount);\n    }\n\n    function _unmint(address unminter, uint256 amount) internal {\n        emit Unminted(unminter, amount);\n        tbtcToken.burnFrom(unminter, amount);\n        bank.transferBalance(unminter, amount);\n    }\n}\n"
     },
     "@keep-network/random-beacon/contracts/Governable.sol": {
       "content": "// SPDX-License-Identifier: MIT\n//\n// ▓▓▌ ▓▓ ▐▓▓ ▓▓▓▓▓▓▓▓▓▓▌▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▄\n// ▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▌▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓\n//   ▓▓▓▓▓▓    ▓▓▓▓▓▓▓▀    ▐▓▓▓▓▓▓    ▐▓▓▓▓▓   ▓▓▓▓▓▓     ▓▓▓▓▓   ▐▓▓▓▓▓▌   ▐▓▓▓▓▓▓\n//   ▓▓▓▓▓▓▄▄▓▓▓▓▓▓▓▀      ▐▓▓▓▓▓▓▄▄▄▄         ▓▓▓▓▓▓▄▄▄▄         ▐▓▓▓▓▓▌   ▐▓▓▓▓▓▓\n//   ▓▓▓▓▓▓▓▓▓▓▓▓▓▀        ▐▓▓▓▓▓▓▓▓▓▓         ▓▓▓▓▓▓▓▓▓▓         ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓\n//   ▓▓▓▓▓▓▀▀▓▓▓▓▓▓▄       ▐▓▓▓▓▓▓▀▀▀▀         ▓▓▓▓▓▓▀▀▀▀         ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▀\n//   ▓▓▓▓▓▓   ▀▓▓▓▓▓▓▄     ▐▓▓▓▓▓▓     ▓▓▓▓▓   ▓▓▓▓▓▓     ▓▓▓▓▓   ▐▓▓▓▓▓▌\n// ▓▓▓▓▓▓▓▓▓▓ █▓▓▓▓▓▓▓▓▓ ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓▓▓\n// ▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓ ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓▓▓\n//\n//                           Trust math, not hardware.\n\npragma solidity ^0.8.9;\n\n/// @notice Governable contract.\n/// @dev A constructor is not defined, which makes the contract compatible with\n///      upgradable proxies. This requires calling explicitly `_transferGovernance`\n///      function in a child contract.\nabstract contract Governable {\n    // Governance of the contract\n    // The variable should be initialized by the implementing contract.\n    // slither-disable-next-line uninitialized-state\n    address public governance;\n\n    // Reserved storage space in case we need to add more variables,\n    // since there are upgradeable contracts that inherit from this one.\n    // See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n    // slither-disable-next-line unused-state\n    uint256[49] private __gap;\n\n    event GovernanceTransferred(address oldGovernance, address newGovernance);\n\n    modifier onlyGovernance() virtual {\n        require(governance == msg.sender, \"Caller is not the governance\");\n        _;\n    }\n\n    /// @notice Transfers governance of the contract to `newGovernance`.\n    function transferGovernance(address newGovernance)\n        external\n        virtual\n        onlyGovernance\n    {\n        require(\n            newGovernance != address(0),\n            \"New governance is the zero address\"\n        );\n        _transferGovernance(newGovernance);\n    }\n\n    function _transferGovernance(address newGovernance) internal virtual {\n        address oldGovernance = governance;\n        governance = newGovernance;\n        emit GovernanceTransferred(oldGovernance, newGovernance);\n    }\n}\n"
@@ -125,11 +125,14 @@
       "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     * ====\n     *\n     * [IMPORTANT]\n     * ====\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCall(target, data, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        require(isContract(target), \"Address: call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        require(isContract(target), \"Address: static call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            // Look for revert reason and bubble it up if present\n            if (returndata.length > 0) {\n                // The easiest way to bubble the revert reason is using memory via assembly\n\n                assembly {\n                    let returndata_size := mload(returndata)\n                    revert(add(32, returndata), returndata_size)\n                }\n            } else {\n                revert(errorMessage);\n            }\n        }\n    }\n}\n"
     },
     "contracts/bridge/Bridge.sol": {
-      "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\nimport \"@keep-network/random-beacon/contracts/Governable.sol\";\nimport {IWalletOwner as EcdsaWalletOwner} from \"@keep-network/ecdsa/contracts/api/IWalletOwner.sol\";\n\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\";\n\nimport \"./IRelay.sol\";\nimport \"./BridgeState.sol\";\nimport \"./Deposit.sol\";\nimport \"./DepositSweep.sol\";\nimport \"./Redemption.sol\";\nimport \"./BitcoinTx.sol\";\nimport \"./EcdsaLib.sol\";\nimport \"./Wallets.sol\";\nimport \"./Fraud.sol\";\nimport \"./MovingFunds.sol\";\n\nimport \"../bank/Bank.sol\";\n\n/// @title Bitcoin Bridge\n/// @notice Bridge manages BTC deposit and redemption flow and is increasing and\n///         decreasing balances in the Bank as a result of BTC deposit and\n///         redemption operations performed by depositors and redeemers.\n///\n///         Depositors send BTC funds to the most recently created off-chain\n///         ECDSA wallet of the bridge using pay-to-script-hash (P2SH) or\n///         pay-to-witness-script-hash (P2WSH) containing hashed information\n///         about the depositor’s Ethereum address. Then, the depositor reveals\n///         their Ethereum address along with their deposit blinding factor,\n///         refund public key hash and refund locktime to the Bridge on Ethereum\n///         chain. The off-chain ECDSA wallet listens for these sorts of\n///         messages and when it gets one, it checks the Bitcoin network to make\n///         sure the deposit lines up. If it does, the off-chain ECDSA wallet\n///         may decide to pick the deposit transaction for sweeping, and when\n///         the sweep operation is confirmed on the Bitcoin network, the ECDSA\n///         wallet informs the Bridge about the sweep increasing appropriate\n///         balances in the Bank.\n/// @dev Bridge is an upgradeable component of the Bank. The order of\n///      functionalities in this contract is: deposit, sweep, redemption,\n///      moving funds, wallet lifecycle, frauds, parameters.\ncontract Bridge is Governable, EcdsaWalletOwner, Initializable {\n    using BridgeState for BridgeState.Storage;\n    using Deposit for BridgeState.Storage;\n    using DepositSweep for BridgeState.Storage;\n    using Redemption for BridgeState.Storage;\n    using MovingFunds for BridgeState.Storage;\n    using Wallets for BridgeState.Storage;\n    using Fraud for BridgeState.Storage;\n\n    BridgeState.Storage internal self;\n\n    event DepositRevealed(\n        bytes32 fundingTxHash,\n        uint32 fundingOutputIndex,\n        address indexed depositor,\n        uint64 amount,\n        bytes8 blindingFactor,\n        bytes20 indexed walletPubKeyHash,\n        bytes20 refundPubKeyHash,\n        bytes4 refundLocktime,\n        address vault\n    );\n\n    event DepositsSwept(bytes20 walletPubKeyHash, bytes32 sweepTxHash);\n\n    event RedemptionRequested(\n        bytes20 indexed walletPubKeyHash,\n        bytes redeemerOutputScript,\n        address indexed redeemer,\n        uint64 requestedAmount,\n        uint64 treasuryFee,\n        uint64 txMaxFee\n    );\n\n    event RedemptionsCompleted(\n        bytes20 indexed walletPubKeyHash,\n        bytes32 redemptionTxHash\n    );\n\n    event RedemptionTimedOut(\n        bytes20 indexed walletPubKeyHash,\n        bytes redeemerOutputScript\n    );\n\n    event WalletMovingFunds(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event MovingFundsCommitmentSubmitted(\n        bytes20 indexed walletPubKeyHash,\n        bytes20[] targetWallets,\n        address submitter\n    );\n\n    event MovingFundsTimeoutReset(bytes20 indexed walletPubKeyHash);\n\n    event MovingFundsCompleted(\n        bytes20 indexed walletPubKeyHash,\n        bytes32 movingFundsTxHash\n    );\n\n    event MovingFundsTimedOut(bytes20 indexed walletPubKeyHash);\n\n    event MovingFundsBelowDustReported(bytes20 indexed walletPubKeyHash);\n\n    event MovedFundsSwept(\n        bytes20 indexed walletPubKeyHash,\n        bytes32 sweepTxHash\n    );\n\n    event MovedFundsSweepTimedOut(\n        bytes20 indexed walletPubKeyHash,\n        bytes32 movingFundsTxHash,\n        uint32 movingFundsTxOutputIndex\n    );\n\n    event NewWalletRequested();\n\n    event NewWalletRegistered(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletClosing(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletClosed(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletTerminated(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event FraudChallengeSubmitted(\n        bytes20 indexed walletPubKeyHash,\n        bytes32 sighash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    );\n\n    event FraudChallengeDefeated(\n        bytes20 indexed walletPubKeyHash,\n        bytes32 sighash\n    );\n\n    event FraudChallengeDefeatTimedOut(\n        bytes20 indexed walletPubKeyHash,\n        bytes32 sighash\n    );\n\n    event VaultStatusUpdated(address indexed vault, bool isTrusted);\n\n    event DepositParametersUpdated(\n        uint64 depositDustThreshold,\n        uint64 depositTreasuryFeeDivisor,\n        uint64 depositTxMaxFee\n    );\n\n    event RedemptionParametersUpdated(\n        uint64 redemptionDustThreshold,\n        uint64 redemptionTreasuryFeeDivisor,\n        uint64 redemptionTxMaxFee,\n        uint256 redemptionTimeout,\n        uint96 redemptionTimeoutSlashingAmount,\n        uint256 redemptionTimeoutNotifierRewardMultiplier\n    );\n\n    event MovingFundsParametersUpdated(\n        uint64 movingFundsTxMaxTotalFee,\n        uint64 movingFundsDustThreshold,\n        uint32 movingFundsTimeoutResetDelay,\n        uint32 movingFundsTimeout,\n        uint96 movingFundsTimeoutSlashingAmount,\n        uint256 movingFundsTimeoutNotifierRewardMultiplier,\n        uint64 movedFundsSweepTxMaxTotalFee,\n        uint32 movedFundsSweepTimeout,\n        uint96 movedFundsSweepTimeoutSlashingAmount,\n        uint256 movedFundsSweepTimeoutNotifierRewardMultiplier\n    );\n\n    event WalletParametersUpdated(\n        uint32 walletCreationPeriod,\n        uint64 walletCreationMinBtcBalance,\n        uint64 walletCreationMaxBtcBalance,\n        uint64 walletClosureMinBtcBalance,\n        uint32 walletMaxAge,\n        uint64 walletMaxBtcTransfer,\n        uint32 walletClosingPeriod\n    );\n\n    event FraudParametersUpdated(\n        uint256 fraudChallengeDepositAmount,\n        uint256 fraudChallengeDefeatTimeout,\n        uint96 fraudSlashingAmount,\n        uint256 fraudNotifierRewardMultiplier\n    );\n\n    /// @dev Initializes upgradable contract on deployment.\n    /// @param _bank Address of the Bank the Bridge belongs to.\n    /// @param _relay Address of the Bitcoin relay providing the current Bitcoin\n    ///        network difficulty.\n    /// @param _treasury Address where the deposit and redemption treasury fees\n    ///        will be sent to.\n    /// @param _ecdsaWalletRegistry Address of the ECDSA Wallet Registry contract.\n    /// @param _txProofDifficultyFactor The number of confirmations on the Bitcoin\n    ///        chain required to successfully evaluate an SPV proof.\n    function initialize(\n        address _bank,\n        address _relay,\n        address _treasury,\n        address _ecdsaWalletRegistry,\n        uint256 _txProofDifficultyFactor\n    ) external initializer {\n        require(_bank != address(0), \"Bank address cannot be zero\");\n        self.bank = Bank(_bank);\n\n        require(_relay != address(0), \"Relay address cannot be zero\");\n        self.relay = IRelay(_relay);\n\n        require(\n            _ecdsaWalletRegistry != address(0),\n            \"ECDSA Wallet Registry address cannot be zero\"\n        );\n        self.ecdsaWalletRegistry = EcdsaWalletRegistry(_ecdsaWalletRegistry);\n\n        require(_treasury != address(0), \"Treasury address cannot be zero\");\n        self.treasury = _treasury;\n\n        self.txProofDifficultyFactor = _txProofDifficultyFactor;\n\n        // TODO: Revisit initial values.\n        //       https://github.com/keep-network/tbtc-v2/issues/258\n        self.depositDustThreshold = 1000000; // 1000000 satoshi = 0.01 BTC\n        self.depositTxMaxFee = 10000; // 10000 satoshi\n        self.depositTreasuryFeeDivisor = 2000; // 1/2000 == 5bps == 0.05% == 0.0005\n        self.redemptionDustThreshold = 1000000; // 1000000 satoshi = 0.01 BTC\n        self.redemptionTreasuryFeeDivisor = 2000; // 1/2000 == 5bps == 0.05% == 0.0005\n        self.redemptionTxMaxFee = 10000; // 10000 satoshi\n        self.redemptionTimeout = 172800; // 48 hours\n        self.redemptionTimeoutSlashingAmount = 10000 * 1e18; // 10000 T\n        self.redemptionTimeoutNotifierRewardMultiplier = 100; // 100%\n        self.movingFundsTxMaxTotalFee = 10000; // 10000 satoshi\n        self.movingFundsDustThreshold = 20000; // 20000 satoshi\n        self.movingFundsTimeoutResetDelay = 6 days;\n        self.movingFundsTimeout = 7 days;\n        self.movingFundsTimeoutSlashingAmount = 10000 * 1e18; // 10000 T\n        self.movingFundsTimeoutNotifierRewardMultiplier = 100; //100%\n        self.movedFundsSweepTxMaxTotalFee = 10000; // 10000 satoshi\n        self.movedFundsSweepTimeout = 7 days;\n        self.movedFundsSweepTimeoutSlashingAmount = 10000 * 1e18; // 10000 T\n        self.movedFundsSweepTimeoutNotifierRewardMultiplier = 100; //100%\n        self.fraudChallengeDepositAmount = 2 ether;\n        self.fraudChallengeDefeatTimeout = 7 days;\n        self.fraudSlashingAmount = 10000 * 1e18; // 10000 T\n        self.fraudNotifierRewardMultiplier = 100; // 100%\n        self.walletCreationPeriod = 1 weeks;\n        self.walletCreationMinBtcBalance = 1e8; // 1 BTC\n        self.walletCreationMaxBtcBalance = 100e8; // 100 BTC\n        self.walletClosureMinBtcBalance = 5 * 1e7; // 0.5 BTC\n        self.walletMaxAge = 26 weeks; // ~6 months\n        self.walletMaxBtcTransfer = 10e8; // 10 BTC\n        self.walletClosingPeriod = 40 days;\n\n        _transferGovernance(msg.sender);\n    }\n\n    /// @notice Used by the depositor to reveal information about their P2(W)SH\n    ///         Bitcoin deposit to the Bridge on Ethereum chain. The off-chain\n    ///         wallet listens for revealed deposit events and may decide to\n    ///         include the revealed deposit in the next executed sweep.\n    ///         Information about the Bitcoin deposit can be revealed before or\n    ///         after the Bitcoin transaction with P2(W)SH deposit is mined on\n    ///         the Bitcoin chain. Worth noting, the gas cost of this function\n    ///         scales with the number of P2(W)SH transaction inputs and\n    ///         outputs. The deposit may be routed to one of the trusted vaults.\n    ///         When a deposit is routed to a vault, vault gets notified when\n    ///         the deposit gets swept and it may execute the appropriate action.\n    /// @param fundingTx Bitcoin funding transaction data, see `BitcoinTx.Info`.\n    /// @param reveal Deposit reveal data, see `RevealInfo struct.\n    /// @dev Requirements:\n    ///      - `reveal.walletPubKeyHash` must identify a `Live` wallet,\n    ///      - `reveal.vault` must be 0x0 or point to a trusted vault,\n    ///      - `reveal.fundingOutputIndex` must point to the actual P2(W)SH\n    ///        output of the BTC deposit transaction,\n    ///      - `reveal.depositor` must be the Ethereum address used in the\n    ///        P2(W)SH BTC deposit transaction,\n    ///      - `reveal.blindingFactor` must be the blinding factor used in the\n    ///        P2(W)SH BTC deposit transaction,\n    ///      - `reveal.walletPubKeyHash` must be the wallet pub key hash used in\n    ///        the P2(W)SH BTC deposit transaction,\n    ///      - `reveal.refundPubKeyHash` must be the refund pub key hash used in\n    ///        the P2(W)SH BTC deposit transaction,\n    ///      - `reveal.refundLocktime` must be the refund locktime used in the\n    ///        P2(W)SH BTC deposit transaction,\n    ///      - BTC deposit for the given `fundingTxHash`, `fundingOutputIndex`\n    ///        can be revealed only one time.\n    ///\n    ///      If any of these requirements is not met, the wallet _must_ refuse\n    ///      to sweep the deposit and the depositor has to wait until the\n    ///      deposit script unlocks to receive their BTC back.\n    function revealDeposit(\n        BitcoinTx.Info calldata fundingTx,\n        Deposit.DepositRevealInfo calldata reveal\n    ) external {\n        self.revealDeposit(fundingTx, reveal);\n    }\n\n    /// @notice Used by the wallet to prove the BTC deposit sweep transaction\n    ///         and to update Bank balances accordingly. Sweep is only accepted\n    ///         if it satisfies SPV proof.\n    ///\n    ///         The function is performing Bank balance updates by first\n    ///         computing the Bitcoin fee for the sweep transaction. The fee is\n    ///         divided evenly between all swept deposits. Each depositor\n    ///         receives a balance in the bank equal to the amount inferred\n    ///         during the reveal transaction, minus their fee share.\n    ///\n    ///         It is possible to prove the given sweep only one time.\n    /// @param sweepTx Bitcoin sweep transaction data.\n    /// @param sweepProof Bitcoin sweep proof data.\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain. If no main UTXO exists for the given wallet,\n    ///        this parameter is ignored.\n    /// @param vault Optional address of the vault where all swept deposits\n    ///        should be routed to. All deposits swept as part of the transaction\n    ///        must have their `vault` parameters set to the same address.\n    ///        If this parameter is set to an address of a trusted vault, swept\n    ///        deposits are routed to that vault.\n    ///        If this parameter is set to the zero address or to an address\n    ///        of a non-trusted vault, swept deposits are not routed to a\n    ///        vault but depositors' balances are increased in the Bank\n    ///        individually.\n    /// @dev Requirements:\n    ///      - `sweepTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash,\n    ///      - The `sweepTx` should represent a Bitcoin transaction with 1..n\n    ///        inputs. If the wallet has no main UTXO, all n inputs should\n    ///        correspond to P2(W)SH revealed deposits UTXOs. If the wallet has\n    ///        an existing main UTXO, one of the n inputs must point to that\n    ///        main UTXO and remaining n-1 inputs should correspond to P2(W)SH\n    ///        revealed deposits UTXOs. That transaction must have only\n    ///        one P2(W)PKH output locking funds on the 20-byte wallet public\n    ///        key hash,\n    ///      - All revealed deposits that are swept by `sweepTx` must have\n    ///        their `vault` parameters set to the same address as the address\n    ///        passed in the `vault` function parameter,\n    ///      - `sweepProof` components must match the expected structure. See\n    ///        `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant,\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        If there is no main UTXO, this parameter is ignored.\n    function submitDepositSweepProof(\n        BitcoinTx.Info calldata sweepTx,\n        BitcoinTx.Proof calldata sweepProof,\n        BitcoinTx.UTXO calldata mainUtxo,\n        address vault\n    ) external {\n        self.submitDepositSweepProof(sweepTx, sweepProof, mainUtxo, vault);\n    }\n\n    /// @notice Requests redemption of the given amount from the specified\n    ///         wallet to the redeemer Bitcoin output script.\n    /// @param walletPubKeyHash The 20-byte wallet public key hash (computed\n    ///        using Bitcoin HASH160 over the compressed ECDSA public key).\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain.\n    /// @param redeemerOutputScript The redeemer's length-prefixed output\n    ///        script (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock\n    ///        redeemed BTC.\n    /// @param amount Requested amount in satoshi. This is also the TBTC amount\n    ///        that is taken from redeemer's balance in the Bank upon request.\n    ///        Once the request is handled, the actual amount of BTC locked\n    ///        on the redeemer output script will be always lower than this value\n    ///        since the treasury and Bitcoin transaction fees must be incurred.\n    ///        The minimal amount satisfying the request can be computed as:\n    ///        `amount - (amount / redemptionTreasuryFeeDivisor) - redemptionTxMaxFee`.\n    ///        Fees values are taken at the moment of request creation.\n    /// @dev Requirements:\n    ///      - Wallet behind `walletPubKeyHash` must be live,\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain,\n    ///      - `redeemerOutputScript` must be a proper Bitcoin script,\n    ///      - `redeemerOutputScript` cannot have wallet PKH as payload,\n    ///      - `amount` must be above or equal the `redemptionDustThreshold`,\n    ///      - Given `walletPubKeyHash` and `redeemerOutputScript` pair can be\n    ///        used for only one pending request at the same time,\n    ///      - Wallet must have enough Bitcoin balance to proceed the request,\n    ///      - Redeemer must make an allowance in the Bank that the Bridge\n    ///        contract can spend the given `amount`.\n    function requestRedemption(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata mainUtxo,\n        bytes calldata redeemerOutputScript,\n        uint64 amount\n    ) external {\n        self.requestRedemption(\n            walletPubKeyHash,\n            mainUtxo,\n            redeemerOutputScript,\n            amount\n        );\n    }\n\n    /// @notice Used by the wallet to prove the BTC redemption transaction\n    ///         and to make the necessary bookkeeping. Redemption is only\n    ///         accepted if it satisfies SPV proof.\n    ///\n    ///         The function is performing Bank balance updates by burning\n    ///         the total redeemed Bitcoin amount from Bridge balance and\n    ///         transferring the treasury fee sum to the treasury address.\n    ///\n    ///         It is possible to prove the given redemption only one time.\n    /// @param redemptionTx Bitcoin redemption transaction data.\n    /// @param redemptionProof Bitcoin redemption proof data.\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain.\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    ///        HASH160 over the compressed ECDSA public key) of the wallet which\n    ///        performed the redemption transaction.\n    /// @dev Requirements:\n    ///      - `redemptionTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash,\n    ///      - The `redemptionTx` should represent a Bitcoin transaction with\n    ///        exactly 1 input that refers to the wallet's main UTXO. That\n    ///        transaction should have 1..n outputs handling existing pending\n    ///        redemption requests or pointing to reported timed out requests.\n    ///        There can be also 1 optional output representing the\n    ///        change and pointing back to the 20-byte wallet public key hash.\n    ///        The change should be always present if the redeemed value sum\n    ///        is lower than the total wallet's BTC balance,\n    ///      - `redemptionProof` components must match the expected structure.\n    ///        See `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant,\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        Additionally, the recent main UTXO on Ethereum must be set,\n    ///      - `walletPubKeyHash` must be connected with the main UTXO used\n    ///        as transaction single input.\n    ///      Other remarks:\n    ///      - Putting the change output as the first transaction output can\n    ///        save some gas because the output processing loop begins each\n    ///        iteration by checking whether the given output is the change\n    ///        thus uses some gas for making the comparison. Once the change\n    ///        is identified, that check is omitted in further iterations.\n    function submitRedemptionProof(\n        BitcoinTx.Info calldata redemptionTx,\n        BitcoinTx.Proof calldata redemptionProof,\n        BitcoinTx.UTXO calldata mainUtxo,\n        bytes20 walletPubKeyHash\n    ) external {\n        self.submitRedemptionProof(\n            redemptionTx,\n            redemptionProof,\n            mainUtxo,\n            walletPubKeyHash\n        );\n    }\n\n    /// @notice Notifies that there is a pending redemption request associated\n    ///         with the given wallet, that has timed out. The redemption\n    ///         request is identified by the key built as\n    ///         `keccak256(walletPubKeyHash | redeemerOutputScript)`.\n    ///         The results of calling this function:\n    ///         - The pending redemptions value for the wallet will be decreased\n    ///           by the requested amount (minus treasury fee),\n    ///         - The tokens taken from the redeemer on redemption request will\n    ///           be returned to the redeemer,\n    ///         - The request will be moved from pending redemptions to\n    ///           timed-out redemptions,\n    ///         - If the state of the wallet is `Live` or `MovingFunds`, the\n    ///           wallet operators will be slashed and the notifier will be\n    ///           rewarded,\n    ///         - If the state of wallet is `Live`, the wallet will be closed or\n    ///           marked as `MovingFunds` (depending on the presence or absence\n    ///           of the wallet's main UTXO) and the wallet will no longer be\n    ///           marked as the active wallet (if it was marked as such).\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet.\n    /// @param walletMembersIDs Identifiers of the wallet signing group members.\n    /// @param redeemerOutputScript  The redeemer's length-prefixed output\n    ///        script (P2PKH, P2WPKH, P2SH or P2WSH).\n    /// @dev Requirements:\n    ///      - The wallet must be in the Live or MovingFunds or Terminated state,\n    ///      - The redemption request identified by `walletPubKeyHash` and\n    ///        `redeemerOutputScript` must exist,\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract,\n    ///      - The amount of time defined by `redemptionTimeout` must have\n    ///        passed since the redemption was requested (the request must be\n    ///        timed-out).\n    function notifyRedemptionTimeout(\n        bytes20 walletPubKeyHash,\n        uint32[] calldata walletMembersIDs,\n        bytes calldata redeemerOutputScript\n    ) external {\n        self.notifyRedemptionTimeout(\n            walletPubKeyHash,\n            walletMembersIDs,\n            redeemerOutputScript\n        );\n    }\n\n    /// @notice Submits the moving funds target wallets commitment.\n    ///         Once all requirements are met, that function registers the\n    ///         target wallets commitment and opens the way for moving funds\n    ///         proof submission.\n    /// @param walletPubKeyHash 20-byte public key hash of the source wallet.\n    /// @param walletMainUtxo Data of the source wallet's main UTXO, as\n    ///        currently known on the Ethereum chain.\n    /// @param walletMembersIDs Identifiers of the source wallet signing group\n    ///        members.\n    /// @param walletMemberIndex Position of the caller in the source wallet\n    ///        signing group members list.\n    /// @param targetWallets List of 20-byte public key hashes of the target\n    ///        wallets that the source wallet commits to move the funds to.\n    /// @dev Requirements:\n    ///      - The source wallet must be in the MovingFunds state,\n    ///      - The source wallet must not have pending redemption requests,\n    ///      - The source wallet must not have pending moved funds sweep requests,\n    ///      - The source wallet must not have submitted its commitment already,\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given source wallet in the ECDSA registry. Those IDs are\n    ///        not directly stored in the contract for gas efficiency purposes\n    ///        but they can be read from appropriate `DkgResultSubmitted`\n    ///        and `DkgResultApproved` events,\n    ///      - The `walletMemberIndex` must be in range [1, walletMembersIDs.length],\n    ///      - The caller must be the member of the source wallet signing group\n    ///        at the position indicated by `walletMemberIndex` parameter,\n    ///      - The `walletMainUtxo` components must point to the recent main\n    ///        UTXO of the source wallet, as currently known on the Ethereum\n    ///        chain,\n    ///      - Source wallet BTC balance must be greater than zero,\n    ///      - At least one Live wallet must exist in the system,\n    ///      - Submitted target wallets count must match the expected count\n    ///        `N = min(liveWalletsCount, ceil(walletBtcBalance / walletMaxBtcTransfer))`\n    ///        where `N > 0`,\n    ///      - Each target wallet must be not equal to the source wallet,\n    ///      - Each target wallet must follow the expected order i.e. all\n    ///        target wallets 20-byte public key hashes represented as numbers\n    ///        must form a strictly increasing sequence without duplicates,\n    ///      - Each target wallet must be in Live state.\n    function submitMovingFundsCommitment(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata walletMainUtxo,\n        uint32[] calldata walletMembersIDs,\n        uint256 walletMemberIndex,\n        bytes20[] calldata targetWallets\n    ) external {\n        self.submitMovingFundsCommitment(\n            walletPubKeyHash,\n            walletMainUtxo,\n            walletMembersIDs,\n            walletMemberIndex,\n            targetWallets\n        );\n    }\n\n    /// @notice Resets the moving funds timeout for the given wallet if the\n    ///         target wallet commitment cannot be submitted due to a lack\n    ///         of live wallets in the system.\n    /// @param walletPubKeyHash 20-byte public key hash of the moving funds wallet.\n    /// @dev Requirements:\n    ///      - The wallet must be in the MovingFunds state,\n    ///      - The target wallets commitment must not be already submitted for\n    ///        the given moving funds wallet,\n    ///      - Live wallets count must be zero,\n    ///      - The moving funds timeout reset delay must be elapsed.\n    function resetMovingFundsTimeout(bytes20 walletPubKeyHash) external {\n        self.resetMovingFundsTimeout(walletPubKeyHash);\n    }\n\n    /// @notice Used by the wallet to prove the BTC moving funds transaction\n    ///         and to make the necessary state changes. Moving funds is only\n    ///         accepted if it satisfies SPV proof.\n    ///\n    ///         The function validates the moving funds transaction structure\n    ///         by checking if it actually spends the main UTXO of the declared\n    ///         wallet and locks the value on the pre-committed target wallets\n    ///         using a reasonable transaction fee. If all preconditions are\n    ///         met, this functions closes the source wallet.\n    ///\n    ///         It is possible to prove the given moving funds transaction only\n    ///         one time.\n    /// @param movingFundsTx Bitcoin moving funds transaction data.\n    /// @param movingFundsProof Bitcoin moving funds proof data.\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain.\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    ///        HASH160 over the compressed ECDSA public key) of the wallet\n    ///        which performed the moving funds transaction.\n    /// @dev Requirements:\n    ///      - `movingFundsTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash,\n    ///      - The `movingFundsTx` should represent a Bitcoin transaction with\n    ///        exactly 1 input that refers to the wallet's main UTXO. That\n    ///        transaction should have 1..n outputs corresponding to the\n    ///        pre-committed target wallets. Outputs must be ordered in the\n    ///        same way as their corresponding target wallets are ordered\n    ///        within the target wallets commitment,\n    ///      - `movingFundsProof` components must match the expected structure.\n    ///        See `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant,\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        Additionally, the recent main UTXO on Ethereum must be set,\n    ///      - `walletPubKeyHash` must be connected with the main UTXO used\n    ///        as transaction single input,\n    ///      - The wallet that `walletPubKeyHash` points to must be in the\n    ///        MovingFunds state,\n    ///      - The target wallets commitment must be submitted by the wallet\n    ///        that `walletPubKeyHash` points to,\n    ///      - The total Bitcoin transaction fee must be lesser or equal\n    ///        to `movingFundsTxMaxTotalFee` governable parameter.\n    function submitMovingFundsProof(\n        BitcoinTx.Info calldata movingFundsTx,\n        BitcoinTx.Proof calldata movingFundsProof,\n        BitcoinTx.UTXO calldata mainUtxo,\n        bytes20 walletPubKeyHash\n    ) external {\n        self.submitMovingFundsProof(\n            movingFundsTx,\n            movingFundsProof,\n            mainUtxo,\n            walletPubKeyHash\n        );\n    }\n\n    /// @notice Notifies about a timed out moving funds process. Terminates\n    ///         the wallet and slashes signing group members as a result.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet.\n    /// @param walletMembersIDs Identifiers of the wallet signing group members.\n    /// @dev Requirements:\n    ///      - The wallet must be in the MovingFunds state,\n    ///      - The moving funds timeout must be actually exceeded,\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract.\n    function notifyMovingFundsTimeout(\n        bytes20 walletPubKeyHash,\n        uint32[] calldata walletMembersIDs\n    ) external {\n        self.notifyMovingFundsTimeout(walletPubKeyHash, walletMembersIDs);\n    }\n\n    /// @notice Notifies about a moving funds wallet whose BTC balance is\n    ///         below the moving funds dust threshold. Ends the moving funds\n    ///         process and begins wallet closing immediately.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known\n    ///        on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - The wallet must be in the MovingFunds state,\n    ///      - The `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        If the wallet has no main UTXO, this parameter can be empty as it\n    ///        is ignored,\n    ///      - The wallet BTC balance must be below the moving funds threshold.\n    function notifyMovingFundsBelowDust(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata mainUtxo\n    ) external {\n        self.notifyMovingFundsBelowDust(walletPubKeyHash, mainUtxo);\n    }\n\n    /// @notice Used by the wallet to prove the BTC moved funds sweep\n    ///         transaction and to make the necessary state changes. Moved\n    ///         funds sweep is only accepted if it satisfies SPV proof.\n    ///\n    ///         The function validates the sweep transaction structure by\n    ///         checking if it actually spends the moved funds UTXO and the\n    ///         sweeping wallet's main UTXO (optionally), and if it locks the\n    ///         value on the sweeping wallet's 20-byte public key hash using a\n    ///         reasonable transaction fee. If all preconditions are\n    ///         met, this function updates the sweeping wallet main UTXO, thus\n    ///         their BTC balance.\n    ///\n    ///         It is possible to prove the given sweep transaction only\n    ///         one time.\n    /// @param sweepTx Bitcoin sweep funds transaction data.\n    /// @param sweepProof Bitcoin sweep funds proof data.\n    /// @param mainUtxo Data of the sweeping wallet's main UTXO, as currently\n    ///        known on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - `sweepTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash,\n    ///      - The `sweepTx` should represent a Bitcoin transaction with\n    ///        the first input pointing to a moved funds sweep request targeted\n    ///        to the wallet, and optionally, the second input pointing to the\n    ///        wallet's main UTXO, if the sweeping wallet has a main UTXO set.\n    ///        There should be only one output locking funds on the sweeping\n    ///        wallet 20-byte public key hash,\n    ///      - `sweepProof` components must match the expected structure.\n    ///        See `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant,\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the sweeping wallet, as currently known on the Ethereum chain.\n    ///        If there is no main UTXO, this parameter is ignored,\n    ///      - The sweeping wallet must be in the Live or MovingFunds state,\n    ///      - The total Bitcoin transaction fee must be lesser or equal\n    ///        to `movedFundsSweepTxMaxTotalFee` governable parameter.\n    function submitMovedFundsSweepProof(\n        BitcoinTx.Info calldata sweepTx,\n        BitcoinTx.Proof calldata sweepProof,\n        BitcoinTx.UTXO calldata mainUtxo\n    ) external {\n        self.submitMovedFundsSweepProof(sweepTx, sweepProof, mainUtxo);\n    }\n\n    /// @notice Notifies about a timed out moved funds sweep process. If the\n    ///         wallet is not terminated yet, that function terminates\n    ///         the wallet and slashes signing group members as a result.\n    ///         Marks the given sweep request as TimedOut.\n    /// @param movingFundsTxHash 32-byte hash of the moving funds transaction\n    ///        that caused the sweep request to be created.\n    /// @param movingFundsTxOutputIndex Index of the moving funds transaction\n    ///        output that is subject of the sweep request.\n    /// @param walletMembersIDs Identifiers of the wallet signing group members.\n    /// @dev Requirements:\n    ///      - The moved funds sweep request must be in the Pending state,\n    ///      - The moved funds sweep timeout must be actually exceeded,\n    ///      - The wallet must be either in the Live or MovingFunds or\n    ///        Terminated state,\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract.\n    function notifyMovedFundsSweepTimeout(\n        bytes32 movingFundsTxHash,\n        uint32 movingFundsTxOutputIndex,\n        uint32[] calldata walletMembersIDs\n    ) external {\n        self.notifyMovedFundsSweepTimeout(\n            movingFundsTxHash,\n            movingFundsTxOutputIndex,\n            walletMembersIDs\n        );\n    }\n\n    /// @notice Requests creation of a new wallet. This function just\n    ///         forms a request and the creation process is performed\n    ///         asynchronously. Once a wallet is created, the ECDSA Wallet\n    ///         Registry will notify this contract by calling the\n    ///         `__ecdsaWalletCreatedCallback` function.\n    /// @param activeWalletMainUtxo Data of the active wallet's main UTXO, as\n    ///        currently known on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - `activeWalletMainUtxo` components must point to the recent main\n    ///        UTXO of the given active wallet, as currently known on the\n    ///        Ethereum chain. If there is no active wallet at the moment, or\n    ///        the active wallet has no main UTXO, this parameter can be\n    ///        empty as it is ignored,\n    ///      - Wallet creation must not be in progress,\n    ///      - If the active wallet is set, one of the following\n    ///        conditions must be true:\n    ///        - The active wallet BTC balance is above the minimum threshold\n    ///          and the active wallet is old enough, i.e. the creation period\n    ///          was elapsed since its creation time,\n    ///        - The active wallet BTC balance is above the maximum threshold.\n    function requestNewWallet(BitcoinTx.UTXO calldata activeWalletMainUtxo)\n        external\n    {\n        self.requestNewWallet(activeWalletMainUtxo);\n    }\n\n    /// @notice A callback function that is called by the ECDSA Wallet Registry\n    ///         once a new ECDSA wallet is created.\n    /// @param ecdsaWalletID Wallet's unique identifier.\n    /// @param publicKeyX Wallet's public key's X coordinate.\n    /// @param publicKeyY Wallet's public key's Y coordinate.\n    /// @dev Requirements:\n    ///      - The only caller authorized to call this function is `registry`,\n    ///      - Given wallet data must not belong to an already registered wallet.\n    function __ecdsaWalletCreatedCallback(\n        bytes32 ecdsaWalletID,\n        bytes32 publicKeyX,\n        bytes32 publicKeyY\n    ) external override {\n        self.registerNewWallet(ecdsaWalletID, publicKeyX, publicKeyY);\n    }\n\n    /// @notice A callback function that is called by the ECDSA Wallet Registry\n    ///         once a wallet heartbeat failure is detected.\n    /// @param publicKeyX Wallet's public key's X coordinate.\n    /// @param publicKeyY Wallet's public key's Y coordinate.\n    /// @dev Requirements:\n    ///      - The only caller authorized to call this function is `registry`,\n    ///      - Wallet must be in Live state.\n    function __ecdsaWalletHeartbeatFailedCallback(\n        bytes32,\n        bytes32 publicKeyX,\n        bytes32 publicKeyY\n    ) external override {\n        self.notifyWalletHeartbeatFailed(publicKeyX, publicKeyY);\n    }\n\n    /// @notice Notifies that the wallet is either old enough or has too few\n    ///         satoshi left and qualifies to be closed.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet.\n    /// @param walletMainUtxo Data of the wallet's main UTXO, as currently\n    ///        known on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - Wallet must not be set as the current active wallet,\n    ///      - Wallet must exceed the wallet maximum age OR the wallet BTC\n    ///        balance must be lesser than the minimum threshold. If the latter\n    ///        case is true, the `walletMainUtxo` components must point to the\n    ///        recent main UTXO of the given wallet, as currently known on the\n    ///        Ethereum chain. If the wallet has no main UTXO, this parameter\n    ///        can be empty as it is ignored since the wallet balance is\n    ///        assumed to be zero,\n    ///      - Wallet must be in Live state.\n    function notifyCloseableWallet(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata walletMainUtxo\n    ) external {\n        self.notifyCloseableWallet(walletPubKeyHash, walletMainUtxo);\n    }\n\n    /// @notice Notifies about the end of the closing period for the given wallet.\n    ///         Closes the wallet ultimately and notifies the ECDSA registry\n    ///         about this fact.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet.\n    /// @dev Requirements:\n    ///      - The wallet must be in the Closing state,\n    ///      - The wallet closing period must have elapsed.\n    function notifyWalletClosingPeriodElapsed(bytes20 walletPubKeyHash)\n        external\n    {\n        self.notifyWalletClosingPeriodElapsed(walletPubKeyHash);\n    }\n\n    /// @notice Submits a fraud challenge indicating that a UTXO being under\n    ///         wallet control was unlocked by the wallet but was not used\n    ///         according to the protocol rules. That means the wallet signed\n    ///         a transaction input pointing to that UTXO and there is a unique\n    ///         sighash and signature pair associated with that input. This\n    ///         function uses those parameters to create a fraud accusation that\n    ///         proves a given transaction input unlocking the given UTXO was\n    ///         actually signed by the wallet. This function cannot determine\n    ///         whether the transaction was actually broadcast and the input was\n    ///         consumed in a fraudulent way so it just opens a challenge period\n    ///         during which the wallet can defeat the challenge by submitting\n    ///         proof of a transaction that consumes the given input according\n    ///         to protocol rules. To prevent spurious allegations, the caller\n    ///         must deposit ETH that is returned back upon justified fraud\n    ///         challenge or confiscated otherwise.\n    /// @param walletPublicKey The public key of the wallet in the uncompressed\n    ///        and unprefixed format (64 bytes).\n    /// @param preimageSha256 The hash that was generated by applying SHA-256\n    ///        one time over the preimage used during input signing. The preimage\n    ///        is a serialized subset of the transaction and its structure\n    ///        depends on the transaction input (see BIP-143 for reference).\n    ///        Notice that applying SHA-256 over the `preimageSha256` results\n    ///        in `sighash`.  The path from `preimage` to `sighash` looks like\n    ///        this:\n    ///        preimage -> (SHA-256) -> preimageSha256 -> (SHA-256) -> sighash.\n    /// @param signature Bitcoin signature in the R/S/V format.\n    /// @dev Requirements:\n    ///      - Wallet behind `walletPublicKey` must be in Live or MovingFunds\n    ///        or Closing state,\n    ///      - The challenger must send appropriate amount of ETH used as\n    ///        fraud challenge deposit,\n    ///      - The signature (represented by r, s and v) must be generated by\n    ///        the wallet behind `walletPubKey` during signing of `sighash`\n    ///        which was calculated from `preimageSha256`,\n    ///      - Wallet can be challenged for the given signature only once.\n    function submitFraudChallenge(\n        bytes calldata walletPublicKey,\n        bytes memory preimageSha256,\n        BitcoinTx.RSVSignature calldata signature\n    ) external payable {\n        self.submitFraudChallenge(walletPublicKey, preimageSha256, signature);\n    }\n\n    /// @notice Allows to defeat a pending fraud challenge against a wallet if\n    ///         the transaction that spends the UTXO follows the protocol rules.\n    ///         In order to defeat the challenge the same `walletPublicKey` and\n    ///         signature (represented by `r`, `s` and `v`) must be provided as\n    ///         were used to calculate the sighash during input signing.\n    ///         The fraud challenge defeat attempt will only succeed if the\n    ///         inputs in the preimage are considered honestly spent by the\n    ///         wallet. Therefore the transaction spending the UTXO must be\n    ///         proven in the Bridge before a challenge defeat is called.\n    ///         If successfully defeated, the fraud challenge is marked as\n    ///         resolved and the amount of ether deposited by the challenger is\n    ///         sent to the treasury.\n    /// @param walletPublicKey The public key of the wallet in the uncompressed\n    ///        and unprefixed format (64 bytes).\n    /// @param preimage The preimage which produces sighash used to generate the\n    ///        ECDSA signature that is the subject of the fraud claim. It is a\n    ///        serialized subset of the transaction. The exact subset used as\n    ///        the preimage depends on the transaction input the signature is\n    ///        produced for. See BIP-143 for reference.\n    /// @param witness Flag indicating whether the preimage was produced for a\n    ///        witness input. True for witness, false for non-witness input.\n    /// @dev Requirements:\n    ///      - `walletPublicKey` and `sighash` calculated as `hash256(preimage)`\n    ///        must identify an open fraud challenge,\n    ///      - the preimage must be a valid preimage of a transaction generated\n    ///        according to the protocol rules and already proved in the Bridge,\n    ///      - before a defeat attempt is made the transaction that spends the\n    ///        given UTXO must be proven in the Bridge.\n    function defeatFraudChallenge(\n        bytes calldata walletPublicKey,\n        bytes calldata preimage,\n        bool witness\n    ) external {\n        self.defeatFraudChallenge(walletPublicKey, preimage, witness);\n    }\n\n    /// @notice Allows to defeat a pending fraud challenge against a wallet by\n    ///         proving the sighash and signature were produced for an off-chain\n    ///         wallet heartbeat message following a strict format.\n    ///         In order to defeat the challenge the same `walletPublicKey` and\n    ///         signature (represented by `r`, `s` and `v`) must be provided as\n    ///         were used to calculate the sighash during heartbeat message\n    ///         signing. The fraud challenge defeat attempt will only succeed if\n    ///         the signed message follows a strict format required for\n    ///         heartbeat messages. If successfully defeated, the fraud\n    ///         challenge is marked as resolved and the amount of ether\n    ///         deposited by the challenger is sent to the treasury.\n    /// @param walletPublicKey The public key of the wallet in the uncompressed\n    ///        and unprefixed format (64 bytes).\n    /// @param heartbeatMessage Off-chain heartbeat message meeting the heartbeat\n    ///        message format requirements which produces sighash used to\n    ///        generate the ECDSA signature that is the subject of the fraud\n    ///        claim.\n    /// @dev Requirements:\n    ///      - `walletPublicKey` and `sighash` calculated as\n    ///        `hash256(heartbeatMessage)` must identify an open fraud challenge,\n    ///      - `heartbeatMessage` must follow a strict format of heartbeat\n    ///        messages.\n    function defeatFraudChallengeWithHeartbeat(\n        bytes calldata walletPublicKey,\n        bytes calldata heartbeatMessage\n    ) external {\n        self.defeatFraudChallengeWithHeartbeat(\n            walletPublicKey,\n            heartbeatMessage\n        );\n    }\n\n    /// @notice Notifies about defeat timeout for the given fraud challenge.\n    ///         Can be called only if there was a fraud challenge identified by\n    ///         the provided `walletPublicKey` and `sighash` and it was not\n    ///         defeated on time. The amount of time that needs to pass after\n    ///         a fraud challenge is reported is indicated by the\n    ///         `challengeDefeatTimeout`. After a successful fraud challenge\n    ///         defeat timeout notification the fraud challenge is marked as\n    ///         resolved, the stake of each operator is slashed, the ether\n    ///         deposited is returned to the challenger and the challenger is\n    ///         rewarded.\n    /// @param walletPublicKey The public key of the wallet in the uncompressed\n    ///        and unprefixed format (64 bytes).\n    /// @param walletMembersIDs Identifiers of the wallet signing group members.\n    /// @param preimageSha256 The hash that was generated by applying SHA-256\n    ///        one time over the preimage used during input signing. The preimage\n    ///        is a serialized subset of the transaction and its structure\n    ///        depends on the transaction input (see BIP-143 for reference).\n    ///        Notice that applying SHA-256 over the `preimageSha256` results\n    ///        in `sighash`.  The path from `preimage` to `sighash` looks like\n    ///        this:\n    ///        preimage -> (SHA-256) -> preimageSha256 -> (SHA-256) -> sighash.\n    /// @dev Requirements:\n    ///      - The wallet must be in the Live or MovingFunds or Closing or\n    ///        Terminated state,\n    ///      - The `walletPublicKey` and `sighash` calculated from\n    ///        `preimageSha256` must identify an open fraud challenge,\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract,\n    ///      - The amount of time indicated by `challengeDefeatTimeout` must pass\n    ///        after the challenge was reported.\n    function notifyFraudChallengeDefeatTimeout(\n        bytes calldata walletPublicKey,\n        uint32[] calldata walletMembersIDs,\n        bytes memory preimageSha256\n    ) external {\n        self.notifyFraudChallengeDefeatTimeout(\n            walletPublicKey,\n            walletMembersIDs,\n            preimageSha256\n        );\n    }\n\n    /// @notice Allows the Governance to mark the given vault address as trusted\n    ///         or no longer trusted. Vaults are not trusted by default.\n    ///         Trusted vault must meet the following criteria:\n    ///         - `IVault.receiveBalanceIncrease` must have a known, low gas\n    ///           cost,\n    ///         - `IVault.receiveBalanceIncrease` must never revert.\n    /// @dev Without restricting reveal only to trusted vaults, malicious\n    ///      vaults not meeting the criteria would be able to nuke sweep proof\n    ///      transactions executed by ECDSA wallet with  deposits routed to\n    ///      them.\n    /// @param vault The address of the vault.\n    /// @param isTrusted flag indicating whether the vault is trusted or not.\n    /// @dev Can only be called by the Governance.\n    function setVaultStatus(address vault, bool isTrusted)\n        external\n        onlyGovernance\n    {\n        self.isVaultTrusted[vault] = isTrusted;\n        emit VaultStatusUpdated(vault, isTrusted);\n    }\n\n    /// @notice Updates parameters of deposits.\n    /// @param depositDustThreshold New value of the deposit dust threshold in\n    ///        satoshis. It is the minimal amount that can be requested to\n    ////       deposit. Value of this parameter must take into account the value\n    ///        of `depositTreasuryFeeDivisor` and `depositTxMaxFee` parameters\n    ///        in order to make requests that can incur the treasury and\n    ///        transaction fee and still satisfy the depositor.\n    /// @param depositTreasuryFeeDivisor New value of the treasury fee divisor.\n    ///        It is the divisor used to compute the treasury fee taken from\n    ///        each deposit and transferred to the treasury upon sweep proof\n    ///        submission. That fee is computed as follows:\n    ///        `treasuryFee = depositedAmount / depositTreasuryFeeDivisor`\n    ///        For example, if the treasury fee needs to be 2% of each deposit,\n    ///        the `depositTreasuryFeeDivisor` should be set to `50`\n    ///        because `1/50 = 0.02 = 2%`.\n    /// @param depositTxMaxFee New value of the deposit tx max fee in satoshis.\n    ///        It is the maximum amount of BTC transaction fee that can\n    ///        be incurred by each swept deposit being part of the given sweep\n    ///        transaction. If the maximum BTC transaction fee is exceeded,\n    ///        such transaction is considered a fraud.\n    /// @dev Requirements:\n    ///      - Deposit dust threshold must be greater than zero,\n    ///      - Deposit treasury fee divisor must be greater than zero,\n    ///      - Deposit transaction max fee must be greater than zero.\n    function updateDepositParameters(\n        uint64 depositDustThreshold,\n        uint64 depositTreasuryFeeDivisor,\n        uint64 depositTxMaxFee\n    ) external onlyGovernance {\n        self.updateDepositParameters(\n            depositDustThreshold,\n            depositTreasuryFeeDivisor,\n            depositTxMaxFee\n        );\n    }\n\n    /// @notice Updates parameters of redemptions.\n    /// @param redemptionDustThreshold New value of the redemption dust\n    ///        threshold in satoshis. It is the minimal amount that can be\n    ///        requested for redemption. Value of this parameter must take into\n    ///        account the value of `redemptionTreasuryFeeDivisor` and\n    ///        `redemptionTxMaxFee` parameters in order to make requests that\n    ///        can incur the treasury and transaction fee and still satisfy the\n    ///        redeemer.\n    /// @param redemptionTreasuryFeeDivisor New value of the redemption\n    ///        treasury fee divisor. It is the divisor used to compute the\n    ///        treasury fee taken from each redemption request and transferred\n    ///        to the treasury upon successful request finalization. That fee is\n    ///        computed as follows:\n    ///        `treasuryFee = requestedAmount / redemptionTreasuryFeeDivisor`\n    ///        For example, if the treasury fee needs to be 2% of each\n    ///        redemption request, the `redemptionTreasuryFeeDivisor` should\n    ///        be set to `50` because `1/50 = 0.02 = 2%`.\n    /// @param redemptionTxMaxFee New value of the redemption transaction max\n    ///        fee in satoshis. It is the maximum amount of BTC transaction fee\n    ///        that can be incurred by each redemption request being part of the\n    ///        given redemption transaction. If the maximum BTC transaction fee\n    ///        is exceeded, such transaction is considered a fraud.\n    ///        This is a per-redemption output max fee for the redemption\n    ///        transaction.\n    /// @param redemptionTimeout New value of the redemption timeout in seconds.\n    ///        It is the time after which the redemption request can be reported\n    ///        as timed out. It is counted from the moment when the redemption\n    ///        request was created via `requestRedemption` call. Reported  timed\n    ///        out requests are cancelled and locked TBTC is returned to the\n    ///        redeemer in full amount.\n    /// @param redemptionTimeoutSlashingAmount New value of the redemption\n    ///        timeout slashing amount in T, it is the amount slashed from each\n    ///        wallet member for redemption timeout.\n    /// @param redemptionTimeoutNotifierRewardMultiplier New value of the\n    ///        redemption timeout notifier reward multiplier as percentage,\n    ///        it determines the percentage of the notifier reward from the\n    ///        staking contact the notifier of a redemption timeout receives.\n    ///        The value must be in the range [0, 100].\n    /// @dev Requirements:\n    ///      - Redemption dust threshold must be greater than moving funds dust\n    ///        threshold,\n    ///      - Redemption treasury fee divisor must be greater than zero,\n    ///      - Redemption transaction max fee must be greater than zero,\n    ///      - Redemption timeout must be greater than zero,\n    ///      - Redemption timeout notifier reward multiplier must be in the\n    ///        range [0, 100].\n    function updateRedemptionParameters(\n        uint64 redemptionDustThreshold,\n        uint64 redemptionTreasuryFeeDivisor,\n        uint64 redemptionTxMaxFee,\n        uint256 redemptionTimeout,\n        uint96 redemptionTimeoutSlashingAmount,\n        uint256 redemptionTimeoutNotifierRewardMultiplier\n    ) external onlyGovernance {\n        self.updateRedemptionParameters(\n            redemptionDustThreshold,\n            redemptionTreasuryFeeDivisor,\n            redemptionTxMaxFee,\n            redemptionTimeout,\n            redemptionTimeoutSlashingAmount,\n            redemptionTimeoutNotifierRewardMultiplier\n        );\n    }\n\n    /// @notice Updates parameters of moving funds.\n    /// @param movingFundsTxMaxTotalFee New value of the moving funds transaction\n    ///        max total fee in satoshis. It is the maximum amount of the total\n    ///        BTC transaction fee that is acceptable in a single moving funds\n    ///        transaction. This is a _total_ max fee for the entire moving\n    ///        funds transaction.\n    /// @param movingFundsDustThreshold New value of the moving funds dust\n    ///        threshold. It is the minimal satoshi amount that makes sense to\n    ///        be transferred during the moving funds process. Moving funds\n    ///        wallets having their BTC balance below that value can begin\n    ///        closing immediately as transferring such a low value may not be\n    ///        possible due to BTC network fees.\n    /// @param movingFundsTimeoutResetDelay New value of the moving funds\n    ///        timeout reset delay in seconds. It is the time after which the\n    ///        moving funds timeout can be reset in case the target wallet\n    ///        commitment cannot be submitted due to a lack of live wallets\n    ///        in the system. It is counted from the moment when the wallet\n    ///        was requested to move their funds and switched to the MovingFunds\n    ///        state or from the moment the timeout was reset the last time.\n    /// @param movingFundsTimeout New value of the moving funds timeout in\n    ///        seconds. It is the time after which the moving funds process can\n    ///        be reported as timed out. It is counted from the moment when the\n    ///        wallet was requested to move their funds and switched to the\n    ///        MovingFunds state.\n    /// @param movingFundsTimeoutSlashingAmount New value of the moving funds\n    ///        timeout slashing amount in T, it is the amount slashed from each\n    ///        wallet member for moving funds timeout.\n    /// @param movingFundsTimeoutNotifierRewardMultiplier New value of the\n    ///        moving funds timeout notifier reward multiplier as percentage,\n    ///        it determines the percentage of the notifier reward from the\n    ///        staking contact the notifier of a moving funds timeout receives.\n    ///        The value must be in the range [0, 100].\n    /// @param movedFundsSweepTxMaxTotalFee New value of the moved funds sweep\n    ///        transaction max total fee in satoshis. It is the maximum amount\n    ///        of the total BTC transaction fee that is acceptable in a single\n    ///        moved funds sweep transaction. This is a _total_ max fee for the\n    ///        entire moved funds sweep transaction.\n    /// @param movedFundsSweepTimeout New value of the moved funds sweep\n    ///        timeout in seconds. It is the time after which the moved funds\n    ///        sweep process can be reported as timed out. It is counted from\n    ///        the moment when the wallet was requested to sweep the received\n    ///        funds.\n    /// @param movedFundsSweepTimeoutSlashingAmount New value of the moved\n    ///        funds sweep timeout slashing amount in T, it is the amount\n    ///        slashed from each wallet member for moved funds sweep timeout.\n    /// @param movedFundsSweepTimeoutNotifierRewardMultiplier New value of\n    ///        the moved funds sweep timeout notifier reward multiplier as\n    ///        percentage, it determines the percentage of the notifier reward\n    ///        from the staking contact the notifier of a moved funds sweep\n    ///        timeout receives. The value must be in the range [0, 100].\n    /// @dev Requirements:\n    ///      - Moving funds transaction max total fee must be greater than zero,\n    ///      - Moving funds dust threshold must be greater than zero and lower\n    ///        than the redemption dust threshold,\n    ///      - Moving funds timeout reset delay must be greater than zero,\n    ///      - Moving funds timeout must be greater than the moving funds\n    ///        timeout reset delay,\n    ///      - Moving funds timeout notifier reward multiplier must be in the\n    ///        range [0, 100],\n    ///      - Moved funds sweep transaction max total fee must be greater than zero,\n    ///      - Moved funds sweep timeout must be greater than zero,\n    ///      - Moved funds sweep timeout notifier reward multiplier must be in the\n    ///        range [0, 100].\n    function updateMovingFundsParameters(\n        uint64 movingFundsTxMaxTotalFee,\n        uint64 movingFundsDustThreshold,\n        uint32 movingFundsTimeoutResetDelay,\n        uint32 movingFundsTimeout,\n        uint96 movingFundsTimeoutSlashingAmount,\n        uint256 movingFundsTimeoutNotifierRewardMultiplier,\n        uint64 movedFundsSweepTxMaxTotalFee,\n        uint32 movedFundsSweepTimeout,\n        uint96 movedFundsSweepTimeoutSlashingAmount,\n        uint256 movedFundsSweepTimeoutNotifierRewardMultiplier\n    ) external onlyGovernance {\n        self.updateMovingFundsParameters(\n            movingFundsTxMaxTotalFee,\n            movingFundsDustThreshold,\n            movingFundsTimeoutResetDelay,\n            movingFundsTimeout,\n            movingFundsTimeoutSlashingAmount,\n            movingFundsTimeoutNotifierRewardMultiplier,\n            movedFundsSweepTxMaxTotalFee,\n            movedFundsSweepTimeout,\n            movedFundsSweepTimeoutSlashingAmount,\n            movedFundsSweepTimeoutNotifierRewardMultiplier\n        );\n    }\n\n    /// @notice Updates parameters of wallets.\n    /// @param walletCreationPeriod New value of the wallet creation period in\n    ///        seconds, determines how frequently a new wallet creation can be\n    ///        requested.\n    /// @param walletCreationMinBtcBalance New value of the wallet minimum BTC\n    ///        balance in satoshi, used to decide about wallet creation.\n    /// @param walletCreationMaxBtcBalance New value of the wallet maximum BTC\n    ///        balance in satoshi, used to decide about wallet creation.\n    /// @param walletClosureMinBtcBalance New value of the wallet minimum BTC\n    ///        balance in satoshi, used to decide about wallet closure.\n    /// @param walletMaxAge New value of the wallet maximum age in seconds,\n    ///        indicates the maximum age of a wallet in seconds, after which\n    ///        the wallet moving funds process can be requested.\n    /// @param walletMaxBtcTransfer New value of the wallet maximum BTC transfer\n    ///        in satoshi, determines the maximum amount that can be transferred\n    //         to a single target wallet during the moving funds process.\n    /// @param walletClosingPeriod New value of the wallet closing period in\n    ///        seconds, determines the length of the wallet closing period,\n    //         i.e. the period when the wallet remains in the Closing state\n    //         and can be subject of deposit fraud challenges.\n    /// @dev Requirements:\n    ///      - Wallet minimum BTC balance must be greater than zero,\n    ///      - Wallet maximum BTC balance must be greater than the wallet\n    ///        minimum BTC balance,\n    ///      - Wallet maximum BTC transfer must be greater than zero,\n    ///      - Wallet closing period must be greater than zero.\n    function updateWalletParameters(\n        uint32 walletCreationPeriod,\n        uint64 walletCreationMinBtcBalance,\n        uint64 walletCreationMaxBtcBalance,\n        uint64 walletClosureMinBtcBalance,\n        uint32 walletMaxAge,\n        uint64 walletMaxBtcTransfer,\n        uint32 walletClosingPeriod\n    ) external onlyGovernance {\n        self.updateWalletParameters(\n            walletCreationPeriod,\n            walletCreationMinBtcBalance,\n            walletCreationMaxBtcBalance,\n            walletClosureMinBtcBalance,\n            walletMaxAge,\n            walletMaxBtcTransfer,\n            walletClosingPeriod\n        );\n    }\n\n    /// @notice Updates parameters related to frauds.\n    /// @param fraudChallengeDepositAmount New value of the fraud challenge\n    ///        deposit amount in wei, it is the amount of ETH the party\n    ///        challenging the wallet for fraud needs to deposit.\n    /// @param fraudChallengeDefeatTimeout New value of the challenge defeat\n    ///        timeout in seconds, it is the amount of time the wallet has to\n    ///        defeat a fraud challenge. The value must be greater than zero.\n    /// @param fraudSlashingAmount New value of the fraud slashing amount in T,\n    ///        it is the amount slashed from each wallet member for committing\n    ///        a fraud.\n    /// @param fraudNotifierRewardMultiplier New value of the fraud notifier\n    ///        reward multiplier as percentage, it determines the percentage of\n    ///        the notifier reward from the staking contact the notifier of\n    ///        a fraud receives. The value must be in the range [0, 100].\n    /// @dev Requirements:\n    ///      - Fraud challenge defeat timeout must be greater than 0,\n    ///      - Fraud notifier reward multiplier must be in the range [0, 100].\n    function updateFraudParameters(\n        uint256 fraudChallengeDepositAmount,\n        uint256 fraudChallengeDefeatTimeout,\n        uint96 fraudSlashingAmount,\n        uint256 fraudNotifierRewardMultiplier\n    ) external onlyGovernance {\n        self.updateFraudParameters(\n            fraudChallengeDepositAmount,\n            fraudChallengeDefeatTimeout,\n            fraudSlashingAmount,\n            fraudNotifierRewardMultiplier\n        );\n    }\n\n    /// @notice Collection of all revealed deposits indexed by\n    ///         keccak256(fundingTxHash | fundingOutputIndex).\n    ///         The fundingTxHash is bytes32 (ordered as in Bitcoin internally)\n    ///         and fundingOutputIndex an uint32. This mapping may contain valid\n    ///         and invalid deposits and the wallet is responsible for\n    ///         validating them before attempting to execute a sweep.\n    function deposits(uint256 depositKey)\n        external\n        view\n        returns (Deposit.DepositRequest memory)\n    {\n        return self.deposits[depositKey];\n    }\n\n    /// @notice Collection of all pending redemption requests indexed by\n    ///         redemption key built as\n    ///         keccak256(walletPubKeyHash | redeemerOutputScript). The\n    ///         walletPubKeyHash is the 20-byte wallet's public key hash\n    ///         (computed using Bitcoin HASH160 over the compressed ECDSA\n    ///         public key) and redeemerOutputScript is a Bitcoin script\n    ///         (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock\n    ///         redeemed BTC as requested by the redeemer. Requests are added\n    ///         to this mapping by the `requestRedemption` method (duplicates\n    ///         not allowed) and are removed by one of the following methods:\n    ///         - `submitRedemptionProof` in case the request was handled\n    ///           successfully,\n    ///         - `notifyRedemptionTimeout` in case the request was reported\n    ///           to be timed out.\n    function pendingRedemptions(uint256 redemptionKey)\n        external\n        view\n        returns (Redemption.RedemptionRequest memory)\n    {\n        return self.pendingRedemptions[redemptionKey];\n    }\n\n    /// @notice Collection of all timed out redemptions requests indexed by\n    ///         redemption key built as\n    ///         keccak256(walletPubKeyHash | redeemerOutputScript). The\n    ///         walletPubKeyHash is the 20-byte wallet's public key hash\n    ///         (computed using Bitcoin HASH160 over the compressed ECDSA\n    ///         public key) and redeemerOutputScript is the Bitcoin script\n    ///         (P2PKH, P2WPKH, P2SH or P2WSH) that is involved in the timed\n    ///         out request. Timed out requests are stored in this mapping to\n    ///         avoid slashing the wallets multiple times for the same timeout.\n    ///         Only one method can add to this mapping:\n    ///         - `notifyRedemptionTimeout` which puts the redemption key\n    ///           to this mapping basing on a timed out request stored\n    ///           previously in `pendingRedemptions` mapping.\n    function timedOutRedemptions(uint256 redemptionKey)\n        external\n        view\n        returns (Redemption.RedemptionRequest memory)\n    {\n        return self.timedOutRedemptions[redemptionKey];\n    }\n\n    /// @notice Collection of main UTXOs that are honestly spent indexed by\n    ///         keccak256(fundingTxHash | fundingOutputIndex). The fundingTxHash\n    ///         is bytes32 (ordered as in Bitcoin internally) and\n    ///         fundingOutputIndex an uint32. A main UTXO is considered honestly\n    ///         spent if it was used as an input of a transaction that have been\n    ///         proven in the Bridge.\n    function spentMainUTXOs(uint256 utxoKey) external view returns (bool) {\n        return self.spentMainUTXOs[utxoKey];\n    }\n\n    /// @notice Gets details about a registered wallet.\n    /// @param walletPubKeyHash The 20-byte wallet public key hash (computed\n    ///        using Bitcoin HASH160 over the compressed ECDSA public key).\n    /// @return Wallet details.\n    function wallets(bytes20 walletPubKeyHash)\n        external\n        view\n        returns (Wallets.Wallet memory)\n    {\n        return self.registeredWallets[walletPubKeyHash];\n    }\n\n    /// @notice Gets the public key hash of the active wallet.\n    /// @return The 20-byte public key hash (computed using Bitcoin HASH160\n    ///         over the compressed ECDSA public key) of the active wallet.\n    ///         Returns bytes20(0) if there is no active wallet at the moment.\n    function activeWalletPubKeyHash() external view returns (bytes20) {\n        return self.activeWalletPubKeyHash;\n    }\n\n    /// @notice Gets the live wallets count.\n    /// @return The current count of wallets being in the Live state.\n    function liveWalletsCount() external view returns (uint32) {\n        return self.liveWalletsCount;\n    }\n\n    /// @notice Returns the fraud challenge identified by the given key built\n    ///         as keccak256(walletPublicKey|sighash).\n    function fraudChallenges(uint256 challengeKey)\n        external\n        view\n        returns (Fraud.FraudChallenge memory)\n    {\n        return self.fraudChallenges[challengeKey];\n    }\n\n    /// @notice Collection of all moved funds sweep requests indexed by\n    ///         `keccak256(movingFundsTxHash | movingFundsOutputIndex)`.\n    ///         The `movingFundsTxHash` is `bytes32` (ordered as in Bitcoin\n    ///         internally) and `movingFundsOutputIndex` an `uint32`. Each entry\n    ///         is actually an UTXO representing the moved funds and is supposed\n    ///         to be swept with the current main UTXO of the recipient wallet.\n    /// @param requestKey Request key built as\n    ///        `keccak256(movingFundsTxHash | movingFundsOutputIndex)`.\n    /// @return Details of the moved funds sweep request.\n    function movedFundsSweepRequests(uint256 requestKey)\n        external\n        view\n        returns (MovingFunds.MovedFundsSweepRequest memory)\n    {\n        return self.movedFundsSweepRequests[requestKey];\n    }\n\n    /// @notice Indicates if the vault with the given address is trusted or not.\n    ///         Depositors can route their revealed deposits only to trusted\n    ///         vaults and have trusted vaults notified about new deposits as\n    ///         soon as these deposits get swept. Vaults not trusted by the\n    ///         Bridge can still be used by Bank balance owners on their own\n    ///         responsibility - anyone can approve their Bank balance to any\n    ///         address.\n    function isVaultTrusted(address vault) external view returns (bool) {\n        return self.isVaultTrusted[vault];\n    }\n\n    /// @notice Returns the current values of Bridge deposit parameters.\n    /// @return depositDustThreshold The minimal amount that can be requested\n    ///         to deposit. Value of this parameter must take into account the\n    ///         value of `depositTreasuryFeeDivisor` and `depositTxMaxFee`\n    ///         parameters in order to make requests that can incur the\n    ///         treasury and transaction fee and still satisfy the depositor.\n    /// @return depositTreasuryFeeDivisor Divisor used to compute the treasury\n    ///         fee taken from each deposit and transferred to the treasury upon\n    ///         sweep proof submission. That fee is computed as follows:\n    ///         `treasuryFee = depositedAmount / depositTreasuryFeeDivisor`\n    ///         For example, if the treasury fee needs to be 2% of each deposit,\n    ///         the `depositTreasuryFeeDivisor` should be set to `50`\n    ///         because `1/50 = 0.02 = 2%`.\n    /// @return depositTxMaxFee Maximum amount of BTC transaction fee that can\n    ///         be incurred by each swept deposit being part of the given sweep\n    ///         transaction. If the maximum BTC transaction fee is exceeded,\n    ///         such transaction is considered a fraud.\n    function depositParameters()\n        external\n        view\n        returns (\n            uint64 depositDustThreshold,\n            uint64 depositTreasuryFeeDivisor,\n            uint64 depositTxMaxFee\n        )\n    {\n        depositDustThreshold = self.depositDustThreshold;\n        depositTreasuryFeeDivisor = self.depositTreasuryFeeDivisor;\n        depositTxMaxFee = self.depositTxMaxFee;\n    }\n\n    /// @notice Returns the current values of Bridge redemption parameters.\n    /// @return redemptionDustThreshold The minimal amount that can be requested\n    ///         for redemption. Value of this parameter must take into account\n    ///         the value of `redemptionTreasuryFeeDivisor` and `redemptionTxMaxFee`\n    ///         parameters in order to make requests that can incur the\n    ///         treasury and transaction fee and still satisfy the redeemer.\n    /// @return redemptionTreasuryFeeDivisor Divisor used to compute the treasury\n    ///         fee taken from each redemption request and transferred to the\n    ///         treasury upon successful request finalization. That fee is\n    ///         computed as follows:\n    ///         `treasuryFee = requestedAmount / redemptionTreasuryFeeDivisor`\n    ///         For example, if the treasury fee needs to be 2% of each\n    ///         redemption request, the `redemptionTreasuryFeeDivisor` should\n    ///         be set to `50` because `1/50 = 0.02 = 2%`.\n    /// @return redemptionTxMaxFee Maximum amount of BTC transaction fee that\n    ///         can be incurred by each redemption request being part of the\n    ///         given redemption transaction. If the maximum BTC transaction\n    ///         fee is exceeded, such transaction is considered a fraud.\n    ///         This is a per-redemption output max fee for the redemption\n    ///         transaction.\n    /// @return redemptionTimeout Time after which the redemption request can be\n    ///         reported as timed out. It is counted from the moment when the\n    ///         redemption request was created via `requestRedemption` call.\n    ///         Reported  timed out requests are cancelled and locked TBTC is\n    ///         returned to the redeemer in full amount.\n    /// @return redemptionTimeoutSlashingAmount The amount of stake slashed\n    ///         from each member of a wallet for a redemption timeout.\n    /// @return redemptionTimeoutNotifierRewardMultiplier The percentage of the\n    ///         notifier reward from the staking contract the notifier of a\n    ///         redemption timeout receives. The value is in the range [0, 100].\n    function redemptionParameters()\n        external\n        view\n        returns (\n            uint64 redemptionDustThreshold,\n            uint64 redemptionTreasuryFeeDivisor,\n            uint64 redemptionTxMaxFee,\n            uint256 redemptionTimeout,\n            uint96 redemptionTimeoutSlashingAmount,\n            uint256 redemptionTimeoutNotifierRewardMultiplier\n        )\n    {\n        redemptionDustThreshold = self.redemptionDustThreshold;\n        redemptionTreasuryFeeDivisor = self.redemptionTreasuryFeeDivisor;\n        redemptionTxMaxFee = self.redemptionTxMaxFee;\n        redemptionTimeout = self.redemptionTimeout;\n        redemptionTimeoutSlashingAmount = self.redemptionTimeoutSlashingAmount;\n        redemptionTimeoutNotifierRewardMultiplier = self\n            .redemptionTimeoutNotifierRewardMultiplier;\n    }\n\n    /// @notice Returns the current values of Bridge moving funds between\n    ///         wallets parameters.\n    /// @return movingFundsTxMaxTotalFee Maximum amount of the total BTC\n    ///         transaction fee that is acceptable in a single moving funds\n    ///         transaction. This is a _total_ max fee for the entire moving\n    ///         funds transaction.\n    /// @return movingFundsDustThreshold The minimal satoshi amount that makes\n    ///         sense to be transferred during the moving funds process. Moving\n    ///         funds wallets having their BTC balance below that value can\n    ///         begin closing immediately as transferring such a low value may\n    ///         not be possible due to BTC network fees.\n    /// @return movingFundsTimeoutResetDelay Time after which the moving funds\n    ///         timeout can be reset in case the target wallet commitment\n    ///         cannot be submitted due to a lack of live wallets in the system.\n    ///         It is counted from the moment when the wallet was requested to\n    ///         move their funds and switched to the MovingFunds state or from\n    ///         the moment the timeout was reset the last time. Value in seconds\n    ///         This value should be lower than the value of the\n    ///         `movingFundsTimeout`.\n    /// @return movingFundsTimeout Time after which the moving funds process\n    ///         can be reported as timed out. It is counted from the moment\n    ///         when the wallet was requested to move their funds and switched\n    ///         to the MovingFunds state. Value in seconds.\n    /// @return movingFundsTimeoutSlashingAmount The amount of stake slashed\n    ///         from each member of a wallet for a moving funds timeout.\n    /// @return movingFundsTimeoutNotifierRewardMultiplier The percentage of the\n    ///         notifier reward from the staking contract the notifier of a\n    ///         moving funds timeout receives. The value is in the range [0, 100].\n    /// @return movedFundsSweepTxMaxTotalFee Maximum amount of the total BTC\n    ///         transaction fee that is acceptable in a single moved funds\n    ///         sweep transaction. This is a _total_ max fee for the entire\n    ///         moved funds sweep transaction.\n    /// @return movedFundsSweepTimeout Time after which the moved funds sweep\n    ///         process can be reported as timed out. It is counted from the\n    ///         moment when the wallet was requested to sweep the received funds.\n    ///         Value in seconds.\n    /// @return movedFundsSweepTimeoutSlashingAmount The amount of stake slashed\n    ///         from each member of a wallet for a moved funds sweep timeout.\n    /// @return movedFundsSweepTimeoutNotifierRewardMultiplier The percentage\n    ///         of the notifier reward from the staking contract the notifier\n    ///         of a moved funds sweep timeout receives. The value is in the\n    ///         range [0, 100].\n    function movingFundsParameters()\n        external\n        view\n        returns (\n            uint64 movingFundsTxMaxTotalFee,\n            uint64 movingFundsDustThreshold,\n            uint32 movingFundsTimeoutResetDelay,\n            uint32 movingFundsTimeout,\n            uint96 movingFundsTimeoutSlashingAmount,\n            uint256 movingFundsTimeoutNotifierRewardMultiplier,\n            uint64 movedFundsSweepTxMaxTotalFee,\n            uint32 movedFundsSweepTimeout,\n            uint96 movedFundsSweepTimeoutSlashingAmount,\n            uint256 movedFundsSweepTimeoutNotifierRewardMultiplier\n        )\n    {\n        movingFundsTxMaxTotalFee = self.movingFundsTxMaxTotalFee;\n        movingFundsDustThreshold = self.movingFundsDustThreshold;\n        movingFundsTimeoutResetDelay = self.movingFundsTimeoutResetDelay;\n        movingFundsTimeout = self.movingFundsTimeout;\n        movingFundsTimeoutSlashingAmount = self\n            .movingFundsTimeoutSlashingAmount;\n        movingFundsTimeoutNotifierRewardMultiplier = self\n            .movingFundsTimeoutNotifierRewardMultiplier;\n        movedFundsSweepTxMaxTotalFee = self.movedFundsSweepTxMaxTotalFee;\n        movedFundsSweepTimeout = self.movedFundsSweepTimeout;\n        movedFundsSweepTimeoutSlashingAmount = self\n            .movedFundsSweepTimeoutSlashingAmount;\n        movedFundsSweepTimeoutNotifierRewardMultiplier = self\n            .movedFundsSweepTimeoutNotifierRewardMultiplier;\n    }\n\n    /// @return walletCreationPeriod Determines how frequently a new wallet\n    ///         creation can be requested. Value in seconds.\n    /// @return walletCreationMinBtcBalance The minimum BTC threshold in satoshi\n    ///         that is used to decide about wallet creation.\n    /// @return walletCreationMaxBtcBalance The maximum BTC threshold in satoshi\n    ///         that is used to decide about wallet creation.\n    /// @return walletClosureMinBtcBalance The minimum BTC threshold in satoshi\n    ///         that is used to decide about wallet closure.\n    /// @return walletMaxAge The maximum age of a wallet in seconds, after which\n    ///         the wallet moving funds process can be requested.\n    /// @return walletMaxBtcTransfer The maximum BTC amount in satoshi than\n    ///         can be transferred to a single target wallet during the moving\n    ///         funds process.\n    /// @return walletClosingPeriod Determines the length of the wallet closing\n    ///         period, i.e. the period when the wallet remains in the Closing\n    ///         state and can be subject of deposit fraud challenges. Value\n    ///         in seconds.\n    function walletParameters()\n        external\n        view\n        returns (\n            uint32 walletCreationPeriod,\n            uint64 walletCreationMinBtcBalance,\n            uint64 walletCreationMaxBtcBalance,\n            uint64 walletClosureMinBtcBalance,\n            uint32 walletMaxAge,\n            uint64 walletMaxBtcTransfer,\n            uint32 walletClosingPeriod\n        )\n    {\n        walletCreationPeriod = self.walletCreationPeriod;\n        walletCreationMinBtcBalance = self.walletCreationMinBtcBalance;\n        walletCreationMaxBtcBalance = self.walletCreationMaxBtcBalance;\n        walletClosureMinBtcBalance = self.walletClosureMinBtcBalance;\n        walletMaxAge = self.walletMaxAge;\n        walletMaxBtcTransfer = self.walletMaxBtcTransfer;\n        walletClosingPeriod = self.walletClosingPeriod;\n    }\n\n    /// @notice Returns the current values of Bridge fraud parameters.\n    /// @return fraudChallengeDepositAmount The amount of ETH in wei the party\n    ///         challenging the wallet for fraud needs to deposit.\n    /// @return fraudChallengeDefeatTimeout The amount of time the wallet has to\n    ///         defeat a fraud challenge.\n    /// @return fraudSlashingAmount The amount slashed from each wallet member\n    ///         for committing a fraud.\n    /// @return fraudNotifierRewardMultiplier The percentage of the notifier\n    ///         reward from the staking contract the notifier of a fraud\n    ///         receives. The value is in the range [0, 100].\n    function fraudParameters()\n        external\n        view\n        returns (\n            uint256 fraudChallengeDepositAmount,\n            uint256 fraudChallengeDefeatTimeout,\n            uint96 fraudSlashingAmount,\n            uint256 fraudNotifierRewardMultiplier\n        )\n    {\n        fraudChallengeDepositAmount = self.fraudChallengeDepositAmount;\n        fraudChallengeDefeatTimeout = self.fraudChallengeDefeatTimeout;\n        fraudSlashingAmount = self.fraudSlashingAmount;\n        fraudNotifierRewardMultiplier = self.fraudNotifierRewardMultiplier;\n    }\n\n    /// @notice Returns the addresses of contracts Bridge is interacting with.\n    /// @return bank Address of the Bank the Bridge belongs to.\n    /// @return relay Address of the Bitcoin relay providing the current Bitcoin\n    ///         network difficulty.\n    /// @return ecdsaWalletRegistry Address of the ECDSA Wallet Registry.\n    function contractReferences()\n        external\n        view\n        returns (\n            Bank bank,\n            IRelay relay,\n            EcdsaWalletRegistry ecdsaWalletRegistry\n        )\n    {\n        bank = self.bank;\n        relay = self.relay;\n        ecdsaWalletRegistry = self.ecdsaWalletRegistry;\n    }\n\n    /// @notice Address where the deposit treasury fees will be sent to.\n    ///         Treasury takes part in the operators rewarding process.\n    function treasury() external view returns (address) {\n        return self.treasury;\n    }\n\n    /// @notice The number of confirmations on the Bitcoin chain required to\n    ///         successfully evaluate an SPV proof.\n    function txProofDifficultyFactor() external view returns (uint256) {\n        return self.txProofDifficultyFactor;\n    }\n}\n"
+      "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\nimport \"@keep-network/random-beacon/contracts/Governable.sol\";\nimport {IWalletOwner as EcdsaWalletOwner} from \"@keep-network/ecdsa/contracts/api/IWalletOwner.sol\";\n\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/utils/math/SafeCastUpgradeable.sol\";\n\nimport \"./IRelay.sol\";\nimport \"./BridgeState.sol\";\nimport \"./Deposit.sol\";\nimport \"./DepositSweep.sol\";\nimport \"./Redemption.sol\";\nimport \"./BitcoinTx.sol\";\nimport \"./EcdsaLib.sol\";\nimport \"./Wallets.sol\";\nimport \"./Fraud.sol\";\nimport \"./MovingFunds.sol\";\n\nimport \"../bank/IReceiveBalanceApproval.sol\";\nimport \"../bank/Bank.sol\";\n\n/// @title Bitcoin Bridge\n/// @notice Bridge manages BTC deposit and redemption flow and is increasing and\n///         decreasing balances in the Bank as a result of BTC deposit and\n///         redemption operations performed by depositors and redeemers.\n///\n///         Depositors send BTC funds to the most recently created off-chain\n///         ECDSA wallet of the bridge using pay-to-script-hash (P2SH) or\n///         pay-to-witness-script-hash (P2WSH) containing hashed information\n///         about the depositor’s Ethereum address. Then, the depositor reveals\n///         their Ethereum address along with their deposit blinding factor,\n///         refund public key hash and refund locktime to the Bridge on Ethereum\n///         chain. The off-chain ECDSA wallet listens for these sorts of\n///         messages and when it gets one, it checks the Bitcoin network to make\n///         sure the deposit lines up. If it does, the off-chain ECDSA wallet\n///         may decide to pick the deposit transaction for sweeping, and when\n///         the sweep operation is confirmed on the Bitcoin network, the ECDSA\n///         wallet informs the Bridge about the sweep increasing appropriate\n///         balances in the Bank.\n/// @dev Bridge is an upgradeable component of the Bank. The order of\n///      functionalities in this contract is: deposit, sweep, redemption,\n///      moving funds, wallet lifecycle, frauds, parameters.\ncontract Bridge is\n    Governable,\n    EcdsaWalletOwner,\n    Initializable,\n    IReceiveBalanceApproval\n{\n    using BridgeState for BridgeState.Storage;\n    using Deposit for BridgeState.Storage;\n    using DepositSweep for BridgeState.Storage;\n    using Redemption for BridgeState.Storage;\n    using MovingFunds for BridgeState.Storage;\n    using Wallets for BridgeState.Storage;\n    using Fraud for BridgeState.Storage;\n\n    BridgeState.Storage internal self;\n\n    event DepositRevealed(\n        bytes32 fundingTxHash,\n        uint32 fundingOutputIndex,\n        address indexed depositor,\n        uint64 amount,\n        bytes8 blindingFactor,\n        bytes20 indexed walletPubKeyHash,\n        bytes20 refundPubKeyHash,\n        bytes4 refundLocktime,\n        address vault\n    );\n\n    event DepositsSwept(bytes20 walletPubKeyHash, bytes32 sweepTxHash);\n\n    event RedemptionRequested(\n        bytes20 indexed walletPubKeyHash,\n        bytes redeemerOutputScript,\n        address indexed redeemer,\n        uint64 requestedAmount,\n        uint64 treasuryFee,\n        uint64 txMaxFee\n    );\n\n    event RedemptionsCompleted(\n        bytes20 indexed walletPubKeyHash,\n        bytes32 redemptionTxHash\n    );\n\n    event RedemptionTimedOut(\n        bytes20 indexed walletPubKeyHash,\n        bytes redeemerOutputScript\n    );\n\n    event WalletMovingFunds(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event MovingFundsCommitmentSubmitted(\n        bytes20 indexed walletPubKeyHash,\n        bytes20[] targetWallets,\n        address submitter\n    );\n\n    event MovingFundsTimeoutReset(bytes20 indexed walletPubKeyHash);\n\n    event MovingFundsCompleted(\n        bytes20 indexed walletPubKeyHash,\n        bytes32 movingFundsTxHash\n    );\n\n    event MovingFundsTimedOut(bytes20 indexed walletPubKeyHash);\n\n    event MovingFundsBelowDustReported(bytes20 indexed walletPubKeyHash);\n\n    event MovedFundsSwept(\n        bytes20 indexed walletPubKeyHash,\n        bytes32 sweepTxHash\n    );\n\n    event MovedFundsSweepTimedOut(\n        bytes20 indexed walletPubKeyHash,\n        bytes32 movingFundsTxHash,\n        uint32 movingFundsTxOutputIndex\n    );\n\n    event NewWalletRequested();\n\n    event NewWalletRegistered(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletClosing(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletClosed(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletTerminated(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event FraudChallengeSubmitted(\n        bytes20 indexed walletPubKeyHash,\n        bytes32 sighash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    );\n\n    event FraudChallengeDefeated(\n        bytes20 indexed walletPubKeyHash,\n        bytes32 sighash\n    );\n\n    event FraudChallengeDefeatTimedOut(\n        bytes20 indexed walletPubKeyHash,\n        bytes32 sighash\n    );\n\n    event VaultStatusUpdated(address indexed vault, bool isTrusted);\n\n    event DepositParametersUpdated(\n        uint64 depositDustThreshold,\n        uint64 depositTreasuryFeeDivisor,\n        uint64 depositTxMaxFee\n    );\n\n    event RedemptionParametersUpdated(\n        uint64 redemptionDustThreshold,\n        uint64 redemptionTreasuryFeeDivisor,\n        uint64 redemptionTxMaxFee,\n        uint256 redemptionTimeout,\n        uint96 redemptionTimeoutSlashingAmount,\n        uint256 redemptionTimeoutNotifierRewardMultiplier\n    );\n\n    event MovingFundsParametersUpdated(\n        uint64 movingFundsTxMaxTotalFee,\n        uint64 movingFundsDustThreshold,\n        uint32 movingFundsTimeoutResetDelay,\n        uint32 movingFundsTimeout,\n        uint96 movingFundsTimeoutSlashingAmount,\n        uint256 movingFundsTimeoutNotifierRewardMultiplier,\n        uint64 movedFundsSweepTxMaxTotalFee,\n        uint32 movedFundsSweepTimeout,\n        uint96 movedFundsSweepTimeoutSlashingAmount,\n        uint256 movedFundsSweepTimeoutNotifierRewardMultiplier\n    );\n\n    event WalletParametersUpdated(\n        uint32 walletCreationPeriod,\n        uint64 walletCreationMinBtcBalance,\n        uint64 walletCreationMaxBtcBalance,\n        uint64 walletClosureMinBtcBalance,\n        uint32 walletMaxAge,\n        uint64 walletMaxBtcTransfer,\n        uint32 walletClosingPeriod\n    );\n\n    event FraudParametersUpdated(\n        uint256 fraudChallengeDepositAmount,\n        uint256 fraudChallengeDefeatTimeout,\n        uint96 fraudSlashingAmount,\n        uint256 fraudNotifierRewardMultiplier\n    );\n\n    /// @dev Initializes upgradable contract on deployment.\n    /// @param _bank Address of the Bank the Bridge belongs to.\n    /// @param _relay Address of the Bitcoin relay providing the current Bitcoin\n    ///        network difficulty.\n    /// @param _treasury Address where the deposit and redemption treasury fees\n    ///        will be sent to.\n    /// @param _ecdsaWalletRegistry Address of the ECDSA Wallet Registry contract.\n    /// @param _txProofDifficultyFactor The number of confirmations on the Bitcoin\n    ///        chain required to successfully evaluate an SPV proof.\n    function initialize(\n        address _bank,\n        address _relay,\n        address _treasury,\n        address _ecdsaWalletRegistry,\n        uint256 _txProofDifficultyFactor\n    ) external initializer {\n        require(_bank != address(0), \"Bank address cannot be zero\");\n        self.bank = Bank(_bank);\n\n        require(_relay != address(0), \"Relay address cannot be zero\");\n        self.relay = IRelay(_relay);\n\n        require(\n            _ecdsaWalletRegistry != address(0),\n            \"ECDSA Wallet Registry address cannot be zero\"\n        );\n        self.ecdsaWalletRegistry = EcdsaWalletRegistry(_ecdsaWalletRegistry);\n\n        require(_treasury != address(0), \"Treasury address cannot be zero\");\n        self.treasury = _treasury;\n\n        self.txProofDifficultyFactor = _txProofDifficultyFactor;\n\n        // TODO: Revisit initial values.\n        //       https://github.com/keep-network/tbtc-v2/issues/258\n        self.depositDustThreshold = 1000000; // 1000000 satoshi = 0.01 BTC\n        self.depositTxMaxFee = 10000; // 10000 satoshi\n        self.depositTreasuryFeeDivisor = 2000; // 1/2000 == 5bps == 0.05% == 0.0005\n        self.redemptionDustThreshold = 1000000; // 1000000 satoshi = 0.01 BTC\n        self.redemptionTreasuryFeeDivisor = 2000; // 1/2000 == 5bps == 0.05% == 0.0005\n        self.redemptionTxMaxFee = 10000; // 10000 satoshi\n        self.redemptionTimeout = 172800; // 48 hours\n        self.redemptionTimeoutSlashingAmount = 10000 * 1e18; // 10000 T\n        self.redemptionTimeoutNotifierRewardMultiplier = 100; // 100%\n        self.movingFundsTxMaxTotalFee = 10000; // 10000 satoshi\n        self.movingFundsDustThreshold = 20000; // 20000 satoshi\n        self.movingFundsTimeoutResetDelay = 6 days;\n        self.movingFundsTimeout = 7 days;\n        self.movingFundsTimeoutSlashingAmount = 10000 * 1e18; // 10000 T\n        self.movingFundsTimeoutNotifierRewardMultiplier = 100; //100%\n        self.movedFundsSweepTxMaxTotalFee = 10000; // 10000 satoshi\n        self.movedFundsSweepTimeout = 7 days;\n        self.movedFundsSweepTimeoutSlashingAmount = 10000 * 1e18; // 10000 T\n        self.movedFundsSweepTimeoutNotifierRewardMultiplier = 100; //100%\n        self.fraudChallengeDepositAmount = 2 ether;\n        self.fraudChallengeDefeatTimeout = 7 days;\n        self.fraudSlashingAmount = 10000 * 1e18; // 10000 T\n        self.fraudNotifierRewardMultiplier = 100; // 100%\n        self.walletCreationPeriod = 1 weeks;\n        self.walletCreationMinBtcBalance = 1e8; // 1 BTC\n        self.walletCreationMaxBtcBalance = 100e8; // 100 BTC\n        self.walletClosureMinBtcBalance = 5 * 1e7; // 0.5 BTC\n        self.walletMaxAge = 26 weeks; // ~6 months\n        self.walletMaxBtcTransfer = 10e8; // 10 BTC\n        self.walletClosingPeriod = 40 days;\n\n        _transferGovernance(msg.sender);\n    }\n\n    /// @notice Used by the depositor to reveal information about their P2(W)SH\n    ///         Bitcoin deposit to the Bridge on Ethereum chain. The off-chain\n    ///         wallet listens for revealed deposit events and may decide to\n    ///         include the revealed deposit in the next executed sweep.\n    ///         Information about the Bitcoin deposit can be revealed before or\n    ///         after the Bitcoin transaction with P2(W)SH deposit is mined on\n    ///         the Bitcoin chain. Worth noting, the gas cost of this function\n    ///         scales with the number of P2(W)SH transaction inputs and\n    ///         outputs. The deposit may be routed to one of the trusted vaults.\n    ///         When a deposit is routed to a vault, vault gets notified when\n    ///         the deposit gets swept and it may execute the appropriate action.\n    /// @param fundingTx Bitcoin funding transaction data, see `BitcoinTx.Info`.\n    /// @param reveal Deposit reveal data, see `RevealInfo struct.\n    /// @dev Requirements:\n    ///      - `reveal.walletPubKeyHash` must identify a `Live` wallet,\n    ///      - `reveal.vault` must be 0x0 or point to a trusted vault,\n    ///      - `reveal.fundingOutputIndex` must point to the actual P2(W)SH\n    ///        output of the BTC deposit transaction,\n    ///      - `reveal.depositor` must be the Ethereum address used in the\n    ///        P2(W)SH BTC deposit transaction,\n    ///      - `reveal.blindingFactor` must be the blinding factor used in the\n    ///        P2(W)SH BTC deposit transaction,\n    ///      - `reveal.walletPubKeyHash` must be the wallet pub key hash used in\n    ///        the P2(W)SH BTC deposit transaction,\n    ///      - `reveal.refundPubKeyHash` must be the refund pub key hash used in\n    ///        the P2(W)SH BTC deposit transaction,\n    ///      - `reveal.refundLocktime` must be the refund locktime used in the\n    ///        P2(W)SH BTC deposit transaction,\n    ///      - BTC deposit for the given `fundingTxHash`, `fundingOutputIndex`\n    ///        can be revealed only one time.\n    ///\n    ///      If any of these requirements is not met, the wallet _must_ refuse\n    ///      to sweep the deposit and the depositor has to wait until the\n    ///      deposit script unlocks to receive their BTC back.\n    function revealDeposit(\n        BitcoinTx.Info calldata fundingTx,\n        Deposit.DepositRevealInfo calldata reveal\n    ) external {\n        self.revealDeposit(fundingTx, reveal);\n    }\n\n    /// @notice Used by the wallet to prove the BTC deposit sweep transaction\n    ///         and to update Bank balances accordingly. Sweep is only accepted\n    ///         if it satisfies SPV proof.\n    ///\n    ///         The function is performing Bank balance updates by first\n    ///         computing the Bitcoin fee for the sweep transaction. The fee is\n    ///         divided evenly between all swept deposits. Each depositor\n    ///         receives a balance in the bank equal to the amount inferred\n    ///         during the reveal transaction, minus their fee share.\n    ///\n    ///         It is possible to prove the given sweep only one time.\n    /// @param sweepTx Bitcoin sweep transaction data.\n    /// @param sweepProof Bitcoin sweep proof data.\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain. If no main UTXO exists for the given wallet,\n    ///        this parameter is ignored.\n    /// @param vault Optional address of the vault where all swept deposits\n    ///        should be routed to. All deposits swept as part of the transaction\n    ///        must have their `vault` parameters set to the same address.\n    ///        If this parameter is set to an address of a trusted vault, swept\n    ///        deposits are routed to that vault.\n    ///        If this parameter is set to the zero address or to an address\n    ///        of a non-trusted vault, swept deposits are not routed to a\n    ///        vault but depositors' balances are increased in the Bank\n    ///        individually.\n    /// @dev Requirements:\n    ///      - `sweepTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash,\n    ///      - The `sweepTx` should represent a Bitcoin transaction with 1..n\n    ///        inputs. If the wallet has no main UTXO, all n inputs should\n    ///        correspond to P2(W)SH revealed deposits UTXOs. If the wallet has\n    ///        an existing main UTXO, one of the n inputs must point to that\n    ///        main UTXO and remaining n-1 inputs should correspond to P2(W)SH\n    ///        revealed deposits UTXOs. That transaction must have only\n    ///        one P2(W)PKH output locking funds on the 20-byte wallet public\n    ///        key hash,\n    ///      - All revealed deposits that are swept by `sweepTx` must have\n    ///        their `vault` parameters set to the same address as the address\n    ///        passed in the `vault` function parameter,\n    ///      - `sweepProof` components must match the expected structure. See\n    ///        `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant,\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        If there is no main UTXO, this parameter is ignored.\n    function submitDepositSweepProof(\n        BitcoinTx.Info calldata sweepTx,\n        BitcoinTx.Proof calldata sweepProof,\n        BitcoinTx.UTXO calldata mainUtxo,\n        address vault\n    ) external {\n        self.submitDepositSweepProof(sweepTx, sweepProof, mainUtxo, vault);\n    }\n\n    /// @notice Requests redemption of the given amount from the specified\n    ///         wallet to the redeemer Bitcoin output script. Handles the\n    ///         simplest case in which the redeemer's balance is decreased in\n    ///         the Bank.\n    /// @param walletPubKeyHash The 20-byte wallet public key hash (computed\n    ///        using Bitcoin HASH160 over the compressed ECDSA public key).\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain.\n    /// @param redeemerOutputScript The redeemer's length-prefixed output\n    ///        script (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock\n    ///        redeemed BTC.\n    /// @param amount Requested amount in satoshi. This is also the Bank balance\n    ///        that is taken from the `balanceOwner` upon request.\n    ///        Once the request is handled, the actual amount of BTC locked\n    ///        on the redeemer output script will be always lower than this value\n    ///        since the treasury and Bitcoin transaction fees must be incurred.\n    ///        The minimal amount satisfying the request can be computed as:\n    ///        `amount - (amount / redemptionTreasuryFeeDivisor) - redemptionTxMaxFee`.\n    ///        Fees values are taken at the moment of request creation.\n    /// @dev Requirements:\n    ///      - Wallet behind `walletPubKeyHash` must be live,\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain,\n    ///      - `redeemerOutputScript` must be a proper Bitcoin script,\n    ///      - `redeemerOutputScript` cannot have wallet PKH as payload,\n    ///      - `amount` must be above or equal the `redemptionDustThreshold`,\n    ///      - Given `walletPubKeyHash` and `redeemerOutputScript` pair can be\n    ///        used for only one pending request at the same time,\n    ///      - Wallet must have enough Bitcoin balance to proceed the request,\n    ///      - Redeemer must make an allowance in the Bank that the Bridge\n    ///        contract can spend the given `amount`.\n    function requestRedemption(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata mainUtxo,\n        bytes calldata redeemerOutputScript,\n        uint64 amount\n    ) external {\n        self.requestRedemption(\n            walletPubKeyHash,\n            mainUtxo,\n            msg.sender,\n            redeemerOutputScript,\n            amount\n        );\n    }\n\n    /// @notice Requests redemption of the given amount from the specified\n    ///         wallet to the redeemer Bitcoin output script. Used by\n    ///         `Bank.approveBalanceAndCall`. Can handle more complex cases\n    ///         where balance owner may be someone else than the redeemer.\n    ///         For example, vault redeeming its balance for some depositor.\n    /// @param balanceOwner The address of the Bank balance owner whose balance\n    ///        is getting redeemed.\n    /// @param amount Requested amount in satoshi. This is also the Bank balance\n    ///        that is taken from the `balanceOwner` upon request.\n    ///        Once the request is handled, the actual amount of BTC locked\n    ///        on the redeemer output script will be always lower than this value\n    ///        since the treasury and Bitcoin transaction fees must be incurred.\n    ///        The minimal amount satisfying the request can be computed as:\n    ///        `amount - (amount / redemptionTreasuryFeeDivisor) - redemptionTxMaxFee`.\n    ///        Fees values are taken at the moment of request creation.\n    /// @param redemptionData ABI-encoded redemption data:\n    ///        [\n    ///          address redeemer,\n    ///          bytes20 walletPubKeyHash,\n    ///          bytes32 mainUtxoTxHash,\n    ///          uint32 mainUtxoTxOutputIndex,\n    ///          uint64 mainUtxoTxOutputValue,\n    ///          bytes redeemerOutputScript\n    ///        ]\n    ///\n    ///        - redeemer: The Ethereum address of the redeemer who will be able\n    ///        to claim Bank balance if anything goes wrong during the redemption.\n    ///        In the most basic case, when someone redeems their balance\n    ///        from the Bank, `balanceOwner` is the same as `redemeer`.\n    ///        However, when a Vault is redeeming part of its balance for some\n    ///        redeemer address (for example, someone who has earlier deposited\n    ///        into that Vault), `balanceOwner` is the Vault, and `redemeer` is\n    ///        the address for which the vault is redeeming its balance to,\n    ///        - walletPubKeyHash: The 20-byte wallet public key hash (computed\n    ///        using Bitcoin HASH160 over the compressed ECDSA public key),\n    ///        - mainUtxoTxHash: Data of the wallet's main UTXO TX hash, as\n    ///        currently known on the Ethereum chain,\n    ///        - mainUtxoTxOutputIndex: Data of the wallet's main UTXO output\n    ///        index, as currently known on Ethereum chain,\n    ///        - mainUtxoTxOutputValue: Data of the wallet's main UTXO output\n    ///        value, as currently known on Ethereum chain,\n    ///        - redeemerOutputScript The redeemer's length-prefixed output\n    ///        script (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock\n    ///        redeemed BTC.\n    /// @dev Requirements:\n    ///      - The caller must be the Bank,\n    ///      - Wallet behind `walletPubKeyHash` must be live,\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain,\n    ///      - `redeemerOutputScript` must be a proper Bitcoin script,\n    ///      - `redeemerOutputScript` cannot have wallet PKH as payload,\n    ///      - `amount` must be above or equal the `redemptionDustThreshold`,\n    ///      - Given `walletPubKeyHash` and `redeemerOutputScript` pair can be\n    ///        used for only one pending request at the same time,\n    ///      - Wallet must have enough Bitcoin balance to proceed the request,\n    function receiveBalanceApproval(\n        address balanceOwner,\n        uint256 amount,\n        bytes calldata redemptionData\n    ) external override {\n        require(msg.sender == address(self.bank), \"Caller is not the bank\");\n\n        self.requestRedemption(\n            balanceOwner,\n            SafeCastUpgradeable.toUint64(amount),\n            redemptionData\n        );\n    }\n\n    /// @notice Used by the wallet to prove the BTC redemption transaction\n    ///         and to make the necessary bookkeeping. Redemption is only\n    ///         accepted if it satisfies SPV proof.\n    ///\n    ///         The function is performing Bank balance updates by burning\n    ///         the total redeemed Bitcoin amount from Bridge balance and\n    ///         transferring the treasury fee sum to the treasury address.\n    ///\n    ///         It is possible to prove the given redemption only one time.\n    /// @param redemptionTx Bitcoin redemption transaction data.\n    /// @param redemptionProof Bitcoin redemption proof data.\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain.\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    ///        HASH160 over the compressed ECDSA public key) of the wallet which\n    ///        performed the redemption transaction.\n    /// @dev Requirements:\n    ///      - `redemptionTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash,\n    ///      - The `redemptionTx` should represent a Bitcoin transaction with\n    ///        exactly 1 input that refers to the wallet's main UTXO. That\n    ///        transaction should have 1..n outputs handling existing pending\n    ///        redemption requests or pointing to reported timed out requests.\n    ///        There can be also 1 optional output representing the\n    ///        change and pointing back to the 20-byte wallet public key hash.\n    ///        The change should be always present if the redeemed value sum\n    ///        is lower than the total wallet's BTC balance,\n    ///      - `redemptionProof` components must match the expected structure.\n    ///        See `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant,\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        Additionally, the recent main UTXO on Ethereum must be set,\n    ///      - `walletPubKeyHash` must be connected with the main UTXO used\n    ///        as transaction single input.\n    ///      Other remarks:\n    ///      - Putting the change output as the first transaction output can\n    ///        save some gas because the output processing loop begins each\n    ///        iteration by checking whether the given output is the change\n    ///        thus uses some gas for making the comparison. Once the change\n    ///        is identified, that check is omitted in further iterations.\n    function submitRedemptionProof(\n        BitcoinTx.Info calldata redemptionTx,\n        BitcoinTx.Proof calldata redemptionProof,\n        BitcoinTx.UTXO calldata mainUtxo,\n        bytes20 walletPubKeyHash\n    ) external {\n        self.submitRedemptionProof(\n            redemptionTx,\n            redemptionProof,\n            mainUtxo,\n            walletPubKeyHash\n        );\n    }\n\n    /// @notice Notifies that there is a pending redemption request associated\n    ///         with the given wallet, that has timed out. The redemption\n    ///         request is identified by the key built as\n    ///         `keccak256(walletPubKeyHash | redeemerOutputScript)`.\n    ///         The results of calling this function:\n    ///         - The pending redemptions value for the wallet will be decreased\n    ///           by the requested amount (minus treasury fee),\n    ///         - The tokens taken from the redeemer on redemption request will\n    ///           be returned to the redeemer,\n    ///         - The request will be moved from pending redemptions to\n    ///           timed-out redemptions,\n    ///         - If the state of the wallet is `Live` or `MovingFunds`, the\n    ///           wallet operators will be slashed and the notifier will be\n    ///           rewarded,\n    ///         - If the state of wallet is `Live`, the wallet will be closed or\n    ///           marked as `MovingFunds` (depending on the presence or absence\n    ///           of the wallet's main UTXO) and the wallet will no longer be\n    ///           marked as the active wallet (if it was marked as such).\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet.\n    /// @param walletMembersIDs Identifiers of the wallet signing group members.\n    /// @param redeemerOutputScript  The redeemer's length-prefixed output\n    ///        script (P2PKH, P2WPKH, P2SH or P2WSH).\n    /// @dev Requirements:\n    ///      - The wallet must be in the Live or MovingFunds or Terminated state,\n    ///      - The redemption request identified by `walletPubKeyHash` and\n    ///        `redeemerOutputScript` must exist,\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract,\n    ///      - The amount of time defined by `redemptionTimeout` must have\n    ///        passed since the redemption was requested (the request must be\n    ///        timed-out).\n    function notifyRedemptionTimeout(\n        bytes20 walletPubKeyHash,\n        uint32[] calldata walletMembersIDs,\n        bytes calldata redeemerOutputScript\n    ) external {\n        self.notifyRedemptionTimeout(\n            walletPubKeyHash,\n            walletMembersIDs,\n            redeemerOutputScript\n        );\n    }\n\n    /// @notice Submits the moving funds target wallets commitment.\n    ///         Once all requirements are met, that function registers the\n    ///         target wallets commitment and opens the way for moving funds\n    ///         proof submission.\n    /// @param walletPubKeyHash 20-byte public key hash of the source wallet.\n    /// @param walletMainUtxo Data of the source wallet's main UTXO, as\n    ///        currently known on the Ethereum chain.\n    /// @param walletMembersIDs Identifiers of the source wallet signing group\n    ///        members.\n    /// @param walletMemberIndex Position of the caller in the source wallet\n    ///        signing group members list.\n    /// @param targetWallets List of 20-byte public key hashes of the target\n    ///        wallets that the source wallet commits to move the funds to.\n    /// @dev Requirements:\n    ///      - The source wallet must be in the MovingFunds state,\n    ///      - The source wallet must not have pending redemption requests,\n    ///      - The source wallet must not have pending moved funds sweep requests,\n    ///      - The source wallet must not have submitted its commitment already,\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given source wallet in the ECDSA registry. Those IDs are\n    ///        not directly stored in the contract for gas efficiency purposes\n    ///        but they can be read from appropriate `DkgResultSubmitted`\n    ///        and `DkgResultApproved` events,\n    ///      - The `walletMemberIndex` must be in range [1, walletMembersIDs.length],\n    ///      - The caller must be the member of the source wallet signing group\n    ///        at the position indicated by `walletMemberIndex` parameter,\n    ///      - The `walletMainUtxo` components must point to the recent main\n    ///        UTXO of the source wallet, as currently known on the Ethereum\n    ///        chain,\n    ///      - Source wallet BTC balance must be greater than zero,\n    ///      - At least one Live wallet must exist in the system,\n    ///      - Submitted target wallets count must match the expected count\n    ///        `N = min(liveWalletsCount, ceil(walletBtcBalance / walletMaxBtcTransfer))`\n    ///        where `N > 0`,\n    ///      - Each target wallet must be not equal to the source wallet,\n    ///      - Each target wallet must follow the expected order i.e. all\n    ///        target wallets 20-byte public key hashes represented as numbers\n    ///        must form a strictly increasing sequence without duplicates,\n    ///      - Each target wallet must be in Live state.\n    function submitMovingFundsCommitment(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata walletMainUtxo,\n        uint32[] calldata walletMembersIDs,\n        uint256 walletMemberIndex,\n        bytes20[] calldata targetWallets\n    ) external {\n        self.submitMovingFundsCommitment(\n            walletPubKeyHash,\n            walletMainUtxo,\n            walletMembersIDs,\n            walletMemberIndex,\n            targetWallets\n        );\n    }\n\n    /// @notice Resets the moving funds timeout for the given wallet if the\n    ///         target wallet commitment cannot be submitted due to a lack\n    ///         of live wallets in the system.\n    /// @param walletPubKeyHash 20-byte public key hash of the moving funds wallet.\n    /// @dev Requirements:\n    ///      - The wallet must be in the MovingFunds state,\n    ///      - The target wallets commitment must not be already submitted for\n    ///        the given moving funds wallet,\n    ///      - Live wallets count must be zero,\n    ///      - The moving funds timeout reset delay must be elapsed.\n    function resetMovingFundsTimeout(bytes20 walletPubKeyHash) external {\n        self.resetMovingFundsTimeout(walletPubKeyHash);\n    }\n\n    /// @notice Used by the wallet to prove the BTC moving funds transaction\n    ///         and to make the necessary state changes. Moving funds is only\n    ///         accepted if it satisfies SPV proof.\n    ///\n    ///         The function validates the moving funds transaction structure\n    ///         by checking if it actually spends the main UTXO of the declared\n    ///         wallet and locks the value on the pre-committed target wallets\n    ///         using a reasonable transaction fee. If all preconditions are\n    ///         met, this functions closes the source wallet.\n    ///\n    ///         It is possible to prove the given moving funds transaction only\n    ///         one time.\n    /// @param movingFundsTx Bitcoin moving funds transaction data.\n    /// @param movingFundsProof Bitcoin moving funds proof data.\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain.\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    ///        HASH160 over the compressed ECDSA public key) of the wallet\n    ///        which performed the moving funds transaction.\n    /// @dev Requirements:\n    ///      - `movingFundsTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash,\n    ///      - The `movingFundsTx` should represent a Bitcoin transaction with\n    ///        exactly 1 input that refers to the wallet's main UTXO. That\n    ///        transaction should have 1..n outputs corresponding to the\n    ///        pre-committed target wallets. Outputs must be ordered in the\n    ///        same way as their corresponding target wallets are ordered\n    ///        within the target wallets commitment,\n    ///      - `movingFundsProof` components must match the expected structure.\n    ///        See `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant,\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        Additionally, the recent main UTXO on Ethereum must be set,\n    ///      - `walletPubKeyHash` must be connected with the main UTXO used\n    ///        as transaction single input,\n    ///      - The wallet that `walletPubKeyHash` points to must be in the\n    ///        MovingFunds state,\n    ///      - The target wallets commitment must be submitted by the wallet\n    ///        that `walletPubKeyHash` points to,\n    ///      - The total Bitcoin transaction fee must be lesser or equal\n    ///        to `movingFundsTxMaxTotalFee` governable parameter.\n    function submitMovingFundsProof(\n        BitcoinTx.Info calldata movingFundsTx,\n        BitcoinTx.Proof calldata movingFundsProof,\n        BitcoinTx.UTXO calldata mainUtxo,\n        bytes20 walletPubKeyHash\n    ) external {\n        self.submitMovingFundsProof(\n            movingFundsTx,\n            movingFundsProof,\n            mainUtxo,\n            walletPubKeyHash\n        );\n    }\n\n    /// @notice Notifies about a timed out moving funds process. Terminates\n    ///         the wallet and slashes signing group members as a result.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet.\n    /// @param walletMembersIDs Identifiers of the wallet signing group members.\n    /// @dev Requirements:\n    ///      - The wallet must be in the MovingFunds state,\n    ///      - The moving funds timeout must be actually exceeded,\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract.\n    function notifyMovingFundsTimeout(\n        bytes20 walletPubKeyHash,\n        uint32[] calldata walletMembersIDs\n    ) external {\n        self.notifyMovingFundsTimeout(walletPubKeyHash, walletMembersIDs);\n    }\n\n    /// @notice Notifies about a moving funds wallet whose BTC balance is\n    ///         below the moving funds dust threshold. Ends the moving funds\n    ///         process and begins wallet closing immediately.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known\n    ///        on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - The wallet must be in the MovingFunds state,\n    ///      - The `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        If the wallet has no main UTXO, this parameter can be empty as it\n    ///        is ignored,\n    ///      - The wallet BTC balance must be below the moving funds threshold.\n    function notifyMovingFundsBelowDust(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata mainUtxo\n    ) external {\n        self.notifyMovingFundsBelowDust(walletPubKeyHash, mainUtxo);\n    }\n\n    /// @notice Used by the wallet to prove the BTC moved funds sweep\n    ///         transaction and to make the necessary state changes. Moved\n    ///         funds sweep is only accepted if it satisfies SPV proof.\n    ///\n    ///         The function validates the sweep transaction structure by\n    ///         checking if it actually spends the moved funds UTXO and the\n    ///         sweeping wallet's main UTXO (optionally), and if it locks the\n    ///         value on the sweeping wallet's 20-byte public key hash using a\n    ///         reasonable transaction fee. If all preconditions are\n    ///         met, this function updates the sweeping wallet main UTXO, thus\n    ///         their BTC balance.\n    ///\n    ///         It is possible to prove the given sweep transaction only\n    ///         one time.\n    /// @param sweepTx Bitcoin sweep funds transaction data.\n    /// @param sweepProof Bitcoin sweep funds proof data.\n    /// @param mainUtxo Data of the sweeping wallet's main UTXO, as currently\n    ///        known on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - `sweepTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash,\n    ///      - The `sweepTx` should represent a Bitcoin transaction with\n    ///        the first input pointing to a moved funds sweep request targeted\n    ///        to the wallet, and optionally, the second input pointing to the\n    ///        wallet's main UTXO, if the sweeping wallet has a main UTXO set.\n    ///        There should be only one output locking funds on the sweeping\n    ///        wallet 20-byte public key hash,\n    ///      - `sweepProof` components must match the expected structure.\n    ///        See `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant,\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the sweeping wallet, as currently known on the Ethereum chain.\n    ///        If there is no main UTXO, this parameter is ignored,\n    ///      - The sweeping wallet must be in the Live or MovingFunds state,\n    ///      - The total Bitcoin transaction fee must be lesser or equal\n    ///        to `movedFundsSweepTxMaxTotalFee` governable parameter.\n    function submitMovedFundsSweepProof(\n        BitcoinTx.Info calldata sweepTx,\n        BitcoinTx.Proof calldata sweepProof,\n        BitcoinTx.UTXO calldata mainUtxo\n    ) external {\n        self.submitMovedFundsSweepProof(sweepTx, sweepProof, mainUtxo);\n    }\n\n    /// @notice Notifies about a timed out moved funds sweep process. If the\n    ///         wallet is not terminated yet, that function terminates\n    ///         the wallet and slashes signing group members as a result.\n    ///         Marks the given sweep request as TimedOut.\n    /// @param movingFundsTxHash 32-byte hash of the moving funds transaction\n    ///        that caused the sweep request to be created.\n    /// @param movingFundsTxOutputIndex Index of the moving funds transaction\n    ///        output that is subject of the sweep request.\n    /// @param walletMembersIDs Identifiers of the wallet signing group members.\n    /// @dev Requirements:\n    ///      - The moved funds sweep request must be in the Pending state,\n    ///      - The moved funds sweep timeout must be actually exceeded,\n    ///      - The wallet must be either in the Live or MovingFunds or\n    ///        Terminated state,\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract.\n    function notifyMovedFundsSweepTimeout(\n        bytes32 movingFundsTxHash,\n        uint32 movingFundsTxOutputIndex,\n        uint32[] calldata walletMembersIDs\n    ) external {\n        self.notifyMovedFundsSweepTimeout(\n            movingFundsTxHash,\n            movingFundsTxOutputIndex,\n            walletMembersIDs\n        );\n    }\n\n    /// @notice Requests creation of a new wallet. This function just\n    ///         forms a request and the creation process is performed\n    ///         asynchronously. Once a wallet is created, the ECDSA Wallet\n    ///         Registry will notify this contract by calling the\n    ///         `__ecdsaWalletCreatedCallback` function.\n    /// @param activeWalletMainUtxo Data of the active wallet's main UTXO, as\n    ///        currently known on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - `activeWalletMainUtxo` components must point to the recent main\n    ///        UTXO of the given active wallet, as currently known on the\n    ///        Ethereum chain. If there is no active wallet at the moment, or\n    ///        the active wallet has no main UTXO, this parameter can be\n    ///        empty as it is ignored,\n    ///      - Wallet creation must not be in progress,\n    ///      - If the active wallet is set, one of the following\n    ///        conditions must be true:\n    ///        - The active wallet BTC balance is above the minimum threshold\n    ///          and the active wallet is old enough, i.e. the creation period\n    ///          was elapsed since its creation time,\n    ///        - The active wallet BTC balance is above the maximum threshold.\n    function requestNewWallet(BitcoinTx.UTXO calldata activeWalletMainUtxo)\n        external\n    {\n        self.requestNewWallet(activeWalletMainUtxo);\n    }\n\n    /// @notice A callback function that is called by the ECDSA Wallet Registry\n    ///         once a new ECDSA wallet is created.\n    /// @param ecdsaWalletID Wallet's unique identifier.\n    /// @param publicKeyX Wallet's public key's X coordinate.\n    /// @param publicKeyY Wallet's public key's Y coordinate.\n    /// @dev Requirements:\n    ///      - The only caller authorized to call this function is `registry`,\n    ///      - Given wallet data must not belong to an already registered wallet.\n    function __ecdsaWalletCreatedCallback(\n        bytes32 ecdsaWalletID,\n        bytes32 publicKeyX,\n        bytes32 publicKeyY\n    ) external override {\n        self.registerNewWallet(ecdsaWalletID, publicKeyX, publicKeyY);\n    }\n\n    /// @notice A callback function that is called by the ECDSA Wallet Registry\n    ///         once a wallet heartbeat failure is detected.\n    /// @param publicKeyX Wallet's public key's X coordinate.\n    /// @param publicKeyY Wallet's public key's Y coordinate.\n    /// @dev Requirements:\n    ///      - The only caller authorized to call this function is `registry`,\n    ///      - Wallet must be in Live state.\n    function __ecdsaWalletHeartbeatFailedCallback(\n        bytes32,\n        bytes32 publicKeyX,\n        bytes32 publicKeyY\n    ) external override {\n        self.notifyWalletHeartbeatFailed(publicKeyX, publicKeyY);\n    }\n\n    /// @notice Notifies that the wallet is either old enough or has too few\n    ///         satoshi left and qualifies to be closed.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet.\n    /// @param walletMainUtxo Data of the wallet's main UTXO, as currently\n    ///        known on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - Wallet must not be set as the current active wallet,\n    ///      - Wallet must exceed the wallet maximum age OR the wallet BTC\n    ///        balance must be lesser than the minimum threshold. If the latter\n    ///        case is true, the `walletMainUtxo` components must point to the\n    ///        recent main UTXO of the given wallet, as currently known on the\n    ///        Ethereum chain. If the wallet has no main UTXO, this parameter\n    ///        can be empty as it is ignored since the wallet balance is\n    ///        assumed to be zero,\n    ///      - Wallet must be in Live state.\n    function notifyCloseableWallet(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata walletMainUtxo\n    ) external {\n        self.notifyCloseableWallet(walletPubKeyHash, walletMainUtxo);\n    }\n\n    /// @notice Notifies about the end of the closing period for the given wallet.\n    ///         Closes the wallet ultimately and notifies the ECDSA registry\n    ///         about this fact.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet.\n    /// @dev Requirements:\n    ///      - The wallet must be in the Closing state,\n    ///      - The wallet closing period must have elapsed.\n    function notifyWalletClosingPeriodElapsed(bytes20 walletPubKeyHash)\n        external\n    {\n        self.notifyWalletClosingPeriodElapsed(walletPubKeyHash);\n    }\n\n    /// @notice Submits a fraud challenge indicating that a UTXO being under\n    ///         wallet control was unlocked by the wallet but was not used\n    ///         according to the protocol rules. That means the wallet signed\n    ///         a transaction input pointing to that UTXO and there is a unique\n    ///         sighash and signature pair associated with that input. This\n    ///         function uses those parameters to create a fraud accusation that\n    ///         proves a given transaction input unlocking the given UTXO was\n    ///         actually signed by the wallet. This function cannot determine\n    ///         whether the transaction was actually broadcast and the input was\n    ///         consumed in a fraudulent way so it just opens a challenge period\n    ///         during which the wallet can defeat the challenge by submitting\n    ///         proof of a transaction that consumes the given input according\n    ///         to protocol rules. To prevent spurious allegations, the caller\n    ///         must deposit ETH that is returned back upon justified fraud\n    ///         challenge or confiscated otherwise.\n    /// @param walletPublicKey The public key of the wallet in the uncompressed\n    ///        and unprefixed format (64 bytes).\n    /// @param preimageSha256 The hash that was generated by applying SHA-256\n    ///        one time over the preimage used during input signing. The preimage\n    ///        is a serialized subset of the transaction and its structure\n    ///        depends on the transaction input (see BIP-143 for reference).\n    ///        Notice that applying SHA-256 over the `preimageSha256` results\n    ///        in `sighash`.  The path from `preimage` to `sighash` looks like\n    ///        this:\n    ///        preimage -> (SHA-256) -> preimageSha256 -> (SHA-256) -> sighash.\n    /// @param signature Bitcoin signature in the R/S/V format.\n    /// @dev Requirements:\n    ///      - Wallet behind `walletPublicKey` must be in Live or MovingFunds\n    ///        or Closing state,\n    ///      - The challenger must send appropriate amount of ETH used as\n    ///        fraud challenge deposit,\n    ///      - The signature (represented by r, s and v) must be generated by\n    ///        the wallet behind `walletPubKey` during signing of `sighash`\n    ///        which was calculated from `preimageSha256`,\n    ///      - Wallet can be challenged for the given signature only once.\n    function submitFraudChallenge(\n        bytes calldata walletPublicKey,\n        bytes memory preimageSha256,\n        BitcoinTx.RSVSignature calldata signature\n    ) external payable {\n        self.submitFraudChallenge(walletPublicKey, preimageSha256, signature);\n    }\n\n    /// @notice Allows to defeat a pending fraud challenge against a wallet if\n    ///         the transaction that spends the UTXO follows the protocol rules.\n    ///         In order to defeat the challenge the same `walletPublicKey` and\n    ///         signature (represented by `r`, `s` and `v`) must be provided as\n    ///         were used to calculate the sighash during input signing.\n    ///         The fraud challenge defeat attempt will only succeed if the\n    ///         inputs in the preimage are considered honestly spent by the\n    ///         wallet. Therefore the transaction spending the UTXO must be\n    ///         proven in the Bridge before a challenge defeat is called.\n    ///         If successfully defeated, the fraud challenge is marked as\n    ///         resolved and the amount of ether deposited by the challenger is\n    ///         sent to the treasury.\n    /// @param walletPublicKey The public key of the wallet in the uncompressed\n    ///        and unprefixed format (64 bytes).\n    /// @param preimage The preimage which produces sighash used to generate the\n    ///        ECDSA signature that is the subject of the fraud claim. It is a\n    ///        serialized subset of the transaction. The exact subset used as\n    ///        the preimage depends on the transaction input the signature is\n    ///        produced for. See BIP-143 for reference.\n    /// @param witness Flag indicating whether the preimage was produced for a\n    ///        witness input. True for witness, false for non-witness input.\n    /// @dev Requirements:\n    ///      - `walletPublicKey` and `sighash` calculated as `hash256(preimage)`\n    ///        must identify an open fraud challenge,\n    ///      - the preimage must be a valid preimage of a transaction generated\n    ///        according to the protocol rules and already proved in the Bridge,\n    ///      - before a defeat attempt is made the transaction that spends the\n    ///        given UTXO must be proven in the Bridge.\n    function defeatFraudChallenge(\n        bytes calldata walletPublicKey,\n        bytes calldata preimage,\n        bool witness\n    ) external {\n        self.defeatFraudChallenge(walletPublicKey, preimage, witness);\n    }\n\n    /// @notice Allows to defeat a pending fraud challenge against a wallet by\n    ///         proving the sighash and signature were produced for an off-chain\n    ///         wallet heartbeat message following a strict format.\n    ///         In order to defeat the challenge the same `walletPublicKey` and\n    ///         signature (represented by `r`, `s` and `v`) must be provided as\n    ///         were used to calculate the sighash during heartbeat message\n    ///         signing. The fraud challenge defeat attempt will only succeed if\n    ///         the signed message follows a strict format required for\n    ///         heartbeat messages. If successfully defeated, the fraud\n    ///         challenge is marked as resolved and the amount of ether\n    ///         deposited by the challenger is sent to the treasury.\n    /// @param walletPublicKey The public key of the wallet in the uncompressed\n    ///        and unprefixed format (64 bytes).\n    /// @param heartbeatMessage Off-chain heartbeat message meeting the heartbeat\n    ///        message format requirements which produces sighash used to\n    ///        generate the ECDSA signature that is the subject of the fraud\n    ///        claim.\n    /// @dev Requirements:\n    ///      - `walletPublicKey` and `sighash` calculated as\n    ///        `hash256(heartbeatMessage)` must identify an open fraud challenge,\n    ///      - `heartbeatMessage` must follow a strict format of heartbeat\n    ///        messages.\n    function defeatFraudChallengeWithHeartbeat(\n        bytes calldata walletPublicKey,\n        bytes calldata heartbeatMessage\n    ) external {\n        self.defeatFraudChallengeWithHeartbeat(\n            walletPublicKey,\n            heartbeatMessage\n        );\n    }\n\n    /// @notice Notifies about defeat timeout for the given fraud challenge.\n    ///         Can be called only if there was a fraud challenge identified by\n    ///         the provided `walletPublicKey` and `sighash` and it was not\n    ///         defeated on time. The amount of time that needs to pass after\n    ///         a fraud challenge is reported is indicated by the\n    ///         `challengeDefeatTimeout`. After a successful fraud challenge\n    ///         defeat timeout notification the fraud challenge is marked as\n    ///         resolved, the stake of each operator is slashed, the ether\n    ///         deposited is returned to the challenger and the challenger is\n    ///         rewarded.\n    /// @param walletPublicKey The public key of the wallet in the uncompressed\n    ///        and unprefixed format (64 bytes).\n    /// @param walletMembersIDs Identifiers of the wallet signing group members.\n    /// @param preimageSha256 The hash that was generated by applying SHA-256\n    ///        one time over the preimage used during input signing. The preimage\n    ///        is a serialized subset of the transaction and its structure\n    ///        depends on the transaction input (see BIP-143 for reference).\n    ///        Notice that applying SHA-256 over the `preimageSha256` results\n    ///        in `sighash`.  The path from `preimage` to `sighash` looks like\n    ///        this:\n    ///        preimage -> (SHA-256) -> preimageSha256 -> (SHA-256) -> sighash.\n    /// @dev Requirements:\n    ///      - The wallet must be in the Live or MovingFunds or Closing or\n    ///        Terminated state,\n    ///      - The `walletPublicKey` and `sighash` calculated from\n    ///        `preimageSha256` must identify an open fraud challenge,\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract,\n    ///      - The amount of time indicated by `challengeDefeatTimeout` must pass\n    ///        after the challenge was reported.\n    function notifyFraudChallengeDefeatTimeout(\n        bytes calldata walletPublicKey,\n        uint32[] calldata walletMembersIDs,\n        bytes memory preimageSha256\n    ) external {\n        self.notifyFraudChallengeDefeatTimeout(\n            walletPublicKey,\n            walletMembersIDs,\n            preimageSha256\n        );\n    }\n\n    /// @notice Allows the Governance to mark the given vault address as trusted\n    ///         or no longer trusted. Vaults are not trusted by default.\n    ///         Trusted vault must meet the following criteria:\n    ///         - `IVault.receiveBalanceIncrease` must have a known, low gas\n    ///           cost,\n    ///         - `IVault.receiveBalanceIncrease` must never revert.\n    /// @dev Without restricting reveal only to trusted vaults, malicious\n    ///      vaults not meeting the criteria would be able to nuke sweep proof\n    ///      transactions executed by ECDSA wallet with  deposits routed to\n    ///      them.\n    /// @param vault The address of the vault.\n    /// @param isTrusted flag indicating whether the vault is trusted or not.\n    /// @dev Can only be called by the Governance.\n    function setVaultStatus(address vault, bool isTrusted)\n        external\n        onlyGovernance\n    {\n        self.isVaultTrusted[vault] = isTrusted;\n        emit VaultStatusUpdated(vault, isTrusted);\n    }\n\n    /// @notice Updates parameters of deposits.\n    /// @param depositDustThreshold New value of the deposit dust threshold in\n    ///        satoshis. It is the minimal amount that can be requested to\n    ////       deposit. Value of this parameter must take into account the value\n    ///        of `depositTreasuryFeeDivisor` and `depositTxMaxFee` parameters\n    ///        in order to make requests that can incur the treasury and\n    ///        transaction fee and still satisfy the depositor.\n    /// @param depositTreasuryFeeDivisor New value of the treasury fee divisor.\n    ///        It is the divisor used to compute the treasury fee taken from\n    ///        each deposit and transferred to the treasury upon sweep proof\n    ///        submission. That fee is computed as follows:\n    ///        `treasuryFee = depositedAmount / depositTreasuryFeeDivisor`\n    ///        For example, if the treasury fee needs to be 2% of each deposit,\n    ///        the `depositTreasuryFeeDivisor` should be set to `50`\n    ///        because `1/50 = 0.02 = 2%`.\n    /// @param depositTxMaxFee New value of the deposit tx max fee in satoshis.\n    ///        It is the maximum amount of BTC transaction fee that can\n    ///        be incurred by each swept deposit being part of the given sweep\n    ///        transaction. If the maximum BTC transaction fee is exceeded,\n    ///        such transaction is considered a fraud.\n    /// @dev Requirements:\n    ///      - Deposit dust threshold must be greater than zero,\n    ///      - Deposit treasury fee divisor must be greater than zero,\n    ///      - Deposit transaction max fee must be greater than zero.\n    function updateDepositParameters(\n        uint64 depositDustThreshold,\n        uint64 depositTreasuryFeeDivisor,\n        uint64 depositTxMaxFee\n    ) external onlyGovernance {\n        self.updateDepositParameters(\n            depositDustThreshold,\n            depositTreasuryFeeDivisor,\n            depositTxMaxFee\n        );\n    }\n\n    /// @notice Updates parameters of redemptions.\n    /// @param redemptionDustThreshold New value of the redemption dust\n    ///        threshold in satoshis. It is the minimal amount that can be\n    ///        requested for redemption. Value of this parameter must take into\n    ///        account the value of `redemptionTreasuryFeeDivisor` and\n    ///        `redemptionTxMaxFee` parameters in order to make requests that\n    ///        can incur the treasury and transaction fee and still satisfy the\n    ///        redeemer.\n    /// @param redemptionTreasuryFeeDivisor New value of the redemption\n    ///        treasury fee divisor. It is the divisor used to compute the\n    ///        treasury fee taken from each redemption request and transferred\n    ///        to the treasury upon successful request finalization. That fee is\n    ///        computed as follows:\n    ///        `treasuryFee = requestedAmount / redemptionTreasuryFeeDivisor`\n    ///        For example, if the treasury fee needs to be 2% of each\n    ///        redemption request, the `redemptionTreasuryFeeDivisor` should\n    ///        be set to `50` because `1/50 = 0.02 = 2%`.\n    /// @param redemptionTxMaxFee New value of the redemption transaction max\n    ///        fee in satoshis. It is the maximum amount of BTC transaction fee\n    ///        that can be incurred by each redemption request being part of the\n    ///        given redemption transaction. If the maximum BTC transaction fee\n    ///        is exceeded, such transaction is considered a fraud.\n    ///        This is a per-redemption output max fee for the redemption\n    ///        transaction.\n    /// @param redemptionTimeout New value of the redemption timeout in seconds.\n    ///        It is the time after which the redemption request can be reported\n    ///        as timed out. It is counted from the moment when the redemption\n    ///        request was created via `requestRedemption` call. Reported  timed\n    ///        out requests are cancelled and locked balance is returned to the\n    ///        redeemer in full amount.\n    /// @param redemptionTimeoutSlashingAmount New value of the redemption\n    ///        timeout slashing amount in T, it is the amount slashed from each\n    ///        wallet member for redemption timeout.\n    /// @param redemptionTimeoutNotifierRewardMultiplier New value of the\n    ///        redemption timeout notifier reward multiplier as percentage,\n    ///        it determines the percentage of the notifier reward from the\n    ///        staking contact the notifier of a redemption timeout receives.\n    ///        The value must be in the range [0, 100].\n    /// @dev Requirements:\n    ///      - Redemption dust threshold must be greater than moving funds dust\n    ///        threshold,\n    ///      - Redemption treasury fee divisor must be greater than zero,\n    ///      - Redemption transaction max fee must be greater than zero,\n    ///      - Redemption timeout must be greater than zero,\n    ///      - Redemption timeout notifier reward multiplier must be in the\n    ///        range [0, 100].\n    function updateRedemptionParameters(\n        uint64 redemptionDustThreshold,\n        uint64 redemptionTreasuryFeeDivisor,\n        uint64 redemptionTxMaxFee,\n        uint256 redemptionTimeout,\n        uint96 redemptionTimeoutSlashingAmount,\n        uint256 redemptionTimeoutNotifierRewardMultiplier\n    ) external onlyGovernance {\n        self.updateRedemptionParameters(\n            redemptionDustThreshold,\n            redemptionTreasuryFeeDivisor,\n            redemptionTxMaxFee,\n            redemptionTimeout,\n            redemptionTimeoutSlashingAmount,\n            redemptionTimeoutNotifierRewardMultiplier\n        );\n    }\n\n    /// @notice Updates parameters of moving funds.\n    /// @param movingFundsTxMaxTotalFee New value of the moving funds transaction\n    ///        max total fee in satoshis. It is the maximum amount of the total\n    ///        BTC transaction fee that is acceptable in a single moving funds\n    ///        transaction. This is a _total_ max fee for the entire moving\n    ///        funds transaction.\n    /// @param movingFundsDustThreshold New value of the moving funds dust\n    ///        threshold. It is the minimal satoshi amount that makes sense to\n    ///        be transferred during the moving funds process. Moving funds\n    ///        wallets having their BTC balance below that value can begin\n    ///        closing immediately as transferring such a low value may not be\n    ///        possible due to BTC network fees.\n    /// @param movingFundsTimeoutResetDelay New value of the moving funds\n    ///        timeout reset delay in seconds. It is the time after which the\n    ///        moving funds timeout can be reset in case the target wallet\n    ///        commitment cannot be submitted due to a lack of live wallets\n    ///        in the system. It is counted from the moment when the wallet\n    ///        was requested to move their funds and switched to the MovingFunds\n    ///        state or from the moment the timeout was reset the last time.\n    /// @param movingFundsTimeout New value of the moving funds timeout in\n    ///        seconds. It is the time after which the moving funds process can\n    ///        be reported as timed out. It is counted from the moment when the\n    ///        wallet was requested to move their funds and switched to the\n    ///        MovingFunds state.\n    /// @param movingFundsTimeoutSlashingAmount New value of the moving funds\n    ///        timeout slashing amount in T, it is the amount slashed from each\n    ///        wallet member for moving funds timeout.\n    /// @param movingFundsTimeoutNotifierRewardMultiplier New value of the\n    ///        moving funds timeout notifier reward multiplier as percentage,\n    ///        it determines the percentage of the notifier reward from the\n    ///        staking contact the notifier of a moving funds timeout receives.\n    ///        The value must be in the range [0, 100].\n    /// @param movedFundsSweepTxMaxTotalFee New value of the moved funds sweep\n    ///        transaction max total fee in satoshis. It is the maximum amount\n    ///        of the total BTC transaction fee that is acceptable in a single\n    ///        moved funds sweep transaction. This is a _total_ max fee for the\n    ///        entire moved funds sweep transaction.\n    /// @param movedFundsSweepTimeout New value of the moved funds sweep\n    ///        timeout in seconds. It is the time after which the moved funds\n    ///        sweep process can be reported as timed out. It is counted from\n    ///        the moment when the wallet was requested to sweep the received\n    ///        funds.\n    /// @param movedFundsSweepTimeoutSlashingAmount New value of the moved\n    ///        funds sweep timeout slashing amount in T, it is the amount\n    ///        slashed from each wallet member for moved funds sweep timeout.\n    /// @param movedFundsSweepTimeoutNotifierRewardMultiplier New value of\n    ///        the moved funds sweep timeout notifier reward multiplier as\n    ///        percentage, it determines the percentage of the notifier reward\n    ///        from the staking contact the notifier of a moved funds sweep\n    ///        timeout receives. The value must be in the range [0, 100].\n    /// @dev Requirements:\n    ///      - Moving funds transaction max total fee must be greater than zero,\n    ///      - Moving funds dust threshold must be greater than zero and lower\n    ///        than the redemption dust threshold,\n    ///      - Moving funds timeout reset delay must be greater than zero,\n    ///      - Moving funds timeout must be greater than the moving funds\n    ///        timeout reset delay,\n    ///      - Moving funds timeout notifier reward multiplier must be in the\n    ///        range [0, 100],\n    ///      - Moved funds sweep transaction max total fee must be greater than zero,\n    ///      - Moved funds sweep timeout must be greater than zero,\n    ///      - Moved funds sweep timeout notifier reward multiplier must be in the\n    ///        range [0, 100].\n    function updateMovingFundsParameters(\n        uint64 movingFundsTxMaxTotalFee,\n        uint64 movingFundsDustThreshold,\n        uint32 movingFundsTimeoutResetDelay,\n        uint32 movingFundsTimeout,\n        uint96 movingFundsTimeoutSlashingAmount,\n        uint256 movingFundsTimeoutNotifierRewardMultiplier,\n        uint64 movedFundsSweepTxMaxTotalFee,\n        uint32 movedFundsSweepTimeout,\n        uint96 movedFundsSweepTimeoutSlashingAmount,\n        uint256 movedFundsSweepTimeoutNotifierRewardMultiplier\n    ) external onlyGovernance {\n        self.updateMovingFundsParameters(\n            movingFundsTxMaxTotalFee,\n            movingFundsDustThreshold,\n            movingFundsTimeoutResetDelay,\n            movingFundsTimeout,\n            movingFundsTimeoutSlashingAmount,\n            movingFundsTimeoutNotifierRewardMultiplier,\n            movedFundsSweepTxMaxTotalFee,\n            movedFundsSweepTimeout,\n            movedFundsSweepTimeoutSlashingAmount,\n            movedFundsSweepTimeoutNotifierRewardMultiplier\n        );\n    }\n\n    /// @notice Updates parameters of wallets.\n    /// @param walletCreationPeriod New value of the wallet creation period in\n    ///        seconds, determines how frequently a new wallet creation can be\n    ///        requested.\n    /// @param walletCreationMinBtcBalance New value of the wallet minimum BTC\n    ///        balance in satoshi, used to decide about wallet creation.\n    /// @param walletCreationMaxBtcBalance New value of the wallet maximum BTC\n    ///        balance in satoshi, used to decide about wallet creation.\n    /// @param walletClosureMinBtcBalance New value of the wallet minimum BTC\n    ///        balance in satoshi, used to decide about wallet closure.\n    /// @param walletMaxAge New value of the wallet maximum age in seconds,\n    ///        indicates the maximum age of a wallet in seconds, after which\n    ///        the wallet moving funds process can be requested.\n    /// @param walletMaxBtcTransfer New value of the wallet maximum BTC transfer\n    ///        in satoshi, determines the maximum amount that can be transferred\n    //         to a single target wallet during the moving funds process.\n    /// @param walletClosingPeriod New value of the wallet closing period in\n    ///        seconds, determines the length of the wallet closing period,\n    //         i.e. the period when the wallet remains in the Closing state\n    //         and can be subject of deposit fraud challenges.\n    /// @dev Requirements:\n    ///      - Wallet minimum BTC balance must be greater than zero,\n    ///      - Wallet maximum BTC balance must be greater than the wallet\n    ///        minimum BTC balance,\n    ///      - Wallet maximum BTC transfer must be greater than zero,\n    ///      - Wallet closing period must be greater than zero.\n    function updateWalletParameters(\n        uint32 walletCreationPeriod,\n        uint64 walletCreationMinBtcBalance,\n        uint64 walletCreationMaxBtcBalance,\n        uint64 walletClosureMinBtcBalance,\n        uint32 walletMaxAge,\n        uint64 walletMaxBtcTransfer,\n        uint32 walletClosingPeriod\n    ) external onlyGovernance {\n        self.updateWalletParameters(\n            walletCreationPeriod,\n            walletCreationMinBtcBalance,\n            walletCreationMaxBtcBalance,\n            walletClosureMinBtcBalance,\n            walletMaxAge,\n            walletMaxBtcTransfer,\n            walletClosingPeriod\n        );\n    }\n\n    /// @notice Updates parameters related to frauds.\n    /// @param fraudChallengeDepositAmount New value of the fraud challenge\n    ///        deposit amount in wei, it is the amount of ETH the party\n    ///        challenging the wallet for fraud needs to deposit.\n    /// @param fraudChallengeDefeatTimeout New value of the challenge defeat\n    ///        timeout in seconds, it is the amount of time the wallet has to\n    ///        defeat a fraud challenge. The value must be greater than zero.\n    /// @param fraudSlashingAmount New value of the fraud slashing amount in T,\n    ///        it is the amount slashed from each wallet member for committing\n    ///        a fraud.\n    /// @param fraudNotifierRewardMultiplier New value of the fraud notifier\n    ///        reward multiplier as percentage, it determines the percentage of\n    ///        the notifier reward from the staking contact the notifier of\n    ///        a fraud receives. The value must be in the range [0, 100].\n    /// @dev Requirements:\n    ///      - Fraud challenge defeat timeout must be greater than 0,\n    ///      - Fraud notifier reward multiplier must be in the range [0, 100].\n    function updateFraudParameters(\n        uint256 fraudChallengeDepositAmount,\n        uint256 fraudChallengeDefeatTimeout,\n        uint96 fraudSlashingAmount,\n        uint256 fraudNotifierRewardMultiplier\n    ) external onlyGovernance {\n        self.updateFraudParameters(\n            fraudChallengeDepositAmount,\n            fraudChallengeDefeatTimeout,\n            fraudSlashingAmount,\n            fraudNotifierRewardMultiplier\n        );\n    }\n\n    /// @notice Collection of all revealed deposits indexed by\n    ///         keccak256(fundingTxHash | fundingOutputIndex).\n    ///         The fundingTxHash is bytes32 (ordered as in Bitcoin internally)\n    ///         and fundingOutputIndex an uint32. This mapping may contain valid\n    ///         and invalid deposits and the wallet is responsible for\n    ///         validating them before attempting to execute a sweep.\n    function deposits(uint256 depositKey)\n        external\n        view\n        returns (Deposit.DepositRequest memory)\n    {\n        return self.deposits[depositKey];\n    }\n\n    /// @notice Collection of all pending redemption requests indexed by\n    ///         redemption key built as\n    ///         keccak256(walletPubKeyHash | redeemerOutputScript). The\n    ///         walletPubKeyHash is the 20-byte wallet's public key hash\n    ///         (computed using Bitcoin HASH160 over the compressed ECDSA\n    ///         public key) and redeemerOutputScript is a Bitcoin script\n    ///         (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock\n    ///         redeemed BTC as requested by the redeemer. Requests are added\n    ///         to this mapping by the `requestRedemption` method (duplicates\n    ///         not allowed) and are removed by one of the following methods:\n    ///         - `submitRedemptionProof` in case the request was handled\n    ///           successfully,\n    ///         - `notifyRedemptionTimeout` in case the request was reported\n    ///           to be timed out.\n    function pendingRedemptions(uint256 redemptionKey)\n        external\n        view\n        returns (Redemption.RedemptionRequest memory)\n    {\n        return self.pendingRedemptions[redemptionKey];\n    }\n\n    /// @notice Collection of all timed out redemptions requests indexed by\n    ///         redemption key built as\n    ///         keccak256(walletPubKeyHash | redeemerOutputScript). The\n    ///         walletPubKeyHash is the 20-byte wallet's public key hash\n    ///         (computed using Bitcoin HASH160 over the compressed ECDSA\n    ///         public key) and redeemerOutputScript is the Bitcoin script\n    ///         (P2PKH, P2WPKH, P2SH or P2WSH) that is involved in the timed\n    ///         out request. Timed out requests are stored in this mapping to\n    ///         avoid slashing the wallets multiple times for the same timeout.\n    ///         Only one method can add to this mapping:\n    ///         - `notifyRedemptionTimeout` which puts the redemption key\n    ///           to this mapping basing on a timed out request stored\n    ///           previously in `pendingRedemptions` mapping.\n    function timedOutRedemptions(uint256 redemptionKey)\n        external\n        view\n        returns (Redemption.RedemptionRequest memory)\n    {\n        return self.timedOutRedemptions[redemptionKey];\n    }\n\n    /// @notice Collection of main UTXOs that are honestly spent indexed by\n    ///         keccak256(fundingTxHash | fundingOutputIndex). The fundingTxHash\n    ///         is bytes32 (ordered as in Bitcoin internally) and\n    ///         fundingOutputIndex an uint32. A main UTXO is considered honestly\n    ///         spent if it was used as an input of a transaction that have been\n    ///         proven in the Bridge.\n    function spentMainUTXOs(uint256 utxoKey) external view returns (bool) {\n        return self.spentMainUTXOs[utxoKey];\n    }\n\n    /// @notice Gets details about a registered wallet.\n    /// @param walletPubKeyHash The 20-byte wallet public key hash (computed\n    ///        using Bitcoin HASH160 over the compressed ECDSA public key).\n    /// @return Wallet details.\n    function wallets(bytes20 walletPubKeyHash)\n        external\n        view\n        returns (Wallets.Wallet memory)\n    {\n        return self.registeredWallets[walletPubKeyHash];\n    }\n\n    /// @notice Gets the public key hash of the active wallet.\n    /// @return The 20-byte public key hash (computed using Bitcoin HASH160\n    ///         over the compressed ECDSA public key) of the active wallet.\n    ///         Returns bytes20(0) if there is no active wallet at the moment.\n    function activeWalletPubKeyHash() external view returns (bytes20) {\n        return self.activeWalletPubKeyHash;\n    }\n\n    /// @notice Gets the live wallets count.\n    /// @return The current count of wallets being in the Live state.\n    function liveWalletsCount() external view returns (uint32) {\n        return self.liveWalletsCount;\n    }\n\n    /// @notice Returns the fraud challenge identified by the given key built\n    ///         as keccak256(walletPublicKey|sighash).\n    function fraudChallenges(uint256 challengeKey)\n        external\n        view\n        returns (Fraud.FraudChallenge memory)\n    {\n        return self.fraudChallenges[challengeKey];\n    }\n\n    /// @notice Collection of all moved funds sweep requests indexed by\n    ///         `keccak256(movingFundsTxHash | movingFundsOutputIndex)`.\n    ///         The `movingFundsTxHash` is `bytes32` (ordered as in Bitcoin\n    ///         internally) and `movingFundsOutputIndex` an `uint32`. Each entry\n    ///         is actually an UTXO representing the moved funds and is supposed\n    ///         to be swept with the current main UTXO of the recipient wallet.\n    /// @param requestKey Request key built as\n    ///        `keccak256(movingFundsTxHash | movingFundsOutputIndex)`.\n    /// @return Details of the moved funds sweep request.\n    function movedFundsSweepRequests(uint256 requestKey)\n        external\n        view\n        returns (MovingFunds.MovedFundsSweepRequest memory)\n    {\n        return self.movedFundsSweepRequests[requestKey];\n    }\n\n    /// @notice Indicates if the vault with the given address is trusted or not.\n    ///         Depositors can route their revealed deposits only to trusted\n    ///         vaults and have trusted vaults notified about new deposits as\n    ///         soon as these deposits get swept. Vaults not trusted by the\n    ///         Bridge can still be used by Bank balance owners on their own\n    ///         responsibility - anyone can approve their Bank balance to any\n    ///         address.\n    function isVaultTrusted(address vault) external view returns (bool) {\n        return self.isVaultTrusted[vault];\n    }\n\n    /// @notice Returns the current values of Bridge deposit parameters.\n    /// @return depositDustThreshold The minimal amount that can be requested\n    ///         to deposit. Value of this parameter must take into account the\n    ///         value of `depositTreasuryFeeDivisor` and `depositTxMaxFee`\n    ///         parameters in order to make requests that can incur the\n    ///         treasury and transaction fee and still satisfy the depositor.\n    /// @return depositTreasuryFeeDivisor Divisor used to compute the treasury\n    ///         fee taken from each deposit and transferred to the treasury upon\n    ///         sweep proof submission. That fee is computed as follows:\n    ///         `treasuryFee = depositedAmount / depositTreasuryFeeDivisor`\n    ///         For example, if the treasury fee needs to be 2% of each deposit,\n    ///         the `depositTreasuryFeeDivisor` should be set to `50`\n    ///         because `1/50 = 0.02 = 2%`.\n    /// @return depositTxMaxFee Maximum amount of BTC transaction fee that can\n    ///         be incurred by each swept deposit being part of the given sweep\n    ///         transaction. If the maximum BTC transaction fee is exceeded,\n    ///         such transaction is considered a fraud.\n    function depositParameters()\n        external\n        view\n        returns (\n            uint64 depositDustThreshold,\n            uint64 depositTreasuryFeeDivisor,\n            uint64 depositTxMaxFee\n        )\n    {\n        depositDustThreshold = self.depositDustThreshold;\n        depositTreasuryFeeDivisor = self.depositTreasuryFeeDivisor;\n        depositTxMaxFee = self.depositTxMaxFee;\n    }\n\n    /// @notice Returns the current values of Bridge redemption parameters.\n    /// @return redemptionDustThreshold The minimal amount that can be requested\n    ///         for redemption. Value of this parameter must take into account\n    ///         the value of `redemptionTreasuryFeeDivisor` and `redemptionTxMaxFee`\n    ///         parameters in order to make requests that can incur the\n    ///         treasury and transaction fee and still satisfy the redeemer.\n    /// @return redemptionTreasuryFeeDivisor Divisor used to compute the treasury\n    ///         fee taken from each redemption request and transferred to the\n    ///         treasury upon successful request finalization. That fee is\n    ///         computed as follows:\n    ///         `treasuryFee = requestedAmount / redemptionTreasuryFeeDivisor`\n    ///         For example, if the treasury fee needs to be 2% of each\n    ///         redemption request, the `redemptionTreasuryFeeDivisor` should\n    ///         be set to `50` because `1/50 = 0.02 = 2%`.\n    /// @return redemptionTxMaxFee Maximum amount of BTC transaction fee that\n    ///         can be incurred by each redemption request being part of the\n    ///         given redemption transaction. If the maximum BTC transaction\n    ///         fee is exceeded, such transaction is considered a fraud.\n    ///         This is a per-redemption output max fee for the redemption\n    ///         transaction.\n    /// @return redemptionTimeout Time after which the redemption request can be\n    ///         reported as timed out. It is counted from the moment when the\n    ///         redemption request was created via `requestRedemption` call.\n    ///         Reported  timed out requests are cancelled and locked balance is\n    ///         returned to the redeemer in full amount.\n    /// @return redemptionTimeoutSlashingAmount The amount of stake slashed\n    ///         from each member of a wallet for a redemption timeout.\n    /// @return redemptionTimeoutNotifierRewardMultiplier The percentage of the\n    ///         notifier reward from the staking contract the notifier of a\n    ///         redemption timeout receives. The value is in the range [0, 100].\n    function redemptionParameters()\n        external\n        view\n        returns (\n            uint64 redemptionDustThreshold,\n            uint64 redemptionTreasuryFeeDivisor,\n            uint64 redemptionTxMaxFee,\n            uint256 redemptionTimeout,\n            uint96 redemptionTimeoutSlashingAmount,\n            uint256 redemptionTimeoutNotifierRewardMultiplier\n        )\n    {\n        redemptionDustThreshold = self.redemptionDustThreshold;\n        redemptionTreasuryFeeDivisor = self.redemptionTreasuryFeeDivisor;\n        redemptionTxMaxFee = self.redemptionTxMaxFee;\n        redemptionTimeout = self.redemptionTimeout;\n        redemptionTimeoutSlashingAmount = self.redemptionTimeoutSlashingAmount;\n        redemptionTimeoutNotifierRewardMultiplier = self\n            .redemptionTimeoutNotifierRewardMultiplier;\n    }\n\n    /// @notice Returns the current values of Bridge moving funds between\n    ///         wallets parameters.\n    /// @return movingFundsTxMaxTotalFee Maximum amount of the total BTC\n    ///         transaction fee that is acceptable in a single moving funds\n    ///         transaction. This is a _total_ max fee for the entire moving\n    ///         funds transaction.\n    /// @return movingFundsDustThreshold The minimal satoshi amount that makes\n    ///         sense to be transferred during the moving funds process. Moving\n    ///         funds wallets having their BTC balance below that value can\n    ///         begin closing immediately as transferring such a low value may\n    ///         not be possible due to BTC network fees.\n    /// @return movingFundsTimeoutResetDelay Time after which the moving funds\n    ///         timeout can be reset in case the target wallet commitment\n    ///         cannot be submitted due to a lack of live wallets in the system.\n    ///         It is counted from the moment when the wallet was requested to\n    ///         move their funds and switched to the MovingFunds state or from\n    ///         the moment the timeout was reset the last time. Value in seconds\n    ///         This value should be lower than the value of the\n    ///         `movingFundsTimeout`.\n    /// @return movingFundsTimeout Time after which the moving funds process\n    ///         can be reported as timed out. It is counted from the moment\n    ///         when the wallet was requested to move their funds and switched\n    ///         to the MovingFunds state. Value in seconds.\n    /// @return movingFundsTimeoutSlashingAmount The amount of stake slashed\n    ///         from each member of a wallet for a moving funds timeout.\n    /// @return movingFundsTimeoutNotifierRewardMultiplier The percentage of the\n    ///         notifier reward from the staking contract the notifier of a\n    ///         moving funds timeout receives. The value is in the range [0, 100].\n    /// @return movedFundsSweepTxMaxTotalFee Maximum amount of the total BTC\n    ///         transaction fee that is acceptable in a single moved funds\n    ///         sweep transaction. This is a _total_ max fee for the entire\n    ///         moved funds sweep transaction.\n    /// @return movedFundsSweepTimeout Time after which the moved funds sweep\n    ///         process can be reported as timed out. It is counted from the\n    ///         moment when the wallet was requested to sweep the received funds.\n    ///         Value in seconds.\n    /// @return movedFundsSweepTimeoutSlashingAmount The amount of stake slashed\n    ///         from each member of a wallet for a moved funds sweep timeout.\n    /// @return movedFundsSweepTimeoutNotifierRewardMultiplier The percentage\n    ///         of the notifier reward from the staking contract the notifier\n    ///         of a moved funds sweep timeout receives. The value is in the\n    ///         range [0, 100].\n    function movingFundsParameters()\n        external\n        view\n        returns (\n            uint64 movingFundsTxMaxTotalFee,\n            uint64 movingFundsDustThreshold,\n            uint32 movingFundsTimeoutResetDelay,\n            uint32 movingFundsTimeout,\n            uint96 movingFundsTimeoutSlashingAmount,\n            uint256 movingFundsTimeoutNotifierRewardMultiplier,\n            uint64 movedFundsSweepTxMaxTotalFee,\n            uint32 movedFundsSweepTimeout,\n            uint96 movedFundsSweepTimeoutSlashingAmount,\n            uint256 movedFundsSweepTimeoutNotifierRewardMultiplier\n        )\n    {\n        movingFundsTxMaxTotalFee = self.movingFundsTxMaxTotalFee;\n        movingFundsDustThreshold = self.movingFundsDustThreshold;\n        movingFundsTimeoutResetDelay = self.movingFundsTimeoutResetDelay;\n        movingFundsTimeout = self.movingFundsTimeout;\n        movingFundsTimeoutSlashingAmount = self\n            .movingFundsTimeoutSlashingAmount;\n        movingFundsTimeoutNotifierRewardMultiplier = self\n            .movingFundsTimeoutNotifierRewardMultiplier;\n        movedFundsSweepTxMaxTotalFee = self.movedFundsSweepTxMaxTotalFee;\n        movedFundsSweepTimeout = self.movedFundsSweepTimeout;\n        movedFundsSweepTimeoutSlashingAmount = self\n            .movedFundsSweepTimeoutSlashingAmount;\n        movedFundsSweepTimeoutNotifierRewardMultiplier = self\n            .movedFundsSweepTimeoutNotifierRewardMultiplier;\n    }\n\n    /// @return walletCreationPeriod Determines how frequently a new wallet\n    ///         creation can be requested. Value in seconds.\n    /// @return walletCreationMinBtcBalance The minimum BTC threshold in satoshi\n    ///         that is used to decide about wallet creation.\n    /// @return walletCreationMaxBtcBalance The maximum BTC threshold in satoshi\n    ///         that is used to decide about wallet creation.\n    /// @return walletClosureMinBtcBalance The minimum BTC threshold in satoshi\n    ///         that is used to decide about wallet closure.\n    /// @return walletMaxAge The maximum age of a wallet in seconds, after which\n    ///         the wallet moving funds process can be requested.\n    /// @return walletMaxBtcTransfer The maximum BTC amount in satoshi than\n    ///         can be transferred to a single target wallet during the moving\n    ///         funds process.\n    /// @return walletClosingPeriod Determines the length of the wallet closing\n    ///         period, i.e. the period when the wallet remains in the Closing\n    ///         state and can be subject of deposit fraud challenges. Value\n    ///         in seconds.\n    function walletParameters()\n        external\n        view\n        returns (\n            uint32 walletCreationPeriod,\n            uint64 walletCreationMinBtcBalance,\n            uint64 walletCreationMaxBtcBalance,\n            uint64 walletClosureMinBtcBalance,\n            uint32 walletMaxAge,\n            uint64 walletMaxBtcTransfer,\n            uint32 walletClosingPeriod\n        )\n    {\n        walletCreationPeriod = self.walletCreationPeriod;\n        walletCreationMinBtcBalance = self.walletCreationMinBtcBalance;\n        walletCreationMaxBtcBalance = self.walletCreationMaxBtcBalance;\n        walletClosureMinBtcBalance = self.walletClosureMinBtcBalance;\n        walletMaxAge = self.walletMaxAge;\n        walletMaxBtcTransfer = self.walletMaxBtcTransfer;\n        walletClosingPeriod = self.walletClosingPeriod;\n    }\n\n    /// @notice Returns the current values of Bridge fraud parameters.\n    /// @return fraudChallengeDepositAmount The amount of ETH in wei the party\n    ///         challenging the wallet for fraud needs to deposit.\n    /// @return fraudChallengeDefeatTimeout The amount of time the wallet has to\n    ///         defeat a fraud challenge.\n    /// @return fraudSlashingAmount The amount slashed from each wallet member\n    ///         for committing a fraud.\n    /// @return fraudNotifierRewardMultiplier The percentage of the notifier\n    ///         reward from the staking contract the notifier of a fraud\n    ///         receives. The value is in the range [0, 100].\n    function fraudParameters()\n        external\n        view\n        returns (\n            uint256 fraudChallengeDepositAmount,\n            uint256 fraudChallengeDefeatTimeout,\n            uint96 fraudSlashingAmount,\n            uint256 fraudNotifierRewardMultiplier\n        )\n    {\n        fraudChallengeDepositAmount = self.fraudChallengeDepositAmount;\n        fraudChallengeDefeatTimeout = self.fraudChallengeDefeatTimeout;\n        fraudSlashingAmount = self.fraudSlashingAmount;\n        fraudNotifierRewardMultiplier = self.fraudNotifierRewardMultiplier;\n    }\n\n    /// @notice Returns the addresses of contracts Bridge is interacting with.\n    /// @return bank Address of the Bank the Bridge belongs to.\n    /// @return relay Address of the Bitcoin relay providing the current Bitcoin\n    ///         network difficulty.\n    /// @return ecdsaWalletRegistry Address of the ECDSA Wallet Registry.\n    function contractReferences()\n        external\n        view\n        returns (\n            Bank bank,\n            IRelay relay,\n            EcdsaWalletRegistry ecdsaWalletRegistry\n        )\n    {\n        bank = self.bank;\n        relay = self.relay;\n        ecdsaWalletRegistry = self.ecdsaWalletRegistry;\n    }\n\n    /// @notice Address where the deposit treasury fees will be sent to.\n    ///         Treasury takes part in the operators rewarding process.\n    function treasury() external view returns (address) {\n        return self.treasury;\n    }\n\n    /// @notice The number of confirmations on the Bitcoin chain required to\n    ///         successfully evaluate an SPV proof.\n    function txProofDifficultyFactor() external view returns (uint256) {\n        return self.txProofDifficultyFactor;\n    }\n}\n"
     },
     "@keep-network/ecdsa/contracts/api/IWalletOwner.sol": {
       "content": "// SPDX-License-Identifier: MIT\n//\n// ▓▓▌ ▓▓ ▐▓▓ ▓▓▓▓▓▓▓▓▓▓▌▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▄\n// ▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▌▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓\n//   ▓▓▓▓▓▓    ▓▓▓▓▓▓▓▀    ▐▓▓▓▓▓▓    ▐▓▓▓▓▓   ▓▓▓▓▓▓     ▓▓▓▓▓   ▐▓▓▓▓▓▌   ▐▓▓▓▓▓▓\n//   ▓▓▓▓▓▓▄▄▓▓▓▓▓▓▓▀      ▐▓▓▓▓▓▓▄▄▄▄         ▓▓▓▓▓▓▄▄▄▄         ▐▓▓▓▓▓▌   ▐▓▓▓▓▓▓\n//   ▓▓▓▓▓▓▓▓▓▓▓▓▓▀        ▐▓▓▓▓▓▓▓▓▓▓         ▓▓▓▓▓▓▓▓▓▓         ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓\n//   ▓▓▓▓▓▓▀▀▓▓▓▓▓▓▄       ▐▓▓▓▓▓▓▀▀▀▀         ▓▓▓▓▓▓▀▀▀▀         ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▀\n//   ▓▓▓▓▓▓   ▀▓▓▓▓▓▓▄     ▐▓▓▓▓▓▓     ▓▓▓▓▓   ▓▓▓▓▓▓     ▓▓▓▓▓   ▐▓▓▓▓▓▌\n// ▓▓▓▓▓▓▓▓▓▓ █▓▓▓▓▓▓▓▓▓ ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓▓▓\n// ▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓ ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓▓▓\n//\n//                           Trust math, not hardware.\n\npragma solidity ^0.8.9;\n\ninterface IWalletOwner {\n    /// @notice Callback function executed once a new wallet is created.\n    /// @dev Should be callable only by the Wallet Registry.\n    /// @param walletID Wallet's unique identifier.\n    /// @param publicKeyY Wallet's public key's X coordinate.\n    /// @param publicKeyY Wallet's public key's Y coordinate.\n    function __ecdsaWalletCreatedCallback(\n        bytes32 walletID,\n        bytes32 publicKeyX,\n        bytes32 publicKeyY\n    ) external;\n\n    /// @notice Callback function executed once a wallet heartbeat failure\n    ///         is detected.\n    /// @dev Should be callable only by the Wallet Registry.\n    /// @param walletID Wallet's unique identifier.\n    /// @param publicKeyY Wallet's public key's X coordinate.\n    /// @param publicKeyY Wallet's public key's Y coordinate.\n    function __ecdsaWalletHeartbeatFailedCallback(\n        bytes32 walletID,\n        bytes32 publicKeyX,\n        bytes32 publicKeyY\n    ) external;\n}\n"
     },
+    "@openzeppelin/contracts-upgradeable/utils/math/SafeCastUpgradeable.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/math/SafeCast.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n *\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\n * all math on `uint256` and `int256` and then downcasting.\n */\nlibrary SafeCastUpgradeable {\n    /**\n     * @dev Returns the downcasted uint224 from uint256, reverting on\n     * overflow (when the input is greater than largest uint224).\n     *\n     * Counterpart to Solidity's `uint224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toUint224(uint256 value) internal pure returns (uint224) {\n        require(value <= type(uint224).max, \"SafeCast: value doesn't fit in 224 bits\");\n        return uint224(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint128 from uint256, reverting on\n     * overflow (when the input is greater than largest uint128).\n     *\n     * Counterpart to Solidity's `uint128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toUint128(uint256 value) internal pure returns (uint128) {\n        require(value <= type(uint128).max, \"SafeCast: value doesn't fit in 128 bits\");\n        return uint128(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint96 from uint256, reverting on\n     * overflow (when the input is greater than largest uint96).\n     *\n     * Counterpart to Solidity's `uint96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toUint96(uint256 value) internal pure returns (uint96) {\n        require(value <= type(uint96).max, \"SafeCast: value doesn't fit in 96 bits\");\n        return uint96(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint64 from uint256, reverting on\n     * overflow (when the input is greater than largest uint64).\n     *\n     * Counterpart to Solidity's `uint64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toUint64(uint256 value) internal pure returns (uint64) {\n        require(value <= type(uint64).max, \"SafeCast: value doesn't fit in 64 bits\");\n        return uint64(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint32 from uint256, reverting on\n     * overflow (when the input is greater than largest uint32).\n     *\n     * Counterpart to Solidity's `uint32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toUint32(uint256 value) internal pure returns (uint32) {\n        require(value <= type(uint32).max, \"SafeCast: value doesn't fit in 32 bits\");\n        return uint32(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint16 from uint256, reverting on\n     * overflow (when the input is greater than largest uint16).\n     *\n     * Counterpart to Solidity's `uint16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toUint16(uint256 value) internal pure returns (uint16) {\n        require(value <= type(uint16).max, \"SafeCast: value doesn't fit in 16 bits\");\n        return uint16(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint8 from uint256, reverting on\n     * overflow (when the input is greater than largest uint8).\n     *\n     * Counterpart to Solidity's `uint8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits.\n     */\n    function toUint8(uint256 value) internal pure returns (uint8) {\n        require(value <= type(uint8).max, \"SafeCast: value doesn't fit in 8 bits\");\n        return uint8(value);\n    }\n\n    /**\n     * @dev Converts a signed int256 into an unsigned uint256.\n     *\n     * Requirements:\n     *\n     * - input must be greater than or equal to 0.\n     */\n    function toUint256(int256 value) internal pure returns (uint256) {\n        require(value >= 0, \"SafeCast: value must be positive\");\n        return uint256(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int128 from int256, reverting on\n     * overflow (when the input is less than smallest int128 or\n     * greater than largest int128).\n     *\n     * Counterpart to Solidity's `int128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     *\n     * _Available since v3.1._\n     */\n    function toInt128(int256 value) internal pure returns (int128) {\n        require(value >= type(int128).min && value <= type(int128).max, \"SafeCast: value doesn't fit in 128 bits\");\n        return int128(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int64 from int256, reverting on\n     * overflow (when the input is less than smallest int64 or\n     * greater than largest int64).\n     *\n     * Counterpart to Solidity's `int64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     *\n     * _Available since v3.1._\n     */\n    function toInt64(int256 value) internal pure returns (int64) {\n        require(value >= type(int64).min && value <= type(int64).max, \"SafeCast: value doesn't fit in 64 bits\");\n        return int64(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int32 from int256, reverting on\n     * overflow (when the input is less than smallest int32 or\n     * greater than largest int32).\n     *\n     * Counterpart to Solidity's `int32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     *\n     * _Available since v3.1._\n     */\n    function toInt32(int256 value) internal pure returns (int32) {\n        require(value >= type(int32).min && value <= type(int32).max, \"SafeCast: value doesn't fit in 32 bits\");\n        return int32(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int16 from int256, reverting on\n     * overflow (when the input is less than smallest int16 or\n     * greater than largest int16).\n     *\n     * Counterpart to Solidity's `int16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     *\n     * _Available since v3.1._\n     */\n    function toInt16(int256 value) internal pure returns (int16) {\n        require(value >= type(int16).min && value <= type(int16).max, \"SafeCast: value doesn't fit in 16 bits\");\n        return int16(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int8 from int256, reverting on\n     * overflow (when the input is less than smallest int8 or\n     * greater than largest int8).\n     *\n     * Counterpart to Solidity's `int8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits.\n     *\n     * _Available since v3.1._\n     */\n    function toInt8(int256 value) internal pure returns (int8) {\n        require(value >= type(int8).min && value <= type(int8).max, \"SafeCast: value doesn't fit in 8 bits\");\n        return int8(value);\n    }\n\n    /**\n     * @dev Converts an unsigned uint256 into a signed int256.\n     *\n     * Requirements:\n     *\n     * - input must be less than or equal to maxInt256.\n     */\n    function toInt256(uint256 value) internal pure returns (int256) {\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\n        require(value <= uint256(type(int256).max), \"SafeCast: value doesn't fit in an int256\");\n        return int256(value);\n    }\n}\n"
+    },
     "contracts/bridge/IRelay.sol": {
       "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\n/// @title Interface for the Bitcoin relay\n/// @notice Contains only the methods needed by tBTC v2. The Bitcoin relay\n///         provides the difficulty of the previous and current epoch. One\n///         difficulty epoch spans 2016 blocks.\ninterface IRelay {\n    /// @notice Returns the difficulty of the current epoch.\n    function getCurrentEpochDifficulty() external view returns (uint256);\n\n    /// @notice Returns the difficulty of the previous epoch.\n    function getPrevEpochDifficulty() external view returns (uint256);\n}\n"
     },
@@ -143,10 +146,10 @@
       "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\nimport {BTCUtils} from \"@keep-network/bitcoin-spv-sol/contracts/BTCUtils.sol\";\n\nimport \"./BitcoinTx.sol\";\nimport \"./BridgeState.sol\";\nimport \"./Wallets.sol\";\n\nimport \"../bank/Bank.sol\";\n\n/// @title Bridge deposit sweep\n/// @notice The library handles the logic for sweeping transactions revealed to\n///         the Bridge\n/// @dev Bridge active wallet periodically signs a transaction that unlocks all\n///      of the valid, revealed deposits above the dust threshold, combines them\n///      into a single UTXO with the existing main wallet UTXO, and relocks\n///      those transactions without a 30-day refund clause to the same wallet.\n///      This has two main effects: it consolidates the UTXO set and it disables\n///      the refund. Balances of depositors in the Bank are increased when the\n///      SPV sweep proof is submitted to the Bridge.\nlibrary DepositSweep {\n    using BridgeState for BridgeState.Storage;\n    using BitcoinTx for BridgeState.Storage;\n\n    using BTCUtils for bytes;\n\n    /// @notice Represents temporary information needed during the processing\n    ///         of the deposit sweep Bitcoin transaction inputs. This structure\n    ///         is an internal one and should not be exported outside of the\n    ///         deposit sweep transaction processing code.\n    /// @dev Allows to mitigate \"stack too deep\" errors on EVM.\n    struct DepositSweepTxInputsProcessingInfo {\n        // Input vector of the deposit sweep Bitcoin transaction. It is\n        // assumed the vector's structure is valid so it must be validated\n        // using e.g. `BTCUtils.validateVin` function before being used\n        // during the processing. The validation is usually done as part\n        // of the `BitcoinTx.validateProof` call that checks the SPV proof.\n        bytes sweepTxInputVector;\n        // Data of the wallet's main UTXO. If no main UTXO exists for the given\n        // sweeping wallet, this parameter's fields should be zeroed to bypass\n        // the main UTXO validation\n        BitcoinTx.UTXO mainUtxo;\n        // Address of the vault where all swept deposits should be routed to.\n        // It is used to validate whether all swept deposits have been revealed\n        // with the same `vault` parameter. It is an optional parameter.\n        // Set to zero address if deposits are not routed to a vault.\n        address vault;\n        // This struct doesn't contain `__gap` property as the structure is not\n        // stored, it is used as a function's memory argument.\n    }\n\n    /// @notice Represents an outcome of the sweep Bitcoin transaction\n    ///         inputs processing.\n    struct DepositSweepTxInputsInfo {\n        // Sum of all inputs values i.e. all deposits and main UTXO value,\n        // if present.\n        uint256 inputsTotalValue;\n        // Addresses of depositors who performed processed deposits. Ordered in\n        // the same order as deposits inputs in the input vector. Size of this\n        // array is either equal to the number of inputs (main UTXO doesn't\n        // exist) or less by one (main UTXO exists and is pointed by one of\n        // the inputs).\n        address[] depositors;\n        // Amounts of deposits corresponding to processed deposits. Ordered in\n        // the same order as deposits inputs in the input vector. Size of this\n        // array is either equal to the number of inputs (main UTXO doesn't\n        // exist) or less by one (main UTXO exists and is pointed by one of\n        // the inputs).\n        uint256[] depositedAmounts;\n        // Values of the treasury fee corresponding to processed deposits.\n        // Ordered in the same order as deposits inputs in the input vector.\n        // Size of this array is either equal to the number of inputs (main\n        // UTXO doesn't exist) or less by one (main UTXO exists and is pointed\n        // by one of the inputs).\n        uint256[] treasuryFees;\n        // This struct doesn't contain `__gap` property as the structure is not\n        // stored, it is used as a function's memory argument.\n    }\n\n    event DepositsSwept(bytes20 walletPubKeyHash, bytes32 sweepTxHash);\n\n    /// @notice Used by the wallet to prove the BTC deposit sweep transaction\n    ///         and to update Bank balances accordingly. Sweep is only accepted\n    ///         if it satisfies SPV proof.\n    ///\n    ///         The function is performing Bank balance updates by first\n    ///         computing the Bitcoin fee for the sweep transaction. The fee is\n    ///         divided evenly between all swept deposits. Each depositor\n    ///         receives a balance in the bank equal to the amount inferred\n    ///         during the reveal transaction, minus their fee share.\n    ///\n    ///         It is possible to prove the given sweep only one time.\n    /// @param sweepTx Bitcoin sweep transaction data.\n    /// @param sweepProof Bitcoin sweep proof data.\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain. If no main UTXO exists for the given wallet,\n    ///        this parameter is ignored.\n    /// @param vault Optional address of the vault where all swept deposits\n    ///        should be routed to. All deposits swept as part of the transaction\n    ///        must have their `vault` parameters set to the same address.\n    ///        If this parameter is set to an address of a trusted vault, swept\n    ///        deposits are routed to that vault.\n    ///        If this parameter is set to the zero address or to an address\n    ///        of a non-trusted vault, swept deposits are not routed to a\n    ///        vault but depositors' balances are increased in the Bank\n    ///        individually.\n    /// @dev Requirements:\n    ///      - `sweepTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash,\n    ///      - The `sweepTx` should represent a Bitcoin transaction with 1..n\n    ///        inputs. If the wallet has no main UTXO, all n inputs should\n    ///        correspond to P2(W)SH revealed deposits UTXOs. If the wallet has\n    ///        an existing main UTXO, one of the n inputs must point to that\n    ///        main UTXO and remaining n-1 inputs should correspond to P2(W)SH\n    ///        revealed deposits UTXOs. That transaction must have only\n    ///        one P2(W)PKH output locking funds on the 20-byte wallet public\n    ///        key hash,\n    ///      - All revealed deposits that are swept by `sweepTx` must have\n    ///        their `vault` parameters set to the same address as the address\n    ///        passed in the `vault` function parameter,\n    ///      - `sweepProof` components must match the expected structure. See\n    ///        `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant,\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        If there is no main UTXO, this parameter is ignored.\n    function submitDepositSweepProof(\n        BridgeState.Storage storage self,\n        BitcoinTx.Info calldata sweepTx,\n        BitcoinTx.Proof calldata sweepProof,\n        BitcoinTx.UTXO calldata mainUtxo,\n        address vault\n    ) external {\n        // The actual transaction proof is performed here. After that point, we\n        // can assume the transaction happened on Bitcoin chain and has\n        // a sufficient number of confirmations as determined by\n        // `txProofDifficultyFactor` constant.\n        bytes32 sweepTxHash = self.validateProof(sweepTx, sweepProof);\n\n        // Process sweep transaction output and extract its target wallet\n        // public key hash and value.\n        (\n            bytes20 walletPubKeyHash,\n            uint64 sweepTxOutputValue\n        ) = processDepositSweepTxOutput(self, sweepTx.outputVector);\n\n        (\n            Wallets.Wallet storage wallet,\n            BitcoinTx.UTXO memory resolvedMainUtxo\n        ) = resolveDepositSweepingWallet(self, walletPubKeyHash, mainUtxo);\n\n        // Process sweep transaction inputs and extract all information needed\n        // to perform deposit bookkeeping.\n        DepositSweepTxInputsInfo\n            memory inputsInfo = processDepositSweepTxInputs(\n                self,\n                DepositSweepTxInputsProcessingInfo(\n                    sweepTx.inputVector,\n                    resolvedMainUtxo,\n                    vault\n                )\n            );\n\n        // Helper variable that will hold the sum of treasury fees paid by\n        // all deposits.\n        uint256 totalTreasuryFee = 0;\n\n        // Determine the transaction fee that should be incurred by each deposit\n        // and the indivisible remainder that should be additionally incurred\n        // by the last deposit.\n        (\n            uint256 depositTxFee,\n            uint256 depositTxFeeRemainder\n        ) = depositSweepTxFeeDistribution(\n                inputsInfo.inputsTotalValue,\n                sweepTxOutputValue,\n                inputsInfo.depositedAmounts.length\n            );\n\n        // Make sure the highest value of the deposit transaction fee does not\n        // exceed the maximum value limited by the governable parameter.\n        require(\n            depositTxFee + depositTxFeeRemainder <= self.depositTxMaxFee,\n            \"Transaction fee is too high\"\n        );\n\n        // Reduce each deposit amount by treasury fee and transaction fee.\n        for (uint256 i = 0; i < inputsInfo.depositedAmounts.length; i++) {\n            // The last deposit should incur the deposit transaction fee\n            // remainder.\n            uint256 depositTxFeeIncurred = i ==\n                inputsInfo.depositedAmounts.length - 1\n                ? depositTxFee + depositTxFeeRemainder\n                : depositTxFee;\n\n            // There is no need to check whether\n            // `inputsInfo.depositedAmounts[i] - inputsInfo.treasuryFees[i] - txFee > 0`\n            // since the `depositDustThreshold` should force that condition\n            // to be always true.\n            inputsInfo.depositedAmounts[i] =\n                inputsInfo.depositedAmounts[i] -\n                inputsInfo.treasuryFees[i] -\n                depositTxFeeIncurred;\n            totalTreasuryFee += inputsInfo.treasuryFees[i];\n        }\n\n        // Record this sweep data and assign them to the wallet public key hash\n        // as new main UTXO. Transaction output index is always 0 as sweep\n        // transaction always contains only one output.\n        wallet.mainUtxoHash = keccak256(\n            abi.encodePacked(sweepTxHash, uint32(0), sweepTxOutputValue)\n        );\n\n        // slither-disable-next-line reentrancy-events\n        emit DepositsSwept(walletPubKeyHash, sweepTxHash);\n\n        if (vault != address(0) && self.isVaultTrusted[vault]) {\n            // If the `vault` address is not zero and belongs to a trusted\n            // vault, route the deposits to that vault.\n            self.bank.increaseBalanceAndCall(\n                vault,\n                inputsInfo.depositors,\n                inputsInfo.depositedAmounts\n            );\n        } else {\n            // If the `vault` address is zero or belongs to a non-trusted\n            // vault, increase balances in the Bank individually for each\n            // depositor.\n            self.bank.increaseBalances(\n                inputsInfo.depositors,\n                inputsInfo.depositedAmounts\n            );\n        }\n\n        // Pass the treasury fee to the treasury address.\n        self.bank.increaseBalance(self.treasury, totalTreasuryFee);\n    }\n\n    /// @notice Resolves sweeping wallet based on the provided wallet public key\n    ///         hash. Validates the wallet state and current main UTXO, as\n    ///         currently known on the Ethereum chain.\n    /// @param walletPubKeyHash public key hash of the wallet proving the sweep\n    ///        Bitcoin transaction.\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain. If no main UTXO exists for the given wallet,\n    ///        this parameter is ignored.\n    /// @return wallet Data of the sweeping wallet.\n    /// @return resolvedMainUtxo The actual main UTXO of the sweeping wallet\n    ///         resolved by cross-checking the `mainUtxo` parameter with\n    ///         the chain state. If the validation went well, this is the\n    ///         plain-text main UTXO corresponding to the `wallet.mainUtxoHash`.\n    /// @dev Requirements:\n    ///     - Sweeping wallet must be either in Live or MovingFunds state,\n    ///     - If the main UTXO of the sweeping wallet exists in the storage,\n    ///       the passed `mainUTXO` parameter must be equal to the stored one.\n    function resolveDepositSweepingWallet(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata mainUtxo\n    )\n        internal\n        view\n        returns (\n            Wallets.Wallet storage wallet,\n            BitcoinTx.UTXO memory resolvedMainUtxo\n        )\n    {\n        wallet = self.registeredWallets[walletPubKeyHash];\n\n        Wallets.WalletState walletState = wallet.state;\n        require(\n            walletState == Wallets.WalletState.Live ||\n                walletState == Wallets.WalletState.MovingFunds,\n            \"Wallet must be in Live or MovingFunds state\"\n        );\n\n        // Check if the main UTXO for given wallet exists. If so, validate\n        // passed main UTXO data against the stored hash and use them for\n        // further processing. If no main UTXO exists, use empty data.\n        resolvedMainUtxo = BitcoinTx.UTXO(bytes32(0), 0, 0);\n        bytes32 mainUtxoHash = wallet.mainUtxoHash;\n        if (mainUtxoHash != bytes32(0)) {\n            require(\n                keccak256(\n                    abi.encodePacked(\n                        mainUtxo.txHash,\n                        mainUtxo.txOutputIndex,\n                        mainUtxo.txOutputValue\n                    )\n                ) == mainUtxoHash,\n                \"Invalid main UTXO data\"\n            );\n            resolvedMainUtxo = mainUtxo;\n        }\n    }\n\n    /// @notice Processes the Bitcoin sweep transaction output vector by\n    ///         extracting the single output and using it to gain additional\n    ///         information required for further processing (e.g. value and\n    ///         wallet public key hash).\n    /// @param sweepTxOutputVector Bitcoin sweep transaction output vector.\n    ///        This function assumes vector's structure is valid so it must be\n    ///        validated using e.g. `BTCUtils.validateVout` function before\n    ///        it is passed here.\n    /// @return walletPubKeyHash 20-byte wallet public key hash.\n    /// @return value 8-byte sweep transaction output value.\n    function processDepositSweepTxOutput(\n        BridgeState.Storage storage self,\n        bytes memory sweepTxOutputVector\n    ) internal view returns (bytes20 walletPubKeyHash, uint64 value) {\n        // To determine the total number of sweep transaction outputs, we need to\n        // parse the compactSize uint (VarInt) the output vector is prepended by.\n        // That compactSize uint encodes the number of vector elements using the\n        // format presented in:\n        // https://developer.bitcoin.org/reference/transactions.html#compactsize-unsigned-integers\n        // We don't need asserting the compactSize uint is parseable since it\n        // was already checked during `validateVout` validation.\n        // See `BitcoinTx.outputVector` docs for more details.\n        (, uint256 outputsCount) = sweepTxOutputVector.parseVarInt();\n        require(\n            outputsCount == 1,\n            \"Sweep transaction must have a single output\"\n        );\n\n        bytes memory output = sweepTxOutputVector.extractOutputAtIndex(0);\n        walletPubKeyHash = self.extractPubKeyHash(output);\n        value = output.extractValue();\n\n        return (walletPubKeyHash, value);\n    }\n\n    /// @notice Processes the Bitcoin sweep transaction input vector. It\n    ///         extracts each input and tries to obtain associated deposit or\n    ///         main UTXO data, depending on the input type. Reverts\n    ///         if one of the inputs cannot be recognized as a pointer to a\n    ///         revealed deposit or expected main UTXO.\n    ///         This function also marks each processed deposit as swept.\n    /// @return resultInfo Outcomes of the processing.\n    function processDepositSweepTxInputs(\n        BridgeState.Storage storage self,\n        DepositSweepTxInputsProcessingInfo memory processInfo\n    ) internal returns (DepositSweepTxInputsInfo memory resultInfo) {\n        // If the passed `mainUtxo` parameter's values are zeroed, the main UTXO\n        // for the given wallet doesn't exist and it is not expected to be\n        // included in the sweep transaction input vector.\n        bool mainUtxoExpected = processInfo.mainUtxo.txHash != bytes32(0);\n        bool mainUtxoFound = false;\n\n        // Determining the total number of sweep transaction inputs in the same\n        // way as for number of outputs. See `BitcoinTx.inputVector` docs for\n        // more details.\n        (uint256 inputsCompactSizeUintLength, uint256 inputsCount) = processInfo\n            .sweepTxInputVector\n            .parseVarInt();\n\n        // To determine the first input starting index, we must jump over\n        // the compactSize uint which prepends the input vector. One byte\n        // must be added because `BtcUtils.parseVarInt` does not include\n        // compactSize uint tag in the returned length.\n        //\n        // For >= 0 && <= 252, `BTCUtils.determineVarIntDataLengthAt`\n        // returns `0`, so we jump over one byte of compactSize uint.\n        //\n        // For >= 253 && <= 0xffff there is `0xfd` tag,\n        // `BTCUtils.determineVarIntDataLengthAt` returns `2` (no\n        // tag byte included) so we need to jump over 1+2 bytes of\n        // compactSize uint.\n        //\n        // Please refer `BTCUtils` library and compactSize uint\n        // docs in `BitcoinTx` library for more details.\n        uint256 inputStartingIndex = 1 + inputsCompactSizeUintLength;\n\n        // Determine the swept deposits count. If main UTXO is NOT expected,\n        // all inputs should be deposits. If main UTXO is expected, one input\n        // should point to that main UTXO.\n        resultInfo.depositors = new address[](\n            !mainUtxoExpected ? inputsCount : inputsCount - 1\n        );\n        resultInfo.depositedAmounts = new uint256[](\n            resultInfo.depositors.length\n        );\n        resultInfo.treasuryFees = new uint256[](resultInfo.depositors.length);\n\n        // Initialize helper variables.\n        uint256 processedDepositsCount = 0;\n\n        // Inputs processing loop.\n        for (uint256 i = 0; i < inputsCount; i++) {\n            (\n                bytes32 outpointTxHash,\n                uint32 outpointIndex,\n                uint256 inputLength\n            ) = parseDepositSweepTxInputAt(\n                    processInfo.sweepTxInputVector,\n                    inputStartingIndex\n                );\n\n            Deposit.DepositRequest storage deposit = self.deposits[\n                uint256(\n                    keccak256(abi.encodePacked(outpointTxHash, outpointIndex))\n                )\n            ];\n\n            if (deposit.revealedAt != 0) {\n                // If we entered here, that means the input was identified as\n                // a revealed deposit.\n                require(deposit.sweptAt == 0, \"Deposit already swept\");\n\n                require(\n                    deposit.vault == processInfo.vault,\n                    \"Deposit should be routed to another vault\"\n                );\n\n                if (processedDepositsCount == resultInfo.depositors.length) {\n                    // If this condition is true, that means a deposit input\n                    // took place of an expected main UTXO input.\n                    // In other words, there is no expected main UTXO\n                    // input and all inputs come from valid, revealed deposits.\n                    revert(\n                        \"Expected main UTXO not present in sweep transaction inputs\"\n                    );\n                }\n\n                /* solhint-disable-next-line not-rely-on-time */\n                deposit.sweptAt = uint32(block.timestamp);\n\n                resultInfo.depositors[processedDepositsCount] = deposit\n                    .depositor;\n                resultInfo.depositedAmounts[processedDepositsCount] = deposit\n                    .amount;\n                resultInfo.inputsTotalValue += resultInfo.depositedAmounts[\n                    processedDepositsCount\n                ];\n                resultInfo.treasuryFees[processedDepositsCount] = deposit\n                    .treasuryFee;\n\n                processedDepositsCount++;\n            } else if (\n                mainUtxoExpected != mainUtxoFound &&\n                processInfo.mainUtxo.txHash == outpointTxHash &&\n                processInfo.mainUtxo.txOutputIndex == outpointIndex\n            ) {\n                // If we entered here, that means the input was identified as\n                // the expected main UTXO.\n                resultInfo.inputsTotalValue += processInfo\n                    .mainUtxo\n                    .txOutputValue;\n                mainUtxoFound = true;\n\n                // Main UTXO used as an input, mark it as spent.\n                self.spentMainUTXOs[\n                    uint256(\n                        keccak256(\n                            abi.encodePacked(outpointTxHash, outpointIndex)\n                        )\n                    )\n                ] = true;\n            } else {\n                revert(\"Unknown input type\");\n            }\n\n            // Make the `inputStartingIndex` pointing to the next input by\n            // increasing it by current input's length.\n            inputStartingIndex += inputLength;\n        }\n\n        // Construction of the input processing loop guarantees that:\n        // `processedDepositsCount == resultInfo.depositors.length == resultInfo.depositedAmounts.length`\n        // is always true at this point. We just use the first variable\n        // to assert the total count of swept deposit is bigger than zero.\n        require(\n            processedDepositsCount > 0,\n            \"Sweep transaction must process at least one deposit\"\n        );\n\n        // Assert the main UTXO was used as one of current sweep's inputs if\n        // it was actually expected.\n        require(\n            mainUtxoExpected == mainUtxoFound,\n            \"Expected main UTXO not present in sweep transaction inputs\"\n        );\n\n        return resultInfo;\n    }\n\n    /// @notice Parses a Bitcoin transaction input starting at the given index.\n    /// @param inputVector Bitcoin transaction input vector.\n    /// @param inputStartingIndex Index the given input starts at.\n    /// @return outpointTxHash 32-byte hash of the Bitcoin transaction which is\n    ///         pointed in the given input's outpoint.\n    /// @return outpointIndex 4-byte index of the Bitcoin transaction output\n    ///         which is pointed in the given input's outpoint.\n    /// @return inputLength Byte length of the given input.\n    /// @dev This function assumes vector's structure is valid so it must be\n    ///      validated using e.g. `BTCUtils.validateVin` function before it\n    ///      is passed here.\n    function parseDepositSweepTxInputAt(\n        bytes memory inputVector,\n        uint256 inputStartingIndex\n    )\n        internal\n        pure\n        returns (\n            bytes32 outpointTxHash,\n            uint32 outpointIndex,\n            uint256 inputLength\n        )\n    {\n        outpointTxHash = inputVector.extractInputTxIdLeAt(inputStartingIndex);\n\n        outpointIndex = BTCUtils.reverseUint32(\n            uint32(inputVector.extractTxIndexLeAt(inputStartingIndex))\n        );\n\n        inputLength = inputVector.determineInputLengthAt(inputStartingIndex);\n\n        return (outpointTxHash, outpointIndex, inputLength);\n    }\n\n    /// @notice Determines the distribution of the sweep transaction fee\n    ///         over swept deposits.\n    /// @param sweepTxInputsTotalValue Total value of all sweep transaction inputs.\n    /// @param sweepTxOutputValue Value of the sweep transaction output.\n    /// @param depositsCount Count of the deposits swept by the sweep transaction.\n    /// @return depositTxFee Transaction fee per deposit determined by evenly\n    ///         spreading the divisible part of the sweep transaction fee\n    ///         over all deposits.\n    /// @return depositTxFeeRemainder The indivisible part of the sweep\n    ///         transaction fee than cannot be distributed over all deposits.\n    /// @dev It is up to the caller to decide how the remainder should be\n    ///      counted in. This function only computes its value.\n    function depositSweepTxFeeDistribution(\n        uint256 sweepTxInputsTotalValue,\n        uint256 sweepTxOutputValue,\n        uint256 depositsCount\n    )\n        internal\n        pure\n        returns (uint256 depositTxFee, uint256 depositTxFeeRemainder)\n    {\n        // The sweep transaction fee is just the difference between inputs\n        // amounts sum and the output amount.\n        uint256 sweepTxFee = sweepTxInputsTotalValue - sweepTxOutputValue;\n        // Compute the indivisible remainder that remains after dividing the\n        // sweep transaction fee over all deposits evenly.\n        depositTxFeeRemainder = sweepTxFee % depositsCount;\n        // Compute the transaction fee per deposit by dividing the sweep\n        // transaction fee (reduced by the remainder) by the number of deposits.\n        depositTxFee = (sweepTxFee - depositTxFeeRemainder) / depositsCount;\n\n        return (depositTxFee, depositTxFeeRemainder);\n    }\n}\n"
     },
     "contracts/bridge/Redemption.sol": {
-      "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\nimport {BTCUtils} from \"@keep-network/bitcoin-spv-sol/contracts/BTCUtils.sol\";\nimport {BytesLib} from \"@keep-network/bitcoin-spv-sol/contracts/BytesLib.sol\";\n\nimport \"./BitcoinTx.sol\";\nimport \"./BridgeState.sol\";\nimport \"./Wallets.sol\";\n\nimport \"../bank/Bank.sol\";\n\n/// @notice Aggregates functions common to the redemption transaction proof\n///         validation and to the moving funds transaction proof validation.\nlibrary OutboundTx {\n    using BTCUtils for bytes;\n\n    /// @notice Checks whether an outbound Bitcoin transaction performed from\n    ///         the given wallet has an input vector that contains a single\n    ///         input referring to the wallet's main UTXO. Marks that main UTXO\n    ///         as correctly spent if the validation succeeds. Reverts otherwise.\n    ///         There are two outbound transactions from a wallet possible: a\n    ///         redemption transaction or a moving funds to another wallet\n    ///         transaction.\n    /// @param walletOutboundTxInputVector Bitcoin outbound transaction's input\n    ///        vector. This function assumes vector's structure is valid so it\n    ///        must be validated using e.g. `BTCUtils.validateVin` function\n    ///        before it is passed here.\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain.\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    //         HASH160 over the compressed ECDSA public key) of the wallet which\n    ///        performed the outbound transaction.\n    function processWalletOutboundTxInput(\n        BridgeState.Storage storage self,\n        bytes memory walletOutboundTxInputVector,\n        BitcoinTx.UTXO calldata mainUtxo,\n        bytes20 walletPubKeyHash\n    ) internal {\n        // Assert that main UTXO for passed wallet exists in storage.\n        bytes32 mainUtxoHash = self\n            .registeredWallets[walletPubKeyHash]\n            .mainUtxoHash;\n        require(mainUtxoHash != bytes32(0), \"No main UTXO for given wallet\");\n\n        // Assert that passed main UTXO parameter is the same as in storage and\n        // can be used for further processing.\n        require(\n            keccak256(\n                abi.encodePacked(\n                    mainUtxo.txHash,\n                    mainUtxo.txOutputIndex,\n                    mainUtxo.txOutputValue\n                )\n            ) == mainUtxoHash,\n            \"Invalid main UTXO data\"\n        );\n\n        // Assert that the single outbound transaction input actually\n        // refers to the wallet's main UTXO.\n        (\n            bytes32 outpointTxHash,\n            uint32 outpointIndex\n        ) = parseWalletOutboundTxInput(walletOutboundTxInputVector);\n        require(\n            mainUtxo.txHash == outpointTxHash &&\n                mainUtxo.txOutputIndex == outpointIndex,\n            \"Outbound transaction input must point to the wallet's main UTXO\"\n        );\n\n        // Main UTXO used as an input, mark it as spent.\n        self.spentMainUTXOs[\n            uint256(\n                keccak256(\n                    abi.encodePacked(mainUtxo.txHash, mainUtxo.txOutputIndex)\n                )\n            )\n        ] = true;\n    }\n\n    /// @notice Parses the input vector of an outbound Bitcoin transaction\n    ///         performed from the given wallet. It extracts the single input\n    ///         then the transaction hash and output index from its outpoint.\n    ///         There are two outbound transactions from a wallet possible: a\n    ///         redemption transaction or a moving funds to another wallet\n    ///         transaction.\n    /// @param walletOutboundTxInputVector Bitcoin outbound transaction input\n    ///        vector. This function assumes vector's structure is valid so it\n    ///        must be validated using e.g. `BTCUtils.validateVin` function\n    ///        before it is passed here.\n    /// @return outpointTxHash 32-byte hash of the Bitcoin transaction which is\n    ///         pointed in the input's outpoint.\n    /// @return outpointIndex 4-byte index of the Bitcoin transaction output\n    ///         which is pointed in the input's outpoint.\n    function parseWalletOutboundTxInput(\n        bytes memory walletOutboundTxInputVector\n    ) internal pure returns (bytes32 outpointTxHash, uint32 outpointIndex) {\n        // To determine the total number of Bitcoin transaction inputs,\n        // we need to parse the compactSize uint (VarInt) the input vector is\n        // prepended by. That compactSize uint encodes the number of vector\n        // elements using the format presented in:\n        // https://developer.bitcoin.org/reference/transactions.html#compactsize-unsigned-integers\n        // We don't need asserting the compactSize uint is parseable since it\n        // was already checked during `validateVin` validation.\n        // See `BitcoinTx.inputVector` docs for more details.\n        (, uint256 inputsCount) = walletOutboundTxInputVector.parseVarInt();\n        require(\n            inputsCount == 1,\n            \"Outbound transaction must have a single input\"\n        );\n\n        bytes memory input = walletOutboundTxInputVector.extractInputAtIndex(0);\n\n        outpointTxHash = input.extractInputTxIdLE();\n\n        outpointIndex = BTCUtils.reverseUint32(\n            uint32(input.extractTxIndexLE())\n        );\n\n        // There is only one input in the transaction. Input has an outpoint\n        // field that is a reference to the transaction being spent (see\n        // `BitcoinTx` docs). The outpoint contains the hash of the transaction\n        // to spend (`outpointTxHash`) and the index of the specific output\n        // from that transaction (`outpointIndex`).\n        return (outpointTxHash, outpointIndex);\n    }\n}\n\n/// @title Bridge redemption\n/// @notice The library handles the logic for redeeming Bitcoin balances from\n///         the Bridge.\n/// @dev To initiate a redemption, a user with a Bank balance supplies\n///      a Bitcoin address. Then, the system calculates the redemption fee, and\n///      releases balance to the provided Bitcoin address. Just like in case of\n///      sweeps of revealed deposits, redemption requests are processed in\n///      batches and require SPV proof to be submitted to the Bridge.\nlibrary Redemption {\n    using BridgeState for BridgeState.Storage;\n    using Wallets for BridgeState.Storage;\n    using BitcoinTx for BridgeState.Storage;\n\n    using BTCUtils for bytes;\n    using BytesLib for bytes;\n\n    /// @notice Represents a redemption request.\n    struct RedemptionRequest {\n        // ETH address of the redeemer who created the request.\n        address redeemer;\n        // Requested TBTC amount in satoshi.\n        uint64 requestedAmount;\n        // Treasury TBTC fee in satoshi at the moment of request creation.\n        uint64 treasuryFee;\n        // Transaction maximum BTC fee in satoshi at the moment of request\n        // creation.\n        uint64 txMaxFee;\n        // UNIX timestamp the request was created at.\n        uint32 requestedAt;\n        // This struct doesn't contain `__gap` property as the structure is stored\n        // in a mapping, mappings store values in different slots and they are\n        // not contiguous with other values.\n    }\n\n    /// @notice Represents an outcome of the redemption Bitcoin transaction\n    ///         outputs processing.\n    struct RedemptionTxOutputsInfo {\n        // Total TBTC value in satoshi that should be burned by the Bridge.\n        // It includes the total amount of all BTC redeemed in the transaction\n        // and the fee paid to BTC miners for the redemption transaction.\n        uint64 totalBurnableValue;\n        // Total TBTC value in satoshi that should be transferred to\n        // the treasury. It is a sum of all treasury fees paid by all\n        // redeemers included in the redemption transaction.\n        uint64 totalTreasuryFee;\n        // Index of the change output. The change output becomes\n        // the new main wallet's UTXO.\n        uint32 changeIndex;\n        // Value in satoshi of the change output.\n        uint64 changeValue;\n        // This struct doesn't contain `__gap` property as the structure is not\n        // stored, it is used as a function's memory argument.\n    }\n\n    /// @notice Represents temporary information needed during the processing of\n    ///         the redemption Bitcoin transaction outputs. This structure is an\n    ///         internal one and should not be exported outside of the redemption\n    ///         transaction processing code.\n    /// @dev Allows to mitigate \"stack too deep\" errors on EVM.\n    struct RedemptionTxOutputsProcessingInfo {\n        // The first output starting index in the transaction.\n        uint256 outputStartingIndex;\n        // The number of outputs in the transaction.\n        uint256 outputsCount;\n        // P2PKH script for the wallet. Needed to determine the change output.\n        bytes32 walletP2PKHScriptKeccak;\n        // P2WPKH script for the wallet. Needed to determine the change output.\n        bytes32 walletP2WPKHScriptKeccak;\n        // This struct doesn't contain `__gap` property as the structure is not\n        // stored, it is used as a function's memory argument.\n    }\n\n    event RedemptionRequested(\n        bytes20 indexed walletPubKeyHash,\n        bytes redeemerOutputScript,\n        address indexed redeemer,\n        uint64 requestedAmount,\n        uint64 treasuryFee,\n        uint64 txMaxFee\n    );\n\n    event RedemptionsCompleted(\n        bytes20 indexed walletPubKeyHash,\n        bytes32 redemptionTxHash\n    );\n\n    event RedemptionTimedOut(\n        bytes20 indexed walletPubKeyHash,\n        bytes redeemerOutputScript\n    );\n\n    /// @notice Requests redemption of the given amount from the specified\n    ///         wallet to the redeemer Bitcoin output script.\n    /// @param walletPubKeyHash The 20-byte wallet public key hash (computed\n    ///        using Bitcoin HASH160 over the compressed ECDSA public key).\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain.\n    /// @param redeemerOutputScript The redeemer's length-prefixed output\n    ///        script (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock\n    ///        redeemed BTC.\n    /// @param amount Requested amount in satoshi. This is also the TBTC amount\n    ///        that is taken from redeemer's balance in the Bank upon request.\n    ///        Once the request is handled, the actual amount of BTC locked\n    ///        on the redeemer output script will be always lower than this value\n    ///        since the treasury and Bitcoin transaction fees must be incurred.\n    ///        The minimal amount satisfying the request can be computed as:\n    ///        `amount - (amount / redemptionTreasuryFeeDivisor) - redemptionTxMaxFee`.\n    ///        Fees values are taken at the moment of request creation.\n    /// @dev Requirements:\n    ///      - Wallet behind `walletPubKeyHash` must be live,\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain,\n    ///      - `redeemerOutputScript` must be a proper Bitcoin script,\n    ///      - `redeemerOutputScript` cannot have wallet PKH as payload,\n    ///      - `amount` must be above or equal the `redemptionDustThreshold`,\n    ///      - Given `walletPubKeyHash` and `redeemerOutputScript` pair can be\n    ///        used for only one pending request at the same time,\n    ///      - Wallet must have enough Bitcoin balance to proceed the request,\n    ///      - Redeemer must make an allowance in the Bank that the Bridge\n    ///        contract can spend the given `amount`.\n    function requestRedemption(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata mainUtxo,\n        bytes calldata redeemerOutputScript,\n        uint64 amount\n    ) external {\n        Wallets.Wallet storage wallet = self.registeredWallets[\n            walletPubKeyHash\n        ];\n\n        require(\n            wallet.state == Wallets.WalletState.Live,\n            \"Wallet must be in Live state\"\n        );\n\n        bytes32 mainUtxoHash = wallet.mainUtxoHash;\n        require(\n            mainUtxoHash != bytes32(0),\n            \"No main UTXO for the given wallet\"\n        );\n        require(\n            keccak256(\n                abi.encodePacked(\n                    mainUtxo.txHash,\n                    mainUtxo.txOutputIndex,\n                    mainUtxo.txOutputValue\n                )\n            ) == mainUtxoHash,\n            \"Invalid main UTXO data\"\n        );\n\n        // Validate if redeemer output script is a correct standard type\n        // (P2PKH, P2WPKH, P2SH or P2WSH). This is done by building a stub\n        // output with 0 as value and using `BTCUtils.extractHash` on it. Such\n        // a function extracts the payload properly only from standard outputs\n        // so if it succeeds, we have a guarantee the redeemer output script\n        // is proper. Worth to note `extractHash` ignores the value at all\n        // so this is why we can use 0 safely. This way of validation is the\n        // same as in tBTC v1.\n        bytes memory redeemerOutputScriptPayload = abi\n            .encodePacked(bytes8(0), redeemerOutputScript)\n            .extractHash();\n        require(\n            redeemerOutputScriptPayload.length > 0,\n            \"Redeemer output script must be a standard type\"\n        );\n        // Check if the redeemer output script payload does not point to the\n        // wallet public key hash.\n        require(\n            keccak256(abi.encodePacked(walletPubKeyHash)) !=\n                keccak256(redeemerOutputScriptPayload),\n            \"Redeemer output script must not point to the wallet PKH\"\n        );\n\n        require(\n            amount >= self.redemptionDustThreshold,\n            \"Redemption amount too small\"\n        );\n\n        // The redemption key is built on top of the wallet public key hash\n        // and redeemer output script pair. That means there can be only one\n        // request asking for redemption from the given wallet to the given\n        // BTC script at the same time.\n        uint256 redemptionKey = uint256(\n            keccak256(abi.encodePacked(walletPubKeyHash, redeemerOutputScript))\n        );\n\n        // Check if given redemption key is not used by a pending redemption.\n        // There is no need to check for existence in `timedOutRedemptions`\n        // since the wallet's state is changed to other than Live after\n        // first time out is reported so making new requests is not possible.\n        // slither-disable-next-line incorrect-equality\n        require(\n            self.pendingRedemptions[redemptionKey].requestedAt == 0,\n            \"There is a pending redemption request from this wallet to the same address\"\n        );\n\n        // No need to check whether `amount - treasuryFee - txMaxFee > 0`\n        // since the `redemptionDustThreshold` should force that condition\n        // to be always true.\n        uint64 treasuryFee = self.redemptionTreasuryFeeDivisor > 0\n            ? amount / self.redemptionTreasuryFeeDivisor\n            : 0;\n        uint64 txMaxFee = self.redemptionTxMaxFee;\n\n        // The main wallet UTXO's value doesn't include all pending redemptions.\n        // To determine if the requested redemption can be performed by the\n        // wallet we need to subtract the total value of all pending redemptions\n        // from that wallet's main UTXO value. Given that the treasury fee is\n        // not redeemed from the wallet, we are subtracting it.\n        wallet.pendingRedemptionsValue += amount - treasuryFee;\n        require(\n            mainUtxo.txOutputValue >= wallet.pendingRedemptionsValue,\n            \"Insufficient wallet funds\"\n        );\n\n        self.pendingRedemptions[redemptionKey] = RedemptionRequest(\n            msg.sender,\n            amount,\n            treasuryFee,\n            txMaxFee,\n            /* solhint-disable-next-line not-rely-on-time */\n            uint32(block.timestamp)\n        );\n\n        emit RedemptionRequested(\n            walletPubKeyHash,\n            redeemerOutputScript,\n            msg.sender,\n            amount,\n            treasuryFee,\n            txMaxFee\n        );\n\n        self.bank.transferBalanceFrom(msg.sender, address(this), amount);\n    }\n\n    /// @notice Used by the wallet to prove the BTC redemption transaction\n    ///         and to make the necessary bookkeeping. Redemption is only\n    ///         accepted if it satisfies SPV proof.\n    ///\n    ///         The function is performing Bank balance updates by burning\n    ///         the total redeemed Bitcoin amount from Bridge balance and\n    ///         transferring the treasury fee sum to the treasury address.\n    ///\n    ///         It is possible to prove the given redemption only one time.\n    /// @param redemptionTx Bitcoin redemption transaction data.\n    /// @param redemptionProof Bitcoin redemption proof data.\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain.\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    ///        HASH160 over the compressed ECDSA public key) of the wallet which\n    ///        performed the redemption transaction.\n    /// @dev Requirements:\n    ///      - `redemptionTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash,\n    ///      - The `redemptionTx` should represent a Bitcoin transaction with\n    ///        exactly 1 input that refers to the wallet's main UTXO. That\n    ///        transaction should have 1..n outputs handling existing pending\n    ///        redemption requests or pointing to reported timed out requests.\n    ///        There can be also 1 optional output representing the\n    ///        change and pointing back to the 20-byte wallet public key hash.\n    ///        The change should be always present if the redeemed value sum\n    ///        is lower than the total wallet's BTC balance,\n    ///      - `redemptionProof` components must match the expected structure.\n    ///        See `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant,\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        Additionally, the recent main UTXO on Ethereum must be set,\n    ///      - `walletPubKeyHash` must be connected with the main UTXO used\n    ///        as transaction single input.\n    ///      Other remarks:\n    ///      - Putting the change output as the first transaction output can\n    ///        save some gas because the output processing loop begins each\n    ///        iteration by checking whether the given output is the change\n    ///        thus uses some gas for making the comparison. Once the change\n    ///        is identified, that check is omitted in further iterations.\n    function submitRedemptionProof(\n        BridgeState.Storage storage self,\n        BitcoinTx.Info calldata redemptionTx,\n        BitcoinTx.Proof calldata redemptionProof,\n        BitcoinTx.UTXO calldata mainUtxo,\n        bytes20 walletPubKeyHash\n    ) external {\n        // The actual transaction proof is performed here. After that point, we\n        // can assume the transaction happened on Bitcoin chain and has\n        // a sufficient number of confirmations as determined by\n        // `txProofDifficultyFactor` constant.\n        bytes32 redemptionTxHash = self.validateProof(\n            redemptionTx,\n            redemptionProof\n        );\n\n        // Process the redemption transaction input. Specifically, check if it\n        // refers to the expected wallet's main UTXO.\n        OutboundTx.processWalletOutboundTxInput(\n            self,\n            redemptionTx.inputVector,\n            mainUtxo,\n            walletPubKeyHash\n        );\n\n        Wallets.Wallet storage wallet = self.registeredWallets[\n            walletPubKeyHash\n        ];\n\n        Wallets.WalletState walletState = wallet.state;\n        require(\n            walletState == Wallets.WalletState.Live ||\n                walletState == Wallets.WalletState.MovingFunds,\n            \"Wallet must be in Live or MovingFunds state\"\n        );\n\n        // Process redemption transaction outputs to extract some info required\n        // for further processing.\n        RedemptionTxOutputsInfo memory outputsInfo = processRedemptionTxOutputs(\n            self,\n            redemptionTx.outputVector,\n            walletPubKeyHash\n        );\n\n        if (outputsInfo.changeValue > 0) {\n            // If the change value is grater than zero, it means the change\n            // output exists and can be used as new wallet's main UTXO.\n            wallet.mainUtxoHash = keccak256(\n                abi.encodePacked(\n                    redemptionTxHash,\n                    outputsInfo.changeIndex,\n                    outputsInfo.changeValue\n                )\n            );\n        } else {\n            // If the change value is zero, it means the change output doesn't\n            // exists and no funds left on the wallet. Delete the main UTXO\n            // for that wallet to represent that state in a proper way.\n            delete wallet.mainUtxoHash;\n        }\n\n        wallet.pendingRedemptionsValue -= outputsInfo.totalBurnableValue;\n\n        emit RedemptionsCompleted(walletPubKeyHash, redemptionTxHash);\n\n        self.bank.decreaseBalance(outputsInfo.totalBurnableValue);\n        self.bank.transferBalance(self.treasury, outputsInfo.totalTreasuryFee);\n    }\n\n    /// @notice Processes the Bitcoin redemption transaction output vector.\n    ///         It extracts each output and tries to identify it as a pending\n    ///         redemption request, reported timed out request, or change.\n    ///         Reverts if one of the outputs cannot be recognized properly.\n    ///         This function also marks each request as processed by removing\n    ///         them from `pendingRedemptions` mapping.\n    /// @param redemptionTxOutputVector Bitcoin redemption transaction output\n    ///        vector. This function assumes vector's structure is valid so it\n    ///        must be validated using e.g. `BTCUtils.validateVout` function\n    ///        before it is passed here.\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    //         HASH160 over the compressed ECDSA public key) of the wallet which\n    ///        performed the redemption transaction.\n    /// @return info Outcomes of the processing.\n    function processRedemptionTxOutputs(\n        BridgeState.Storage storage self,\n        bytes memory redemptionTxOutputVector,\n        bytes20 walletPubKeyHash\n    ) internal returns (RedemptionTxOutputsInfo memory info) {\n        // Determining the total number of redemption transaction outputs in\n        // the same way as for number of inputs. See `BitcoinTx.outputVector`\n        // docs for more details.\n        (\n            uint256 outputsCompactSizeUintLength,\n            uint256 outputsCount\n        ) = redemptionTxOutputVector.parseVarInt();\n\n        // To determine the first output starting index, we must jump over\n        // the compactSize uint which prepends the output vector. One byte\n        // must be added because `BtcUtils.parseVarInt` does not include\n        // compactSize uint tag in the returned length.\n        //\n        // For >= 0 && <= 252, `BTCUtils.determineVarIntDataLengthAt`\n        // returns `0`, so we jump over one byte of compactSize uint.\n        //\n        // For >= 253 && <= 0xffff there is `0xfd` tag,\n        // `BTCUtils.determineVarIntDataLengthAt` returns `2` (no\n        // tag byte included) so we need to jump over 1+2 bytes of\n        // compactSize uint.\n        //\n        // Please refer `BTCUtils` library and compactSize uint\n        // docs in `BitcoinTx` library for more details.\n        uint256 outputStartingIndex = 1 + outputsCompactSizeUintLength;\n\n        // Calculate the keccak256 for two possible wallet's P2PKH or P2WPKH\n        // scripts that can be used to lock the change. This is done upfront to\n        // save on gas. Both scripts have a strict format defined by Bitcoin.\n        //\n        // The P2PKH script has the byte format: <0x1976a914> <20-byte PKH> <0x88ac>.\n        // According to https://en.bitcoin.it/wiki/Script#Opcodes this translates to:\n        // - 0x19: Byte length of the entire script\n        // - 0x76: OP_DUP\n        // - 0xa9: OP_HASH160\n        // - 0x14: Byte length of the public key hash\n        // - 0x88: OP_EQUALVERIFY\n        // - 0xac: OP_CHECKSIG\n        // which matches the P2PKH structure as per:\n        // https://en.bitcoin.it/wiki/Transaction#Pay-to-PubkeyHash\n        bytes32 walletP2PKHScriptKeccak = keccak256(\n            abi.encodePacked(hex\"1976a914\", walletPubKeyHash, hex\"88ac\")\n        );\n        // The P2WPKH script has the byte format: <0x160014> <20-byte PKH>.\n        // According to https://en.bitcoin.it/wiki/Script#Opcodes this translates to:\n        // - 0x16: Byte length of the entire script\n        // - 0x00: OP_0\n        // - 0x14: Byte length of the public key hash\n        // which matches the P2WPKH structure as per:\n        // https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#P2WPKH\n        bytes32 walletP2WPKHScriptKeccak = keccak256(\n            abi.encodePacked(hex\"160014\", walletPubKeyHash)\n        );\n\n        return\n            processRedemptionTxOutputs(\n                self,\n                redemptionTxOutputVector,\n                walletPubKeyHash,\n                RedemptionTxOutputsProcessingInfo(\n                    outputStartingIndex,\n                    outputsCount,\n                    walletP2PKHScriptKeccak,\n                    walletP2WPKHScriptKeccak\n                )\n            );\n    }\n\n    /// @notice Processes all outputs from the redemption transaction. Tries to\n    ///         identify output as a change output, pending redemption request\n    //          or reported redemption. Reverts if one of the outputs cannot be\n    ///         recognized properly. Marks each request as processed by removing\n    ///         them from `pendingRedemptions` mapping.\n    /// @param redemptionTxOutputVector Bitcoin redemption transaction output\n    ///        vector. This function assumes vector's structure is valid so it\n    ///        must be validated using e.g. `BTCUtils.validateVout` function\n    ///        before it is passed here.\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    //         HASH160 over the compressed ECDSA public key) of the wallet which\n    ///        performed the redemption transaction.\n    /// @param processInfo RedemptionTxOutputsProcessingInfo identifying output\n    ///        starting index, the number of outputs and possible wallet change\n    ///        P2PKH and P2WPKH scripts.\n    function processRedemptionTxOutputs(\n        BridgeState.Storage storage self,\n        bytes memory redemptionTxOutputVector,\n        bytes20 walletPubKeyHash,\n        RedemptionTxOutputsProcessingInfo memory processInfo\n    ) internal returns (RedemptionTxOutputsInfo memory resultInfo) {\n        // Helper flag indicating whether there was at least one redemption\n        // output present (redemption must be either pending or reported as\n        // timed out).\n        bool redemptionPresent = false;\n\n        // Outputs processing loop.\n        for (uint256 i = 0; i < processInfo.outputsCount; i++) {\n            // TODO: Check if we can optimize gas costs by adding\n            //       `extractValueAt` and `extractHashAt` in `bitcoin-spv-sol`\n            //       in order to avoid allocating bytes in memory.\n            //       https://github.com/keep-network/tbtc-v2/issues/257\n            uint256 outputLength = redemptionTxOutputVector\n                .determineOutputLengthAt(processInfo.outputStartingIndex);\n            bytes memory output = redemptionTxOutputVector.slice(\n                processInfo.outputStartingIndex,\n                outputLength\n            );\n\n            // Extract the value from given output.\n            uint64 outputValue = output.extractValue();\n            // The output consists of an 8-byte value and a variable length\n            // script. To extract that script we slice the output starting from\n            // 9th byte until the end.\n            bytes memory outputScript = output.slice(8, output.length - 8);\n\n            if (\n                resultInfo.changeValue == 0 &&\n                (keccak256(outputScript) ==\n                    processInfo.walletP2PKHScriptKeccak ||\n                    keccak256(outputScript) ==\n                    processInfo.walletP2WPKHScriptKeccak) &&\n                outputValue > 0\n            ) {\n                // If we entered here, that means the change output with a\n                // proper non-zero value was found.\n                resultInfo.changeIndex = uint32(i);\n                resultInfo.changeValue = outputValue;\n            } else {\n                // If we entered here, that the means the given output is\n                // supposed to represent a redemption.\n                (\n                    uint64 burnableValue,\n                    uint64 treasuryFee\n                ) = processNonChangeRedemptionTxOutput(\n                        self,\n                        walletPubKeyHash,\n                        outputScript,\n                        outputValue\n                    );\n                resultInfo.totalBurnableValue += burnableValue;\n                resultInfo.totalTreasuryFee += treasuryFee;\n                redemptionPresent = true;\n            }\n\n            // Make the `outputStartingIndex` pointing to the next output by\n            // increasing it by current output's length.\n            processInfo.outputStartingIndex += outputLength;\n        }\n\n        // Protect against the cases when there is only a single change output\n        // referring back to the wallet PKH and just burning main UTXO value\n        // for transaction fees.\n        require(\n            redemptionPresent,\n            \"Redemption transaction must process at least one redemption\"\n        );\n    }\n\n    /// @notice Processes a single redemption transaction output. Tries to\n    ///         identify output as a pending redemption request or reported\n    ///         redemption timeout. Output script passed to this function must\n    ///         not be the change output. Such output needs to be identified\n    ///         separately before calling this function.\n    ///         Reverts if output is neither requested pending redemption nor\n    ///         requested and reported timed-out redemption.\n    ///         This function also marks each pending request as processed by\n    ///         removing them from `pendingRedemptions` mapping.\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    //         HASH160 over the compressed ECDSA public key) of the wallet which\n    ///        performed the redemption transaction.\n    /// @param outputScript Non-change output script to be processed.\n    /// @param outputValue Value of the output being processed.\n    /// @return burnableValue The value burnable as a result of processing this\n    ///         single redemption output. This value needs to be summed up with\n    ///         burnable values of all other outputs to evaluate total burnable\n    ///         value for the entire redemption transaction. This value is 0\n    ///         for a timed-out redemption request.\n    /// @return treasuryFee The treasury fee from this single redemption output.\n    ///         This value needs to be summed up with treasury fees of all other\n    ///         outputs to evaluate the total treasury fee for the entire\n    ///         redemption transaction. This value is 0 for a timed-out\n    ///         redemption request.\n    function processNonChangeRedemptionTxOutput(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        bytes memory outputScript,\n        uint64 outputValue\n    ) internal returns (uint64 burnableValue, uint64 treasuryFee) {\n        // This function should be called only if the given output is\n        // supposed to represent a redemption. Build the redemption key\n        // to perform that check.\n        uint256 redemptionKey = uint256(\n            keccak256(abi.encodePacked(walletPubKeyHash, outputScript))\n        );\n\n        if (self.pendingRedemptions[redemptionKey].requestedAt != 0) {\n            // If we entered here, that means the output was identified\n            // as a pending redemption request.\n            RedemptionRequest storage request = self.pendingRedemptions[\n                redemptionKey\n            ];\n            // Compute the request's redeemable amount as the requested\n            // amount reduced by the treasury fee. The request's\n            // minimal amount is then the redeemable amount reduced by\n            // the maximum transaction fee.\n            uint64 redeemableAmount = request.requestedAmount -\n                request.treasuryFee;\n            // Output value must fit between the request's redeemable\n            // and minimal amounts to be deemed valid.\n            require(\n                redeemableAmount - request.txMaxFee <= outputValue &&\n                    outputValue <= redeemableAmount,\n                \"Output value is not within the acceptable range of the pending request\"\n            );\n            // Add the redeemable amount to the total burnable value\n            // the Bridge will use to decrease its balance in the Bank.\n            burnableValue = redeemableAmount;\n            // Add the request's treasury fee to the total treasury fee\n            // value the Bridge will transfer to the treasury.\n            treasuryFee = request.treasuryFee;\n            // Request was properly handled so remove its redemption\n            // key from the mapping to make it reusable for further\n            // requests.\n            delete self.pendingRedemptions[redemptionKey];\n        } else {\n            // If we entered here, the output is not a redemption\n            // request but there is still a chance the given output is\n            // related to a reported timed out redemption request.\n            // If so, check if the output value matches the request\n            // amount to confirm this is an overdue request fulfillment\n            // then bypass this output and process the subsequent\n            // ones. That also means the wallet was already punished\n            // for the inactivity. Otherwise, just revert.\n            RedemptionRequest storage request = self.timedOutRedemptions[\n                redemptionKey\n            ];\n\n            require(\n                request.requestedAt != 0,\n                \"Output is a non-requested redemption\"\n            );\n\n            uint64 redeemableAmount = request.requestedAmount -\n                request.treasuryFee;\n\n            require(\n                redeemableAmount - request.txMaxFee <= outputValue &&\n                    outputValue <= redeemableAmount,\n                \"Output value is not within the acceptable range of the timed out request\"\n            );\n        }\n    }\n\n    /// @notice Notifies that there is a pending redemption request associated\n    ///         with the given wallet, that has timed out. The redemption\n    ///         request is identified by the key built as\n    ///         `keccak256(walletPubKeyHash | redeemerOutputScript)`.\n    ///         The results of calling this function:\n    ///         - the pending redemptions value for the wallet will be decreased\n    ///           by the requested amount (minus treasury fee),\n    ///         - the tokens taken from the redeemer on redemption request will\n    ///           be returned to the redeemer,\n    ///         - the request will be moved from pending redemptions to\n    ///           timed-out redemptions,\n    ///         - if the state of the wallet is `Live` or `MovingFunds`, the\n    ///           wallet operators will be slashed and the notifier will be\n    ///           rewarded,\n    ///         - if the state of wallet is `Live`, the wallet will be closed or\n    ///           marked as `MovingFunds` (depending on the presence or absence\n    ///           of the wallet's main UTXO) and the wallet will no longer be\n    ///           marked as the active wallet (if it was marked as such).\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet.\n    /// @param walletMembersIDs Identifiers of the wallet signing group members.\n    /// @param redeemerOutputScript  The redeemer's length-prefixed output\n    ///        script (P2PKH, P2WPKH, P2SH or P2WSH).\n    /// @dev Requirements:\n    ///      - The wallet must be in the Live or MovingFunds or Terminated state,\n    ///      - The redemption request identified by `walletPubKeyHash` and\n    ///        `redeemerOutputScript` must exist,\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract,\n    ///      - The amount of time defined by `redemptionTimeout` must have\n    ///        passed since the redemption was requested (the request must be\n    ///        timed-out).\n    function notifyRedemptionTimeout(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        uint32[] calldata walletMembersIDs,\n        bytes calldata redeemerOutputScript\n    ) external {\n        uint256 redemptionKey = uint256(\n            keccak256(abi.encodePacked(walletPubKeyHash, redeemerOutputScript))\n        );\n        Redemption.RedemptionRequest memory request = self.pendingRedemptions[\n            redemptionKey\n        ];\n\n        require(request.requestedAt > 0, \"Redemption request does not exist\");\n        require(\n            /* solhint-disable-next-line not-rely-on-time */\n            request.requestedAt + self.redemptionTimeout < block.timestamp,\n            \"Redemption request has not timed out\"\n        );\n\n        // Update the wallet's pending redemptions value\n        Wallets.Wallet storage wallet = self.registeredWallets[\n            walletPubKeyHash\n        ];\n        wallet.pendingRedemptionsValue -=\n            request.requestedAmount -\n            request.treasuryFee;\n\n        require(\n            wallet.state == Wallets.WalletState.Live ||\n                wallet.state == Wallets.WalletState.MovingFunds ||\n                wallet.state == Wallets.WalletState.Terminated,\n            \"The wallet must be in Live, MovingFunds or Terminated state\"\n        );\n\n        // It is worth noting that there is no need to check if\n        // `timedOutRedemption` mapping already contains the given redemption\n        // key. There is no possibility to re-use a key of a reported timed-out\n        // redemption because the wallet responsible for causing the timeout is\n        // moved to a state that prevents it to receive new redemption requests.\n\n        // Move the redemption from pending redemptions to timed-out redemptions\n        self.timedOutRedemptions[redemptionKey] = request;\n        delete self.pendingRedemptions[redemptionKey];\n\n        if (\n            wallet.state == Wallets.WalletState.Live ||\n            wallet.state == Wallets.WalletState.MovingFunds\n        ) {\n            // Propagate timeout consequences to the wallet\n            self.notifyWalletTimedOutRedemption(walletPubKeyHash);\n\n            // Slash the wallet operators and reward the notifier\n            self.ecdsaWalletRegistry.seize(\n                self.redemptionTimeoutSlashingAmount,\n                self.redemptionTimeoutNotifierRewardMultiplier,\n                msg.sender,\n                wallet.ecdsaWalletID,\n                walletMembersIDs\n            );\n        }\n\n        // slither-disable-next-line reentrancy-events\n        emit RedemptionTimedOut(walletPubKeyHash, redeemerOutputScript);\n\n        // Return the requested amount of tokens to the redeemer\n        self.bank.transferBalance(request.redeemer, request.requestedAmount);\n    }\n}\n"
+      "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\nimport {BTCUtils} from \"@keep-network/bitcoin-spv-sol/contracts/BTCUtils.sol\";\nimport {BytesLib} from \"@keep-network/bitcoin-spv-sol/contracts/BytesLib.sol\";\n\nimport \"./BitcoinTx.sol\";\nimport \"./BridgeState.sol\";\nimport \"./Wallets.sol\";\n\nimport \"../bank/Bank.sol\";\n\n/// @notice Aggregates functions common to the redemption transaction proof\n///         validation and to the moving funds transaction proof validation.\nlibrary OutboundTx {\n    using BTCUtils for bytes;\n\n    /// @notice Checks whether an outbound Bitcoin transaction performed from\n    ///         the given wallet has an input vector that contains a single\n    ///         input referring to the wallet's main UTXO. Marks that main UTXO\n    ///         as correctly spent if the validation succeeds. Reverts otherwise.\n    ///         There are two outbound transactions from a wallet possible: a\n    ///         redemption transaction or a moving funds to another wallet\n    ///         transaction.\n    /// @param walletOutboundTxInputVector Bitcoin outbound transaction's input\n    ///        vector. This function assumes vector's structure is valid so it\n    ///        must be validated using e.g. `BTCUtils.validateVin` function\n    ///        before it is passed here.\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain.\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    //         HASH160 over the compressed ECDSA public key) of the wallet which\n    ///        performed the outbound transaction.\n    function processWalletOutboundTxInput(\n        BridgeState.Storage storage self,\n        bytes memory walletOutboundTxInputVector,\n        BitcoinTx.UTXO calldata mainUtxo,\n        bytes20 walletPubKeyHash\n    ) internal {\n        // Assert that main UTXO for passed wallet exists in storage.\n        bytes32 mainUtxoHash = self\n            .registeredWallets[walletPubKeyHash]\n            .mainUtxoHash;\n        require(mainUtxoHash != bytes32(0), \"No main UTXO for given wallet\");\n\n        // Assert that passed main UTXO parameter is the same as in storage and\n        // can be used for further processing.\n        require(\n            keccak256(\n                abi.encodePacked(\n                    mainUtxo.txHash,\n                    mainUtxo.txOutputIndex,\n                    mainUtxo.txOutputValue\n                )\n            ) == mainUtxoHash,\n            \"Invalid main UTXO data\"\n        );\n\n        // Assert that the single outbound transaction input actually\n        // refers to the wallet's main UTXO.\n        (\n            bytes32 outpointTxHash,\n            uint32 outpointIndex\n        ) = parseWalletOutboundTxInput(walletOutboundTxInputVector);\n        require(\n            mainUtxo.txHash == outpointTxHash &&\n                mainUtxo.txOutputIndex == outpointIndex,\n            \"Outbound transaction input must point to the wallet's main UTXO\"\n        );\n\n        // Main UTXO used as an input, mark it as spent.\n        self.spentMainUTXOs[\n            uint256(\n                keccak256(\n                    abi.encodePacked(mainUtxo.txHash, mainUtxo.txOutputIndex)\n                )\n            )\n        ] = true;\n    }\n\n    /// @notice Parses the input vector of an outbound Bitcoin transaction\n    ///         performed from the given wallet. It extracts the single input\n    ///         then the transaction hash and output index from its outpoint.\n    ///         There are two outbound transactions from a wallet possible: a\n    ///         redemption transaction or a moving funds to another wallet\n    ///         transaction.\n    /// @param walletOutboundTxInputVector Bitcoin outbound transaction input\n    ///        vector. This function assumes vector's structure is valid so it\n    ///        must be validated using e.g. `BTCUtils.validateVin` function\n    ///        before it is passed here.\n    /// @return outpointTxHash 32-byte hash of the Bitcoin transaction which is\n    ///         pointed in the input's outpoint.\n    /// @return outpointIndex 4-byte index of the Bitcoin transaction output\n    ///         which is pointed in the input's outpoint.\n    function parseWalletOutboundTxInput(\n        bytes memory walletOutboundTxInputVector\n    ) internal pure returns (bytes32 outpointTxHash, uint32 outpointIndex) {\n        // To determine the total number of Bitcoin transaction inputs,\n        // we need to parse the compactSize uint (VarInt) the input vector is\n        // prepended by. That compactSize uint encodes the number of vector\n        // elements using the format presented in:\n        // https://developer.bitcoin.org/reference/transactions.html#compactsize-unsigned-integers\n        // We don't need asserting the compactSize uint is parseable since it\n        // was already checked during `validateVin` validation.\n        // See `BitcoinTx.inputVector` docs for more details.\n        (, uint256 inputsCount) = walletOutboundTxInputVector.parseVarInt();\n        require(\n            inputsCount == 1,\n            \"Outbound transaction must have a single input\"\n        );\n\n        bytes memory input = walletOutboundTxInputVector.extractInputAtIndex(0);\n\n        outpointTxHash = input.extractInputTxIdLE();\n\n        outpointIndex = BTCUtils.reverseUint32(\n            uint32(input.extractTxIndexLE())\n        );\n\n        // There is only one input in the transaction. Input has an outpoint\n        // field that is a reference to the transaction being spent (see\n        // `BitcoinTx` docs). The outpoint contains the hash of the transaction\n        // to spend (`outpointTxHash`) and the index of the specific output\n        // from that transaction (`outpointIndex`).\n        return (outpointTxHash, outpointIndex);\n    }\n}\n\n/// @title Bridge redemption\n/// @notice The library handles the logic for redeeming Bitcoin balances from\n///         the Bridge.\n/// @dev To initiate a redemption, a user with a Bank balance supplies\n///      a Bitcoin address. Then, the system calculates the redemption fee, and\n///      releases balance to the provided Bitcoin address. Just like in case of\n///      sweeps of revealed deposits, redemption requests are processed in\n///      batches and require SPV proof to be submitted to the Bridge.\nlibrary Redemption {\n    using BridgeState for BridgeState.Storage;\n    using Wallets for BridgeState.Storage;\n    using BitcoinTx for BridgeState.Storage;\n\n    using BTCUtils for bytes;\n    using BytesLib for bytes;\n\n    /// @notice Represents a redemption request.\n    struct RedemptionRequest {\n        // ETH address of the redeemer who created the request.\n        address redeemer;\n        // Requested TBTC amount in satoshi.\n        uint64 requestedAmount;\n        // Treasury TBTC fee in satoshi at the moment of request creation.\n        uint64 treasuryFee;\n        // Transaction maximum BTC fee in satoshi at the moment of request\n        // creation.\n        uint64 txMaxFee;\n        // UNIX timestamp the request was created at.\n        uint32 requestedAt;\n        // This struct doesn't contain `__gap` property as the structure is stored\n        // in a mapping, mappings store values in different slots and they are\n        // not contiguous with other values.\n    }\n\n    /// @notice Represents an outcome of the redemption Bitcoin transaction\n    ///         outputs processing.\n    struct RedemptionTxOutputsInfo {\n        // Total TBTC value in satoshi that should be burned by the Bridge.\n        // It includes the total amount of all BTC redeemed in the transaction\n        // and the fee paid to BTC miners for the redemption transaction.\n        uint64 totalBurnableValue;\n        // Total TBTC value in satoshi that should be transferred to\n        // the treasury. It is a sum of all treasury fees paid by all\n        // redeemers included in the redemption transaction.\n        uint64 totalTreasuryFee;\n        // Index of the change output. The change output becomes\n        // the new main wallet's UTXO.\n        uint32 changeIndex;\n        // Value in satoshi of the change output.\n        uint64 changeValue;\n        // This struct doesn't contain `__gap` property as the structure is not\n        // stored, it is used as a function's memory argument.\n    }\n\n    /// @notice Represents temporary information needed during the processing of\n    ///         the redemption Bitcoin transaction outputs. This structure is an\n    ///         internal one and should not be exported outside of the redemption\n    ///         transaction processing code.\n    /// @dev Allows to mitigate \"stack too deep\" errors on EVM.\n    struct RedemptionTxOutputsProcessingInfo {\n        // The first output starting index in the transaction.\n        uint256 outputStartingIndex;\n        // The number of outputs in the transaction.\n        uint256 outputsCount;\n        // P2PKH script for the wallet. Needed to determine the change output.\n        bytes32 walletP2PKHScriptKeccak;\n        // P2WPKH script for the wallet. Needed to determine the change output.\n        bytes32 walletP2WPKHScriptKeccak;\n        // This struct doesn't contain `__gap` property as the structure is not\n        // stored, it is used as a function's memory argument.\n    }\n\n    event RedemptionRequested(\n        bytes20 indexed walletPubKeyHash,\n        bytes redeemerOutputScript,\n        address indexed redeemer,\n        uint64 requestedAmount,\n        uint64 treasuryFee,\n        uint64 txMaxFee\n    );\n\n    event RedemptionsCompleted(\n        bytes20 indexed walletPubKeyHash,\n        bytes32 redemptionTxHash\n    );\n\n    event RedemptionTimedOut(\n        bytes20 indexed walletPubKeyHash,\n        bytes redeemerOutputScript\n    );\n\n    /// @notice Requests redemption of the given amount from the specified\n    ///         wallet to the redeemer Bitcoin output script.\n    ///         This function handles the simplest case, where balance owner is\n    ///         the redeemer.\n    /// @param walletPubKeyHash The 20-byte wallet public key hash (computed\n    ///        using Bitcoin HASH160 over the compressed ECDSA public key).\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain.\n    /// @param balanceOwner The address of the Bank balance owner whose balance\n    ///        is getting redeemed. Balance owner address is stored as\n    ///        a redemeer address who will be able co claim back the Bank\n    ///        balance if anything goes wrong during the redemption.\n    /// @param redeemerOutputScript The redeemer's length-prefixed output\n    ///        script (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock\n    ///        redeemed BTC.\n    /// @param amount Requested amount in satoshi. This is also the Bank balance\n    ///        that is taken from the `balanceOwner` upon request.\n    ///        Once the request is handled, the actual amount of BTC locked\n    ///        on the redeemer output script will be always lower than this value\n    ///        since the treasury and Bitcoin transaction fees must be incurred.\n    ///        The minimal amount satisfying the request can be computed as:\n    ///        `amount - (amount / redemptionTreasuryFeeDivisor) - redemptionTxMaxFee`.\n    ///        Fees values are taken at the moment of request creation.\n    /// @dev Requirements:\n    ///      - Wallet behind `walletPubKeyHash` must be live,\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain,\n    ///      - `redeemerOutputScript` must be a proper Bitcoin script,\n    ///      - `redeemerOutputScript` cannot have wallet PKH as payload,\n    ///      - `amount` must be above or equal the `redemptionDustThreshold`,\n    ///      - Given `walletPubKeyHash` and `redeemerOutputScript` pair can be\n    ///        used for only one pending request at the same time,\n    ///      - Wallet must have enough Bitcoin balance to proceed the request,\n    ///      - Balance owner must make an allowance in the Bank that the Bridge\n    ///        contract can spend the given `amount`.\n    function requestRedemption(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata mainUtxo,\n        address balanceOwner,\n        bytes calldata redeemerOutputScript,\n        uint64 amount\n    ) external {\n        requestRedemption(\n            self,\n            walletPubKeyHash,\n            mainUtxo,\n            balanceOwner,\n            balanceOwner,\n            redeemerOutputScript,\n            amount\n        );\n    }\n\n    /// @notice Requests redemption of the given amount from the specified\n    ///         wallet to the redeemer Bitcoin output script. Used by\n    ///         `Bridge.receiveBalanceApproval`. Can handle more complex cases\n    ///         where balance owner may be someone else than the redeemer.\n    /// @param balanceOwner The address of the Bank balance owner whose balance\n    ///        is getting redeemed.\n    /// @param amount Requested amount in satoshi. This is also the Bank balance\n    ///        that is taken from the `balanceOwner` upon request.\n    ///        Once the request is handled, the actual amount of BTC locked\n    ///        on the redeemer output script will be always lower than this value\n    ///        since the treasury and Bitcoin transaction fees must be incurred.\n    ///        The minimal amount satisfying the request can be computed as:\n    ///        `amount - (amount / redemptionTreasuryFeeDivisor) - redemptionTxMaxFee`.\n    ///        Fees values are taken at the moment of request creation.\n    /// @param redemptionData ABI-encoded redemption data:\n    ///        [\n    ///          address redeemer,\n    ///          bytes20 walletPubKeyHash,\n    ///          bytes32 mainUtxoTxHash,\n    ///          uint32 mainUtxoTxOutputIndex,\n    ///          uint64 mainUtxoTxOutputValue,\n    ///          bytes redeemerOutputScript\n    ///        ]\n    ///\n    ///        - redeemer: The Ethereum address of the redeemer who will be able\n    ///        to claim Bank balance if anything goes wrong during the redemption.\n    ///        In the most basic case, when someone redeems their Bitcoin\n    ///        balance from the Bank, `balanceOwner` is the same as `redemeer`.\n    ///        However, when a Vault is redeeming part of its balance for some\n    ///        redeemer address (for example, someone who has earlier deposited\n    ///        into that Vault), `balanceOwner` is the Vault, and `redemeer` is\n    ///        the address for which the vault is redeeming its balance to,\n    ///        - walletPubKeyHash: The 20-byte wallet public key hash (computed\n    ///        using Bitcoin HASH160 over the compressed ECDSA public key),\n    ///        - mainUtxoTxHash: Data of the wallet's main UTXO TX hash, as\n    ///        currently known on the Ethereum chain,\n    ///        - mainUtxoTxOutputIndex: Data of the wallet's main UTXO output\n    ///        index, as currently known on Ethereum chain,\n    ///        - mainUtxoTxOutputValue: Data of the wallet's main UTXO output\n    ///        value, as currently known on Ethereum chain,\n    ///        - redeemerOutputScript The redeemer's length-prefixed output\n    ///        script (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock\n    ///        redeemed BTC.\n    /// @dev Requirements:\n    ///      - Wallet behind `walletPubKeyHash` must be live,\n    ///      - `mainUtxo*` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain,\n    ///      - `redeemerOutputScript` must be a proper Bitcoin script,\n    ///      - `redeemerOutputScript` cannot have wallet PKH as payload,\n    ///      - `amount` must be above or equal the `redemptionDustThreshold`,\n    ///      - Given `walletPubKeyHash` and `redeemerOutputScript` pair can be\n    ///        used for only one pending request at the same time,\n    ///      - Wallet must have enough Bitcoin balance to proceed the request,\n    ///      - Balance owner must make an allowance in the Bank that the Bridge\n    ///        contract can spend the given `amount`.\n    function requestRedemption(\n        BridgeState.Storage storage self,\n        address balanceOwner,\n        uint64 amount,\n        bytes calldata redemptionData\n    ) external {\n        (\n            address redeemer,\n            bytes20 walletPubKeyHash,\n            bytes32 mainUtxoTxHash,\n            uint32 mainUtxoTxOutputIndex,\n            uint64 mainUtxoTxOutputValue,\n            bytes memory redeemerOutputScript\n        ) = abi.decode(\n                redemptionData,\n                (address, bytes20, bytes32, uint32, uint64, bytes)\n            );\n\n        requestRedemption(\n            self,\n            walletPubKeyHash,\n            BitcoinTx.UTXO(\n                mainUtxoTxHash,\n                mainUtxoTxOutputIndex,\n                mainUtxoTxOutputValue\n            ),\n            balanceOwner,\n            redeemer,\n            redeemerOutputScript,\n            amount\n        );\n    }\n\n    /// @notice Requests redemption of the given amount from the specified\n    ///         wallet to the redeemer Bitcoin output script.\n    /// @param walletPubKeyHash The 20-byte wallet public key hash (computed\n    ///        using Bitcoin HASH160 over the compressed ECDSA public key).\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain.\n    /// @param balanceOwner The address of the Bank balance owner whose balance\n    ///        is getting redeemed.\n    /// @param redeemer The Ethereum address of the redeemer who will be able to\n    ///        claim Bank balance if anything goes wrong during the redemption.\n    ///        In the most basic case, when someone redeems their Bitcoin\n    ///        balance from the Bank, `balanceOwner` is the same as `redemeer`.\n    ///        However, when a Vault is redeeming part of its balance for some\n    ///        redeemer address (for example, someone who has earlier deposited\n    ///        into that Vault), `balanceOwner` is the Vault, and `redemeer` is\n    ///        the address for which the vault is redeeming its balance to.\n    /// @param redeemerOutputScript The redeemer's length-prefixed output\n    ///        script (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock\n    ///        redeemed BTC.\n    /// @param amount Requested amount in satoshi. This is also the Bank balance\n    ///        that is taken from the `balanceOwner` upon request.\n    ///        Once the request is handled, the actual amount of BTC locked\n    ///        on the redeemer output script will be always lower than this value\n    ///        since the treasury and Bitcoin transaction fees must be incurred.\n    ///        The minimal amount satisfying the request can be computed as:\n    ///        `amount - (amount / redemptionTreasuryFeeDivisor) - redemptionTxMaxFee`.\n    ///        Fees values are taken at the moment of request creation.\n    /// @dev Requirements:\n    ///      - Wallet behind `walletPubKeyHash` must be live,\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain,\n    ///      - `redeemerOutputScript` must be a proper Bitcoin script,\n    ///      - `redeemerOutputScript` cannot have wallet PKH as payload,\n    ///      - `amount` must be above or equal the `redemptionDustThreshold`,\n    ///      - Given `walletPubKeyHash` and `redeemerOutputScript` pair can be\n    ///        used for only one pending request at the same time,\n    ///      - Wallet must have enough Bitcoin balance to proceed the request,\n    ///      - Balance owner must make an allowance in the Bank that the Bridge\n    ///        contract can spend the given `amount`.\n    function requestRedemption(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO memory mainUtxo,\n        address balanceOwner,\n        address redeemer,\n        bytes memory redeemerOutputScript,\n        uint64 amount\n    ) internal {\n        Wallets.Wallet storage wallet = self.registeredWallets[\n            walletPubKeyHash\n        ];\n\n        require(\n            wallet.state == Wallets.WalletState.Live,\n            \"Wallet must be in Live state\"\n        );\n\n        bytes32 mainUtxoHash = wallet.mainUtxoHash;\n        require(\n            mainUtxoHash != bytes32(0),\n            \"No main UTXO for the given wallet\"\n        );\n        require(\n            keccak256(\n                abi.encodePacked(\n                    mainUtxo.txHash,\n                    mainUtxo.txOutputIndex,\n                    mainUtxo.txOutputValue\n                )\n            ) == mainUtxoHash,\n            \"Invalid main UTXO data\"\n        );\n\n        // Validate if redeemer output script is a correct standard type\n        // (P2PKH, P2WPKH, P2SH or P2WSH). This is done by building a stub\n        // output with 0 as value and using `BTCUtils.extractHash` on it. Such\n        // a function extracts the payload properly only from standard outputs\n        // so if it succeeds, we have a guarantee the redeemer output script\n        // is proper. Worth to note `extractHash` ignores the value at all\n        // so this is why we can use 0 safely. This way of validation is the\n        // same as in tBTC v1.\n        bytes memory redeemerOutputScriptPayload = abi\n            .encodePacked(bytes8(0), redeemerOutputScript)\n            .extractHash();\n        require(\n            redeemerOutputScriptPayload.length > 0,\n            \"Redeemer output script must be a standard type\"\n        );\n        // Check if the redeemer output script payload does not point to the\n        // wallet public key hash.\n        require(\n            keccak256(abi.encodePacked(walletPubKeyHash)) !=\n                keccak256(redeemerOutputScriptPayload),\n            \"Redeemer output script must not point to the wallet PKH\"\n        );\n\n        require(\n            amount >= self.redemptionDustThreshold,\n            \"Redemption amount too small\"\n        );\n\n        // The redemption key is built on top of the wallet public key hash\n        // and redeemer output script pair. That means there can be only one\n        // request asking for redemption from the given wallet to the given\n        // BTC script at the same time.\n        uint256 redemptionKey = uint256(\n            keccak256(abi.encodePacked(walletPubKeyHash, redeemerOutputScript))\n        );\n\n        // Check if given redemption key is not used by a pending redemption.\n        // There is no need to check for existence in `timedOutRedemptions`\n        // since the wallet's state is changed to other than Live after\n        // first time out is reported so making new requests is not possible.\n        // slither-disable-next-line incorrect-equality\n        require(\n            self.pendingRedemptions[redemptionKey].requestedAt == 0,\n            \"There is a pending redemption request from this wallet to the same address\"\n        );\n\n        // No need to check whether `amount - treasuryFee - txMaxFee > 0`\n        // since the `redemptionDustThreshold` should force that condition\n        // to be always true.\n        uint64 treasuryFee = self.redemptionTreasuryFeeDivisor > 0\n            ? amount / self.redemptionTreasuryFeeDivisor\n            : 0;\n        uint64 txMaxFee = self.redemptionTxMaxFee;\n\n        // The main wallet UTXO's value doesn't include all pending redemptions.\n        // To determine if the requested redemption can be performed by the\n        // wallet we need to subtract the total value of all pending redemptions\n        // from that wallet's main UTXO value. Given that the treasury fee is\n        // not redeemed from the wallet, we are subtracting it.\n        wallet.pendingRedemptionsValue += amount - treasuryFee;\n        require(\n            mainUtxo.txOutputValue >= wallet.pendingRedemptionsValue,\n            \"Insufficient wallet funds\"\n        );\n\n        self.pendingRedemptions[redemptionKey] = RedemptionRequest(\n            redeemer,\n            amount,\n            treasuryFee,\n            txMaxFee,\n            /* solhint-disable-next-line not-rely-on-time */\n            uint32(block.timestamp)\n        );\n\n        emit RedemptionRequested(\n            walletPubKeyHash,\n            redeemerOutputScript,\n            redeemer,\n            amount,\n            treasuryFee,\n            txMaxFee\n        );\n\n        self.bank.transferBalanceFrom(balanceOwner, address(this), amount);\n    }\n\n    /// @notice Used by the wallet to prove the BTC redemption transaction\n    ///         and to make the necessary bookkeeping. Redemption is only\n    ///         accepted if it satisfies SPV proof.\n    ///\n    ///         The function is performing Bank balance updates by burning\n    ///         the total redeemed Bitcoin amount from Bridge balance and\n    ///         transferring the treasury fee sum to the treasury address.\n    ///\n    ///         It is possible to prove the given redemption only one time.\n    /// @param redemptionTx Bitcoin redemption transaction data.\n    /// @param redemptionProof Bitcoin redemption proof data.\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain.\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    ///        HASH160 over the compressed ECDSA public key) of the wallet which\n    ///        performed the redemption transaction.\n    /// @dev Requirements:\n    ///      - `redemptionTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash,\n    ///      - The `redemptionTx` should represent a Bitcoin transaction with\n    ///        exactly 1 input that refers to the wallet's main UTXO. That\n    ///        transaction should have 1..n outputs handling existing pending\n    ///        redemption requests or pointing to reported timed out requests.\n    ///        There can be also 1 optional output representing the\n    ///        change and pointing back to the 20-byte wallet public key hash.\n    ///        The change should be always present if the redeemed value sum\n    ///        is lower than the total wallet's BTC balance,\n    ///      - `redemptionProof` components must match the expected structure.\n    ///        See `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant,\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        Additionally, the recent main UTXO on Ethereum must be set,\n    ///      - `walletPubKeyHash` must be connected with the main UTXO used\n    ///        as transaction single input.\n    ///      Other remarks:\n    ///      - Putting the change output as the first transaction output can\n    ///        save some gas because the output processing loop begins each\n    ///        iteration by checking whether the given output is the change\n    ///        thus uses some gas for making the comparison. Once the change\n    ///        is identified, that check is omitted in further iterations.\n    function submitRedemptionProof(\n        BridgeState.Storage storage self,\n        BitcoinTx.Info calldata redemptionTx,\n        BitcoinTx.Proof calldata redemptionProof,\n        BitcoinTx.UTXO calldata mainUtxo,\n        bytes20 walletPubKeyHash\n    ) external {\n        // The actual transaction proof is performed here. After that point, we\n        // can assume the transaction happened on Bitcoin chain and has\n        // a sufficient number of confirmations as determined by\n        // `txProofDifficultyFactor` constant.\n        bytes32 redemptionTxHash = self.validateProof(\n            redemptionTx,\n            redemptionProof\n        );\n\n        // Process the redemption transaction input. Specifically, check if it\n        // refers to the expected wallet's main UTXO.\n        OutboundTx.processWalletOutboundTxInput(\n            self,\n            redemptionTx.inputVector,\n            mainUtxo,\n            walletPubKeyHash\n        );\n\n        Wallets.Wallet storage wallet = self.registeredWallets[\n            walletPubKeyHash\n        ];\n\n        Wallets.WalletState walletState = wallet.state;\n        require(\n            walletState == Wallets.WalletState.Live ||\n                walletState == Wallets.WalletState.MovingFunds,\n            \"Wallet must be in Live or MovingFunds state\"\n        );\n\n        // Process redemption transaction outputs to extract some info required\n        // for further processing.\n        RedemptionTxOutputsInfo memory outputsInfo = processRedemptionTxOutputs(\n            self,\n            redemptionTx.outputVector,\n            walletPubKeyHash\n        );\n\n        if (outputsInfo.changeValue > 0) {\n            // If the change value is grater than zero, it means the change\n            // output exists and can be used as new wallet's main UTXO.\n            wallet.mainUtxoHash = keccak256(\n                abi.encodePacked(\n                    redemptionTxHash,\n                    outputsInfo.changeIndex,\n                    outputsInfo.changeValue\n                )\n            );\n        } else {\n            // If the change value is zero, it means the change output doesn't\n            // exists and no funds left on the wallet. Delete the main UTXO\n            // for that wallet to represent that state in a proper way.\n            delete wallet.mainUtxoHash;\n        }\n\n        wallet.pendingRedemptionsValue -= outputsInfo.totalBurnableValue;\n\n        emit RedemptionsCompleted(walletPubKeyHash, redemptionTxHash);\n\n        self.bank.decreaseBalance(outputsInfo.totalBurnableValue);\n        self.bank.transferBalance(self.treasury, outputsInfo.totalTreasuryFee);\n    }\n\n    /// @notice Processes the Bitcoin redemption transaction output vector.\n    ///         It extracts each output and tries to identify it as a pending\n    ///         redemption request, reported timed out request, or change.\n    ///         Reverts if one of the outputs cannot be recognized properly.\n    ///         This function also marks each request as processed by removing\n    ///         them from `pendingRedemptions` mapping.\n    /// @param redemptionTxOutputVector Bitcoin redemption transaction output\n    ///        vector. This function assumes vector's structure is valid so it\n    ///        must be validated using e.g. `BTCUtils.validateVout` function\n    ///        before it is passed here.\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    //         HASH160 over the compressed ECDSA public key) of the wallet which\n    ///        performed the redemption transaction.\n    /// @return info Outcomes of the processing.\n    function processRedemptionTxOutputs(\n        BridgeState.Storage storage self,\n        bytes memory redemptionTxOutputVector,\n        bytes20 walletPubKeyHash\n    ) internal returns (RedemptionTxOutputsInfo memory info) {\n        // Determining the total number of redemption transaction outputs in\n        // the same way as for number of inputs. See `BitcoinTx.outputVector`\n        // docs for more details.\n        (\n            uint256 outputsCompactSizeUintLength,\n            uint256 outputsCount\n        ) = redemptionTxOutputVector.parseVarInt();\n\n        // To determine the first output starting index, we must jump over\n        // the compactSize uint which prepends the output vector. One byte\n        // must be added because `BtcUtils.parseVarInt` does not include\n        // compactSize uint tag in the returned length.\n        //\n        // For >= 0 && <= 252, `BTCUtils.determineVarIntDataLengthAt`\n        // returns `0`, so we jump over one byte of compactSize uint.\n        //\n        // For >= 253 && <= 0xffff there is `0xfd` tag,\n        // `BTCUtils.determineVarIntDataLengthAt` returns `2` (no\n        // tag byte included) so we need to jump over 1+2 bytes of\n        // compactSize uint.\n        //\n        // Please refer `BTCUtils` library and compactSize uint\n        // docs in `BitcoinTx` library for more details.\n        uint256 outputStartingIndex = 1 + outputsCompactSizeUintLength;\n\n        // Calculate the keccak256 for two possible wallet's P2PKH or P2WPKH\n        // scripts that can be used to lock the change. This is done upfront to\n        // save on gas. Both scripts have a strict format defined by Bitcoin.\n        //\n        // The P2PKH script has the byte format: <0x1976a914> <20-byte PKH> <0x88ac>.\n        // According to https://en.bitcoin.it/wiki/Script#Opcodes this translates to:\n        // - 0x19: Byte length of the entire script\n        // - 0x76: OP_DUP\n        // - 0xa9: OP_HASH160\n        // - 0x14: Byte length of the public key hash\n        // - 0x88: OP_EQUALVERIFY\n        // - 0xac: OP_CHECKSIG\n        // which matches the P2PKH structure as per:\n        // https://en.bitcoin.it/wiki/Transaction#Pay-to-PubkeyHash\n        bytes32 walletP2PKHScriptKeccak = keccak256(\n            abi.encodePacked(hex\"1976a914\", walletPubKeyHash, hex\"88ac\")\n        );\n        // The P2WPKH script has the byte format: <0x160014> <20-byte PKH>.\n        // According to https://en.bitcoin.it/wiki/Script#Opcodes this translates to:\n        // - 0x16: Byte length of the entire script\n        // - 0x00: OP_0\n        // - 0x14: Byte length of the public key hash\n        // which matches the P2WPKH structure as per:\n        // https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#P2WPKH\n        bytes32 walletP2WPKHScriptKeccak = keccak256(\n            abi.encodePacked(hex\"160014\", walletPubKeyHash)\n        );\n\n        return\n            processRedemptionTxOutputs(\n                self,\n                redemptionTxOutputVector,\n                walletPubKeyHash,\n                RedemptionTxOutputsProcessingInfo(\n                    outputStartingIndex,\n                    outputsCount,\n                    walletP2PKHScriptKeccak,\n                    walletP2WPKHScriptKeccak\n                )\n            );\n    }\n\n    /// @notice Processes all outputs from the redemption transaction. Tries to\n    ///         identify output as a change output, pending redemption request\n    //          or reported redemption. Reverts if one of the outputs cannot be\n    ///         recognized properly. Marks each request as processed by removing\n    ///         them from `pendingRedemptions` mapping.\n    /// @param redemptionTxOutputVector Bitcoin redemption transaction output\n    ///        vector. This function assumes vector's structure is valid so it\n    ///        must be validated using e.g. `BTCUtils.validateVout` function\n    ///        before it is passed here.\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    //         HASH160 over the compressed ECDSA public key) of the wallet which\n    ///        performed the redemption transaction.\n    /// @param processInfo RedemptionTxOutputsProcessingInfo identifying output\n    ///        starting index, the number of outputs and possible wallet change\n    ///        P2PKH and P2WPKH scripts.\n    function processRedemptionTxOutputs(\n        BridgeState.Storage storage self,\n        bytes memory redemptionTxOutputVector,\n        bytes20 walletPubKeyHash,\n        RedemptionTxOutputsProcessingInfo memory processInfo\n    ) internal returns (RedemptionTxOutputsInfo memory resultInfo) {\n        // Helper flag indicating whether there was at least one redemption\n        // output present (redemption must be either pending or reported as\n        // timed out).\n        bool redemptionPresent = false;\n\n        // Outputs processing loop.\n        for (uint256 i = 0; i < processInfo.outputsCount; i++) {\n            // TODO: Check if we can optimize gas costs by adding\n            //       `extractValueAt` and `extractHashAt` in `bitcoin-spv-sol`\n            //       in order to avoid allocating bytes in memory.\n            //       https://github.com/keep-network/tbtc-v2/issues/257\n            uint256 outputLength = redemptionTxOutputVector\n                .determineOutputLengthAt(processInfo.outputStartingIndex);\n            bytes memory output = redemptionTxOutputVector.slice(\n                processInfo.outputStartingIndex,\n                outputLength\n            );\n\n            // Extract the value from given output.\n            uint64 outputValue = output.extractValue();\n            // The output consists of an 8-byte value and a variable length\n            // script. To extract that script we slice the output starting from\n            // 9th byte until the end.\n            bytes memory outputScript = output.slice(8, output.length - 8);\n\n            if (\n                resultInfo.changeValue == 0 &&\n                (keccak256(outputScript) ==\n                    processInfo.walletP2PKHScriptKeccak ||\n                    keccak256(outputScript) ==\n                    processInfo.walletP2WPKHScriptKeccak) &&\n                outputValue > 0\n            ) {\n                // If we entered here, that means the change output with a\n                // proper non-zero value was found.\n                resultInfo.changeIndex = uint32(i);\n                resultInfo.changeValue = outputValue;\n            } else {\n                // If we entered here, that the means the given output is\n                // supposed to represent a redemption.\n                (\n                    uint64 burnableValue,\n                    uint64 treasuryFee\n                ) = processNonChangeRedemptionTxOutput(\n                        self,\n                        walletPubKeyHash,\n                        outputScript,\n                        outputValue\n                    );\n                resultInfo.totalBurnableValue += burnableValue;\n                resultInfo.totalTreasuryFee += treasuryFee;\n                redemptionPresent = true;\n            }\n\n            // Make the `outputStartingIndex` pointing to the next output by\n            // increasing it by current output's length.\n            processInfo.outputStartingIndex += outputLength;\n        }\n\n        // Protect against the cases when there is only a single change output\n        // referring back to the wallet PKH and just burning main UTXO value\n        // for transaction fees.\n        require(\n            redemptionPresent,\n            \"Redemption transaction must process at least one redemption\"\n        );\n    }\n\n    /// @notice Processes a single redemption transaction output. Tries to\n    ///         identify output as a pending redemption request or reported\n    ///         redemption timeout. Output script passed to this function must\n    ///         not be the change output. Such output needs to be identified\n    ///         separately before calling this function.\n    ///         Reverts if output is neither requested pending redemption nor\n    ///         requested and reported timed-out redemption.\n    ///         This function also marks each pending request as processed by\n    ///         removing them from `pendingRedemptions` mapping.\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    //         HASH160 over the compressed ECDSA public key) of the wallet which\n    ///        performed the redemption transaction.\n    /// @param outputScript Non-change output script to be processed.\n    /// @param outputValue Value of the output being processed.\n    /// @return burnableValue The value burnable as a result of processing this\n    ///         single redemption output. This value needs to be summed up with\n    ///         burnable values of all other outputs to evaluate total burnable\n    ///         value for the entire redemption transaction. This value is 0\n    ///         for a timed-out redemption request.\n    /// @return treasuryFee The treasury fee from this single redemption output.\n    ///         This value needs to be summed up with treasury fees of all other\n    ///         outputs to evaluate the total treasury fee for the entire\n    ///         redemption transaction. This value is 0 for a timed-out\n    ///         redemption request.\n    function processNonChangeRedemptionTxOutput(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        bytes memory outputScript,\n        uint64 outputValue\n    ) internal returns (uint64 burnableValue, uint64 treasuryFee) {\n        // This function should be called only if the given output is\n        // supposed to represent a redemption. Build the redemption key\n        // to perform that check.\n        uint256 redemptionKey = uint256(\n            keccak256(abi.encodePacked(walletPubKeyHash, outputScript))\n        );\n\n        if (self.pendingRedemptions[redemptionKey].requestedAt != 0) {\n            // If we entered here, that means the output was identified\n            // as a pending redemption request.\n            RedemptionRequest storage request = self.pendingRedemptions[\n                redemptionKey\n            ];\n            // Compute the request's redeemable amount as the requested\n            // amount reduced by the treasury fee. The request's\n            // minimal amount is then the redeemable amount reduced by\n            // the maximum transaction fee.\n            uint64 redeemableAmount = request.requestedAmount -\n                request.treasuryFee;\n            // Output value must fit between the request's redeemable\n            // and minimal amounts to be deemed valid.\n            require(\n                redeemableAmount - request.txMaxFee <= outputValue &&\n                    outputValue <= redeemableAmount,\n                \"Output value is not within the acceptable range of the pending request\"\n            );\n            // Add the redeemable amount to the total burnable value\n            // the Bridge will use to decrease its balance in the Bank.\n            burnableValue = redeemableAmount;\n            // Add the request's treasury fee to the total treasury fee\n            // value the Bridge will transfer to the treasury.\n            treasuryFee = request.treasuryFee;\n            // Request was properly handled so remove its redemption\n            // key from the mapping to make it reusable for further\n            // requests.\n            delete self.pendingRedemptions[redemptionKey];\n        } else {\n            // If we entered here, the output is not a redemption\n            // request but there is still a chance the given output is\n            // related to a reported timed out redemption request.\n            // If so, check if the output value matches the request\n            // amount to confirm this is an overdue request fulfillment\n            // then bypass this output and process the subsequent\n            // ones. That also means the wallet was already punished\n            // for the inactivity. Otherwise, just revert.\n            RedemptionRequest storage request = self.timedOutRedemptions[\n                redemptionKey\n            ];\n\n            require(\n                request.requestedAt != 0,\n                \"Output is a non-requested redemption\"\n            );\n\n            uint64 redeemableAmount = request.requestedAmount -\n                request.treasuryFee;\n\n            require(\n                redeemableAmount - request.txMaxFee <= outputValue &&\n                    outputValue <= redeemableAmount,\n                \"Output value is not within the acceptable range of the timed out request\"\n            );\n        }\n    }\n\n    /// @notice Notifies that there is a pending redemption request associated\n    ///         with the given wallet, that has timed out. The redemption\n    ///         request is identified by the key built as\n    ///         `keccak256(walletPubKeyHash | redeemerOutputScript)`.\n    ///         The results of calling this function:\n    ///         - the pending redemptions value for the wallet will be decreased\n    ///           by the requested amount (minus treasury fee),\n    ///         - the tokens taken from the redeemer on redemption request will\n    ///           be returned to the redeemer,\n    ///         - the request will be moved from pending redemptions to\n    ///           timed-out redemptions,\n    ///         - if the state of the wallet is `Live` or `MovingFunds`, the\n    ///           wallet operators will be slashed and the notifier will be\n    ///           rewarded,\n    ///         - if the state of wallet is `Live`, the wallet will be closed or\n    ///           marked as `MovingFunds` (depending on the presence or absence\n    ///           of the wallet's main UTXO) and the wallet will no longer be\n    ///           marked as the active wallet (if it was marked as such).\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet.\n    /// @param walletMembersIDs Identifiers of the wallet signing group members.\n    /// @param redeemerOutputScript  The redeemer's length-prefixed output\n    ///        script (P2PKH, P2WPKH, P2SH or P2WSH).\n    /// @dev Requirements:\n    ///      - The wallet must be in the Live or MovingFunds or Terminated state,\n    ///      - The redemption request identified by `walletPubKeyHash` and\n    ///        `redeemerOutputScript` must exist,\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract,\n    ///      - The amount of time defined by `redemptionTimeout` must have\n    ///        passed since the redemption was requested (the request must be\n    ///        timed-out).\n    function notifyRedemptionTimeout(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        uint32[] calldata walletMembersIDs,\n        bytes calldata redeemerOutputScript\n    ) external {\n        uint256 redemptionKey = uint256(\n            keccak256(abi.encodePacked(walletPubKeyHash, redeemerOutputScript))\n        );\n        Redemption.RedemptionRequest memory request = self.pendingRedemptions[\n            redemptionKey\n        ];\n\n        require(request.requestedAt > 0, \"Redemption request does not exist\");\n        require(\n            /* solhint-disable-next-line not-rely-on-time */\n            request.requestedAt + self.redemptionTimeout < block.timestamp,\n            \"Redemption request has not timed out\"\n        );\n\n        // Update the wallet's pending redemptions value\n        Wallets.Wallet storage wallet = self.registeredWallets[\n            walletPubKeyHash\n        ];\n        wallet.pendingRedemptionsValue -=\n            request.requestedAmount -\n            request.treasuryFee;\n\n        require(\n            wallet.state == Wallets.WalletState.Live ||\n                wallet.state == Wallets.WalletState.MovingFunds ||\n                wallet.state == Wallets.WalletState.Terminated,\n            \"The wallet must be in Live, MovingFunds or Terminated state\"\n        );\n\n        // It is worth noting that there is no need to check if\n        // `timedOutRedemption` mapping already contains the given redemption\n        // key. There is no possibility to re-use a key of a reported timed-out\n        // redemption because the wallet responsible for causing the timeout is\n        // moved to a state that prevents it to receive new redemption requests.\n\n        // Move the redemption from pending redemptions to timed-out redemptions\n        self.timedOutRedemptions[redemptionKey] = request;\n        delete self.pendingRedemptions[redemptionKey];\n\n        if (\n            wallet.state == Wallets.WalletState.Live ||\n            wallet.state == Wallets.WalletState.MovingFunds\n        ) {\n            // Propagate timeout consequences to the wallet\n            self.notifyWalletTimedOutRedemption(walletPubKeyHash);\n\n            // Slash the wallet operators and reward the notifier\n            self.ecdsaWalletRegistry.seize(\n                self.redemptionTimeoutSlashingAmount,\n                self.redemptionTimeoutNotifierRewardMultiplier,\n                msg.sender,\n                wallet.ecdsaWalletID,\n                walletMembersIDs\n            );\n        }\n\n        // slither-disable-next-line reentrancy-events\n        emit RedemptionTimedOut(walletPubKeyHash, redeemerOutputScript);\n\n        // Return the requested amount of tokens to the redeemer\n        self.bank.transferBalance(request.redeemer, request.requestedAmount);\n    }\n}\n"
     },
     "contracts/bridge/BitcoinTx.sol": {
-      "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\nimport {BTCUtils} from \"@keep-network/bitcoin-spv-sol/contracts/BTCUtils.sol\";\nimport {BytesLib} from \"@keep-network/bitcoin-spv-sol/contracts/BytesLib.sol\";\nimport {ValidateSPV} from \"@keep-network/bitcoin-spv-sol/contracts/ValidateSPV.sol\";\n\nimport \"./BridgeState.sol\";\n\n/// @title Bitcoin transaction\n/// @notice Allows to reference Bitcoin raw transaction in Solidity.\n/// @dev See https://developer.bitcoin.org/reference/transactions.html#raw-transaction-format\n///\n///      Raw Bitcoin transaction data:\n///\n///      | Bytes  |     Name     |        BTC type        |        Description        |\n///      |--------|--------------|------------------------|---------------------------|\n///      | 4      | version      | int32_t (LE)           | TX version number         |\n///      | varies | tx_in_count  | compactSize uint (LE)  | Number of TX inputs       |\n///      | varies | tx_in        | txIn[]                 | TX inputs                 |\n///      | varies | tx_out_count | compactSize uint (LE)  | Number of TX outputs      |\n///      | varies | tx_out       | txOut[]                | TX outputs                |\n///      | 4      | lock_time    | uint32_t (LE)          | Unix time or block number |\n///\n//\n///      Non-coinbase transaction input (txIn):\n///\n///      | Bytes  |       Name       |        BTC type        |                 Description                 |\n///      |--------|------------------|------------------------|---------------------------------------------|\n///      | 36     | previous_output  | outpoint               | The previous outpoint being spent           |\n///      | varies | script_bytes     | compactSize uint (LE)  | The number of bytes in the signature script |\n///      | varies | signature_script | char[]                 | The signature script, empty for P2WSH       |\n///      | 4      | sequence         | uint32_t (LE)          | Sequence number                             |\n///\n///\n///      The reference to transaction being spent (outpoint):\n///\n///      | Bytes | Name  |   BTC type    |               Description                |\n///      |-------|-------|---------------|------------------------------------------|\n///      |    32 | hash  | char[32]      | Hash of the transaction to spend         |\n///      |    4  | index | uint32_t (LE) | Index of the specific output from the TX |\n///\n///\n///      Transaction output (txOut):\n///\n///      | Bytes  |      Name       |     BTC type          |             Description              |\n///      |--------|-----------------|-----------------------|--------------------------------------|\n///      | 8      | value           | int64_t (LE)          | Number of satoshis to spend          |\n///      | 1+     | pk_script_bytes | compactSize uint (LE) | Number of bytes in the pubkey script |\n///      | varies | pk_script       | char[]                | Pubkey script                        |\n///\n///      compactSize uint format:\n///\n///      |                  Value                  | Bytes |                    Format                    |\n///      |-----------------------------------------|-------|----------------------------------------------|\n///      | >= 0 && <= 252                          | 1     | uint8_t                                      |\n///      | >= 253 && <= 0xffff                     | 3     | 0xfd followed by the number as uint16_t (LE) |\n///      | >= 0x10000 && <= 0xffffffff             | 5     | 0xfe followed by the number as uint32_t (LE) |\n///      | >= 0x100000000 && <= 0xffffffffffffffff | 9     | 0xff followed by the number as uint64_t (LE) |\n///\n///      (*) compactSize uint is often references as VarInt)\n///\n///      Coinbase transaction input (txIn):\n///\n///      | Bytes  |       Name       |        BTC type        |                 Description                 |\n///      |--------|------------------|------------------------|---------------------------------------------|\n///      | 32     | hash             | char[32]               | A 32-byte 0x0  null (no previous_outpoint)  |\n///      | 4      | index            | uint32_t (LE)          | 0xffffffff (no previous_outpoint)           |\n///      | varies | script_bytes     | compactSize uint (LE)  | The number of bytes in the coinbase script  |\n///      | varies | height           | char[]                 | The block height of this block (BIP34) (*)  |\n///      | varies | coinbase_script  | none                   |  Arbitrary data, max 100 bytes              |\n///      | 4      | sequence         | uint32_t (LE)          | Sequence number\n///\n///      (*)  Uses script language: starts with a data-pushing opcode that indicates how many bytes to push to\n///           the stack followed by the block height as a little-endian unsigned integer. This script must be as\n///           short as possible, otherwise it may be rejected. The data-pushing opcode will be 0x03 and the total\n///           size four bytes until block 16,777,216 about 300 years from now.\nlibrary BitcoinTx {\n    using BTCUtils for bytes;\n    using BTCUtils for uint256;\n    using BytesLib for bytes;\n    using ValidateSPV for bytes;\n    using ValidateSPV for bytes32;\n\n    /// @notice Represents Bitcoin transaction data.\n    struct Info {\n        /// @notice Bitcoin transaction version.\n        /// @dev `version` from raw Bitcoin transaction data.\n        ///      Encoded as 4-bytes signed integer, little endian.\n        bytes4 version;\n        /// @notice All Bitcoin transaction inputs, prepended by the number of\n        ///         transaction inputs.\n        /// @dev `tx_in_count | tx_in` from raw Bitcoin transaction data.\n        ///\n        ///      The number of transaction inputs encoded as compactSize\n        ///      unsigned integer, little-endian.\n        ///\n        ///      Note that some popular block explorers reverse the order of\n        ///      bytes from `outpoint`'s `hash` and display it as big-endian.\n        ///      Solidity code of Bridge expects hashes in little-endian, just\n        ///      like they are represented in a raw Bitcoin transaction.\n        bytes inputVector;\n        /// @notice All Bitcoin transaction outputs prepended by the number of\n        ///         transaction outputs.\n        /// @dev `tx_out_count | tx_out` from raw Bitcoin transaction data.\n        ///\n        ///       The number of transaction outputs encoded as a compactSize\n        ///       unsigned integer, little-endian.\n        bytes outputVector;\n        /// @notice Bitcoin transaction locktime.\n        ///\n        /// @dev `lock_time` from raw Bitcoin transaction data.\n        ///      Encoded as 4-bytes unsigned integer, little endian.\n        bytes4 locktime;\n        // This struct doesn't contain `__gap` property as the structure is not\n        // stored, it is used as a function's calldata argument.\n    }\n\n    /// @notice Represents data needed to perform a Bitcoin SPV proof.\n    struct Proof {\n        /// @notice The merkle proof of transaction inclusion in a block.\n        bytes merkleProof;\n        /// @notice Transaction index in the block (0-indexed).\n        uint256 txIndexInBlock;\n        /// @notice Single byte-string of 80-byte bitcoin headers,\n        ///         lowest height first.\n        bytes bitcoinHeaders;\n        // This struct doesn't contain `__gap` property as the structure is not\n        // stored, it is used as a function's calldata argument.\n    }\n\n    /// @notice Represents info about an unspent transaction output.\n    struct UTXO {\n        /// @notice Hash of the transaction the output belongs to.\n        /// @dev Byte order corresponds to the Bitcoin internal byte order.\n        bytes32 txHash;\n        /// @notice Index of the transaction output (0-indexed).\n        uint32 txOutputIndex;\n        /// @notice Value of the transaction output.\n        uint64 txOutputValue;\n        // This struct doesn't contain `__gap` property as the structure is not\n        // stored, it is used as a function's calldata argument.\n    }\n\n    /// @notice Represents Bitcoin signature in the R/S/V format.\n    struct RSVSignature {\n        /// @notice Signature r value.\n        bytes32 r;\n        /// @notice Signature s value.\n        bytes32 s;\n        /// @notice Signature recovery value.\n        uint8 v;\n        // This struct doesn't contain `__gap` property as the structure is not\n        // stored, it is used as a function's calldata argument.\n    }\n\n    /// @notice Validates the SPV proof of the Bitcoin transaction.\n    ///         Reverts in case the validation or proof verification fail.\n    /// @param txInfo Bitcoin transaction data.\n    /// @param proof Bitcoin proof data.\n    /// @return txHash Proven 32-byte transaction hash.\n    function validateProof(\n        BridgeState.Storage storage self,\n        Info calldata txInfo,\n        Proof calldata proof\n    ) internal view returns (bytes32 txHash) {\n        require(\n            txInfo.inputVector.validateVin(),\n            \"Invalid input vector provided\"\n        );\n        require(\n            txInfo.outputVector.validateVout(),\n            \"Invalid output vector provided\"\n        );\n\n        txHash = abi\n            .encodePacked(\n                txInfo.version,\n                txInfo.inputVector,\n                txInfo.outputVector,\n                txInfo.locktime\n            )\n            .hash256View();\n\n        require(\n            txHash.prove(\n                proof.bitcoinHeaders.extractMerkleRootLE(),\n                proof.merkleProof,\n                proof.txIndexInBlock\n            ),\n            \"Tx merkle proof is not valid for provided header and tx hash\"\n        );\n\n        evaluateProofDifficulty(self, proof.bitcoinHeaders);\n\n        return txHash;\n    }\n\n    /// @notice Evaluates the given Bitcoin proof difficulty against the actual\n    ///         Bitcoin chain difficulty provided by the relay oracle.\n    ///         Reverts in case the evaluation fails.\n    /// @param bitcoinHeaders Bitcoin headers chain being part of the SPV\n    ///        proof. Used to extract the observed proof difficulty.\n    function evaluateProofDifficulty(\n        BridgeState.Storage storage self,\n        bytes memory bitcoinHeaders\n    ) internal view {\n        IRelay relay = self.relay;\n        uint256 currentEpochDifficulty = relay.getCurrentEpochDifficulty();\n        uint256 previousEpochDifficulty = relay.getPrevEpochDifficulty();\n\n        uint256 requestedDiff = 0;\n        uint256 firstHeaderDiff = bitcoinHeaders\n            .extractTarget()\n            .calculateDifficulty();\n\n        if (firstHeaderDiff == currentEpochDifficulty) {\n            requestedDiff = currentEpochDifficulty;\n        } else if (firstHeaderDiff == previousEpochDifficulty) {\n            requestedDiff = previousEpochDifficulty;\n        } else {\n            revert(\"Not at current or previous difficulty\");\n        }\n\n        uint256 observedDiff = bitcoinHeaders.validateHeaderChain();\n\n        require(\n            observedDiff != ValidateSPV.getErrBadLength(),\n            \"Invalid length of the headers chain\"\n        );\n        require(\n            observedDiff != ValidateSPV.getErrInvalidChain(),\n            \"Invalid headers chain\"\n        );\n        require(\n            observedDiff != ValidateSPV.getErrLowWork(),\n            \"Insufficient work in a header\"\n        );\n\n        require(\n            observedDiff >= requestedDiff * self.txProofDifficultyFactor,\n            \"Insufficient accumulated difficulty in header chain\"\n        );\n    }\n\n    /// @notice Extracts public key hash from the provided P2PKH or P2WPKH output.\n    ///         Reverts if the validation fails.\n    /// @param output The transaction output.\n    /// @return pubKeyHash 20-byte public key hash the output locks funds on.\n    /// @dev Requirements:\n    ///      - The output must be of P2PKH or P2WPKH type and lock the funds\n    ///        on a 20-byte public key hash.\n    function extractPubKeyHash(BridgeState.Storage storage, bytes memory output)\n        internal\n        view\n        returns (bytes20 pubKeyHash)\n    {\n        bytes memory pubKeyHashBytes = output.extractHash();\n\n        require(\n            pubKeyHashBytes.length == 20,\n            \"Output's public key hash must have 20 bytes\"\n        );\n\n        pubKeyHash = pubKeyHashBytes.slice20(0);\n\n        // We need to make sure that the 20-byte public key hash\n        // is actually used in the right context of a P2PKH or P2WPKH\n        // output. To do so, we must extract the full script from the output\n        // and compare with the expected P2PKH and P2WPKH scripts\n        // referring to that 20-byte public key hash. The output consists\n        // of an 8-byte value and a variable length script. To extract the\n        // script we slice the output starting from 9th byte until the end.\n        bytes32 outputScriptKeccak = keccak256(\n            output.slice(8, output.length - 8)\n        );\n        // Build the expected P2PKH script which has the following byte\n        // format: <0x1976a914> <20-byte PKH> <0x88ac>. According to\n        // https://en.bitcoin.it/wiki/Script#Opcodes this translates to:\n        // - 0x19: Byte length of the entire script\n        // - 0x76: OP_DUP\n        // - 0xa9: OP_HASH160\n        // - 0x14: Byte length of the public key hash\n        // - 0x88: OP_EQUALVERIFY\n        // - 0xac: OP_CHECKSIG\n        // which matches the P2PKH structure as per:\n        // https://en.bitcoin.it/wiki/Transaction#Pay-to-PubkeyHash\n        bytes32 P2PKHScriptKeccak = keccak256(\n            abi.encodePacked(hex\"1976a914\", pubKeyHash, hex\"88ac\")\n        );\n        // Build the expected P2WPKH script which has the following format:\n        // <0x160014> <20-byte PKH>. According to\n        // https://en.bitcoin.it/wiki/Script#Opcodes this translates to:\n        // - 0x16: Byte length of the entire script\n        // - 0x00: OP_0\n        // - 0x14: Byte length of the public key hash\n        // which matches the P2WPKH structure as per:\n        // https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#P2WPKH\n        bytes32 P2WPKHScriptKeccak = keccak256(\n            abi.encodePacked(hex\"160014\", pubKeyHash)\n        );\n        // Make sure the actual output script matches either the P2PKH\n        // or P2WPKH format.\n        require(\n            outputScriptKeccak == P2PKHScriptKeccak ||\n                outputScriptKeccak == P2WPKHScriptKeccak,\n            \"Output must be P2PKH or P2WPKH\"\n        );\n\n        return pubKeyHash;\n    }\n}\n"
+      "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\nimport {BTCUtils} from \"@keep-network/bitcoin-spv-sol/contracts/BTCUtils.sol\";\nimport {BytesLib} from \"@keep-network/bitcoin-spv-sol/contracts/BytesLib.sol\";\nimport {ValidateSPV} from \"@keep-network/bitcoin-spv-sol/contracts/ValidateSPV.sol\";\n\nimport \"./BridgeState.sol\";\n\n/// @title Bitcoin transaction\n/// @notice Allows to reference Bitcoin raw transaction in Solidity.\n/// @dev See https://developer.bitcoin.org/reference/transactions.html#raw-transaction-format\n///\n///      Raw Bitcoin transaction data:\n///\n///      | Bytes  |     Name     |        BTC type        |        Description        |\n///      |--------|--------------|------------------------|---------------------------|\n///      | 4      | version      | int32_t (LE)           | TX version number         |\n///      | varies | tx_in_count  | compactSize uint (LE)  | Number of TX inputs       |\n///      | varies | tx_in        | txIn[]                 | TX inputs                 |\n///      | varies | tx_out_count | compactSize uint (LE)  | Number of TX outputs      |\n///      | varies | tx_out       | txOut[]                | TX outputs                |\n///      | 4      | lock_time    | uint32_t (LE)          | Unix time or block number |\n///\n//\n///      Non-coinbase transaction input (txIn):\n///\n///      | Bytes  |       Name       |        BTC type        |                 Description                 |\n///      |--------|------------------|------------------------|---------------------------------------------|\n///      | 36     | previous_output  | outpoint               | The previous outpoint being spent           |\n///      | varies | script_bytes     | compactSize uint (LE)  | The number of bytes in the signature script |\n///      | varies | signature_script | char[]                 | The signature script, empty for P2WSH       |\n///      | 4      | sequence         | uint32_t (LE)          | Sequence number                             |\n///\n///\n///      The reference to transaction being spent (outpoint):\n///\n///      | Bytes | Name  |   BTC type    |               Description                |\n///      |-------|-------|---------------|------------------------------------------|\n///      |    32 | hash  | char[32]      | Hash of the transaction to spend         |\n///      |    4  | index | uint32_t (LE) | Index of the specific output from the TX |\n///\n///\n///      Transaction output (txOut):\n///\n///      | Bytes  |      Name       |     BTC type          |             Description              |\n///      |--------|-----------------|-----------------------|--------------------------------------|\n///      | 8      | value           | int64_t (LE)          | Number of satoshis to spend          |\n///      | 1+     | pk_script_bytes | compactSize uint (LE) | Number of bytes in the pubkey script |\n///      | varies | pk_script       | char[]                | Pubkey script                        |\n///\n///      compactSize uint format:\n///\n///      |                  Value                  | Bytes |                    Format                    |\n///      |-----------------------------------------|-------|----------------------------------------------|\n///      | >= 0 && <= 252                          | 1     | uint8_t                                      |\n///      | >= 253 && <= 0xffff                     | 3     | 0xfd followed by the number as uint16_t (LE) |\n///      | >= 0x10000 && <= 0xffffffff             | 5     | 0xfe followed by the number as uint32_t (LE) |\n///      | >= 0x100000000 && <= 0xffffffffffffffff | 9     | 0xff followed by the number as uint64_t (LE) |\n///\n///      (*) compactSize uint is often references as VarInt)\n///\n///      Coinbase transaction input (txIn):\n///\n///      | Bytes  |       Name       |        BTC type        |                 Description                 |\n///      |--------|------------------|------------------------|---------------------------------------------|\n///      | 32     | hash             | char[32]               | A 32-byte 0x0  null (no previous_outpoint)  |\n///      | 4      | index            | uint32_t (LE)          | 0xffffffff (no previous_outpoint)           |\n///      | varies | script_bytes     | compactSize uint (LE)  | The number of bytes in the coinbase script  |\n///      | varies | height           | char[]                 | The block height of this block (BIP34) (*)  |\n///      | varies | coinbase_script  | none                   |  Arbitrary data, max 100 bytes              |\n///      | 4      | sequence         | uint32_t (LE)          | Sequence number\n///\n///      (*)  Uses script language: starts with a data-pushing opcode that indicates how many bytes to push to\n///           the stack followed by the block height as a little-endian unsigned integer. This script must be as\n///           short as possible, otherwise it may be rejected. The data-pushing opcode will be 0x03 and the total\n///           size four bytes until block 16,777,216 about 300 years from now.\nlibrary BitcoinTx {\n    using BTCUtils for bytes;\n    using BTCUtils for uint256;\n    using BytesLib for bytes;\n    using ValidateSPV for bytes;\n    using ValidateSPV for bytes32;\n\n    /// @notice Represents Bitcoin transaction data.\n    struct Info {\n        /// @notice Bitcoin transaction version.\n        /// @dev `version` from raw Bitcoin transaction data.\n        ///      Encoded as 4-bytes signed integer, little endian.\n        bytes4 version;\n        /// @notice All Bitcoin transaction inputs, prepended by the number of\n        ///         transaction inputs.\n        /// @dev `tx_in_count | tx_in` from raw Bitcoin transaction data.\n        ///\n        ///      The number of transaction inputs encoded as compactSize\n        ///      unsigned integer, little-endian.\n        ///\n        ///      Note that some popular block explorers reverse the order of\n        ///      bytes from `outpoint`'s `hash` and display it as big-endian.\n        ///      Solidity code of Bridge expects hashes in little-endian, just\n        ///      like they are represented in a raw Bitcoin transaction.\n        bytes inputVector;\n        /// @notice All Bitcoin transaction outputs prepended by the number of\n        ///         transaction outputs.\n        /// @dev `tx_out_count | tx_out` from raw Bitcoin transaction data.\n        ///\n        ///       The number of transaction outputs encoded as a compactSize\n        ///       unsigned integer, little-endian.\n        bytes outputVector;\n        /// @notice Bitcoin transaction locktime.\n        ///\n        /// @dev `lock_time` from raw Bitcoin transaction data.\n        ///      Encoded as 4-bytes unsigned integer, little endian.\n        bytes4 locktime;\n        // This struct doesn't contain `__gap` property as the structure is not\n        // stored, it is used as a function's calldata argument.\n    }\n\n    /// @notice Represents data needed to perform a Bitcoin SPV proof.\n    struct Proof {\n        /// @notice The merkle proof of transaction inclusion in a block.\n        bytes merkleProof;\n        /// @notice Transaction index in the block (0-indexed).\n        uint256 txIndexInBlock;\n        /// @notice Single byte-string of 80-byte bitcoin headers,\n        ///         lowest height first.\n        bytes bitcoinHeaders;\n        // This struct doesn't contain `__gap` property as the structure is not\n        // stored, it is used as a function's calldata argument.\n    }\n\n    /// @notice Represents info about an unspent transaction output.\n    struct UTXO {\n        /// @notice Hash of the transaction the output belongs to.\n        /// @dev Byte order corresponds to the Bitcoin internal byte order.\n        bytes32 txHash;\n        /// @notice Index of the transaction output (0-indexed).\n        uint32 txOutputIndex;\n        /// @notice Value of the transaction output.\n        uint64 txOutputValue;\n        // This struct doesn't contain `__gap` property as the structure is not\n        // stored, it is used as a function's calldata argument.\n    }\n\n    /// @notice Represents Bitcoin signature in the R/S/V format.\n    struct RSVSignature {\n        /// @notice Signature r value.\n        bytes32 r;\n        /// @notice Signature s value.\n        bytes32 s;\n        /// @notice Signature recovery value.\n        uint8 v;\n        // This struct doesn't contain `__gap` property as the structure is not\n        // stored, it is used as a function's calldata argument.\n    }\n\n    /// @notice Validates the SPV proof of the Bitcoin transaction.\n    ///         Reverts in case the validation or proof verification fail.\n    /// @param txInfo Bitcoin transaction data.\n    /// @param proof Bitcoin proof data.\n    /// @return txHash Proven 32-byte transaction hash.\n    function validateProof(\n        BridgeState.Storage storage self,\n        Info calldata txInfo,\n        Proof calldata proof\n    ) internal view returns (bytes32 txHash) {\n        require(\n            txInfo.inputVector.validateVin(),\n            \"Invalid input vector provided\"\n        );\n        require(\n            txInfo.outputVector.validateVout(),\n            \"Invalid output vector provided\"\n        );\n\n        txHash = abi\n            .encodePacked(\n                txInfo.version,\n                txInfo.inputVector,\n                txInfo.outputVector,\n                txInfo.locktime\n            )\n            .hash256View();\n\n        require(\n            txHash.prove(\n                proof.bitcoinHeaders.extractMerkleRootLE(),\n                proof.merkleProof,\n                proof.txIndexInBlock\n            ),\n            \"Tx merkle proof is not valid for provided header and tx hash\"\n        );\n\n        evaluateProofDifficulty(self, proof.bitcoinHeaders);\n\n        return txHash;\n    }\n\n    /// @notice Evaluates the given Bitcoin proof difficulty against the actual\n    ///         Bitcoin chain difficulty provided by the relay oracle.\n    ///         Reverts in case the evaluation fails.\n    /// @param bitcoinHeaders Bitcoin headers chain being part of the SPV\n    ///        proof. Used to extract the observed proof difficulty.\n    function evaluateProofDifficulty(\n        BridgeState.Storage storage self,\n        bytes memory bitcoinHeaders\n    ) internal view {\n        IRelay relay = self.relay;\n        uint256 currentEpochDifficulty = relay.getCurrentEpochDifficulty();\n        uint256 previousEpochDifficulty = relay.getPrevEpochDifficulty();\n\n        uint256 requestedDiff = 0;\n        uint256 firstHeaderDiff = bitcoinHeaders\n            .extractTarget()\n            .calculateDifficulty();\n\n        if (firstHeaderDiff == currentEpochDifficulty) {\n            requestedDiff = currentEpochDifficulty;\n        } else if (firstHeaderDiff == previousEpochDifficulty) {\n            requestedDiff = previousEpochDifficulty;\n        } else {\n            revert(\"Not at current or previous difficulty\");\n        }\n\n        uint256 observedDiff = bitcoinHeaders.validateHeaderChain();\n\n        require(\n            observedDiff != ValidateSPV.getErrBadLength(),\n            \"Invalid length of the headers chain\"\n        );\n        require(\n            observedDiff != ValidateSPV.getErrInvalidChain(),\n            \"Invalid headers chain\"\n        );\n        require(\n            observedDiff != ValidateSPV.getErrLowWork(),\n            \"Insufficient work in a header\"\n        );\n\n        require(\n            observedDiff >= requestedDiff * self.txProofDifficultyFactor,\n            \"Insufficient accumulated difficulty in header chain\"\n        );\n    }\n\n    /// @notice Extracts public key hash from the provided P2PKH or P2WPKH output.\n    ///         Reverts if the validation fails.\n    /// @param output The transaction output.\n    /// @return pubKeyHash 20-byte public key hash the output locks funds on.\n    /// @dev Requirements:\n    ///      - The output must be of P2PKH or P2WPKH type and lock the funds\n    ///        on a 20-byte public key hash.\n    function extractPubKeyHash(BridgeState.Storage storage, bytes memory output)\n        internal\n        pure\n        returns (bytes20 pubKeyHash)\n    {\n        bytes memory pubKeyHashBytes = output.extractHash();\n\n        require(\n            pubKeyHashBytes.length == 20,\n            \"Output's public key hash must have 20 bytes\"\n        );\n\n        pubKeyHash = pubKeyHashBytes.slice20(0);\n\n        // We need to make sure that the 20-byte public key hash\n        // is actually used in the right context of a P2PKH or P2WPKH\n        // output. To do so, we must extract the full script from the output\n        // and compare with the expected P2PKH and P2WPKH scripts\n        // referring to that 20-byte public key hash. The output consists\n        // of an 8-byte value and a variable length script. To extract the\n        // script we slice the output starting from 9th byte until the end.\n        bytes32 outputScriptKeccak = keccak256(\n            output.slice(8, output.length - 8)\n        );\n        // Build the expected P2PKH script which has the following byte\n        // format: <0x1976a914> <20-byte PKH> <0x88ac>. According to\n        // https://en.bitcoin.it/wiki/Script#Opcodes this translates to:\n        // - 0x19: Byte length of the entire script\n        // - 0x76: OP_DUP\n        // - 0xa9: OP_HASH160\n        // - 0x14: Byte length of the public key hash\n        // - 0x88: OP_EQUALVERIFY\n        // - 0xac: OP_CHECKSIG\n        // which matches the P2PKH structure as per:\n        // https://en.bitcoin.it/wiki/Transaction#Pay-to-PubkeyHash\n        bytes32 P2PKHScriptKeccak = keccak256(\n            abi.encodePacked(hex\"1976a914\", pubKeyHash, hex\"88ac\")\n        );\n        // Build the expected P2WPKH script which has the following format:\n        // <0x160014> <20-byte PKH>. According to\n        // https://en.bitcoin.it/wiki/Script#Opcodes this translates to:\n        // - 0x16: Byte length of the entire script\n        // - 0x00: OP_0\n        // - 0x14: Byte length of the public key hash\n        // which matches the P2WPKH structure as per:\n        // https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#P2WPKH\n        bytes32 P2WPKHScriptKeccak = keccak256(\n            abi.encodePacked(hex\"160014\", pubKeyHash)\n        );\n        // Make sure the actual output script matches either the P2PKH\n        // or P2WPKH format.\n        require(\n            outputScriptKeccak == P2PKHScriptKeccak ||\n                outputScriptKeccak == P2WPKHScriptKeccak,\n            \"Output must be P2PKH or P2WPKH\"\n        );\n\n        return pubKeyHash;\n    }\n}\n"
     },
     "contracts/bridge/EcdsaLib.sol": {
       "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\nimport \"@keep-network/bitcoin-spv-sol/contracts/BytesLib.sol\";\n\nlibrary EcdsaLib {\n    using BytesLib for bytes;\n\n    /// @notice Converts public key X and Y coordinates (32-byte each) to a\n    ///         compressed public key (33-byte). Compressed public key is X\n    ///         coordinate prefixed with `02` or `03` based on the Y coordinate parity.\n    ///         It is expected that the uncompressed public key is stripped\n    ///         (i.e. it is not prefixed with `04`).\n    /// @param x Wallet's public key's X coordinate.\n    /// @param y Wallet's public key's Y coordinate.\n    /// @return Compressed public key (33-byte), prefixed with `02` or `03`.\n    function compressPublicKey(bytes32 x, bytes32 y)\n        internal\n        pure\n        returns (bytes memory)\n    {\n        bytes1 prefix;\n        if (uint256(y) % 2 == 0) {\n            prefix = hex\"02\";\n        } else {\n            prefix = hex\"03\";\n        }\n\n        return bytes.concat(prefix, x);\n    }\n}\n"
@@ -256,6 +259,9 @@
     "@keep-network/random-beacon/contracts/Reimbursable.sol": {
       "content": "// SPDX-License-Identifier: MIT\n//\n// ▓▓▌ ▓▓ ▐▓▓ ▓▓▓▓▓▓▓▓▓▓▌▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▄\n// ▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▌▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓\n//   ▓▓▓▓▓▓    ▓▓▓▓▓▓▓▀    ▐▓▓▓▓▓▓    ▐▓▓▓▓▓   ▓▓▓▓▓▓     ▓▓▓▓▓   ▐▓▓▓▓▓▌   ▐▓▓▓▓▓▓\n//   ▓▓▓▓▓▓▄▄▓▓▓▓▓▓▓▀      ▐▓▓▓▓▓▓▄▄▄▄         ▓▓▓▓▓▓▄▄▄▄         ▐▓▓▓▓▓▌   ▐▓▓▓▓▓▓\n//   ▓▓▓▓▓▓▓▓▓▓▓▓▓▀        ▐▓▓▓▓▓▓▓▓▓▓         ▓▓▓▓▓▓▓▓▓▓         ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓\n//   ▓▓▓▓▓▓▀▀▓▓▓▓▓▓▄       ▐▓▓▓▓▓▓▀▀▀▀         ▓▓▓▓▓▓▀▀▀▀         ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▀\n//   ▓▓▓▓▓▓   ▀▓▓▓▓▓▓▄     ▐▓▓▓▓▓▓     ▓▓▓▓▓   ▓▓▓▓▓▓     ▓▓▓▓▓   ▐▓▓▓▓▓▌\n// ▓▓▓▓▓▓▓▓▓▓ █▓▓▓▓▓▓▓▓▓ ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓▓▓\n// ▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓ ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓▓▓\n//\n//                           Trust math, not hardware.\n\npragma solidity ^0.8.9;\n\nimport \"./ReimbursementPool.sol\";\n\nabstract contract Reimbursable {\n    // The variable should be initialized by the implementing contract.\n    // slither-disable-next-line uninitialized-state\n    ReimbursementPool public reimbursementPool;\n\n    // Reserved storage space in case we need to add more variables,\n    // since there are upgradeable contracts that inherit from this one.\n    // See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n    // slither-disable-next-line unused-state\n    uint256[49] private __gap;\n\n    event ReimbursementPoolUpdated(address newReimbursementPool);\n\n    modifier refundable(address receiver) {\n        uint256 gasStart = gasleft();\n        _;\n        reimbursementPool.refund(gasStart - gasleft(), receiver);\n    }\n\n    modifier onlyReimbursableAdmin() virtual {\n        _;\n    }\n\n    function updateReimbursementPool(ReimbursementPool _reimbursementPool)\n        external\n        onlyReimbursableAdmin\n    {\n        emit ReimbursementPoolUpdated(address(_reimbursementPool));\n\n        reimbursementPool = _reimbursementPool;\n    }\n}\n"
     },
+    "contracts/vault/DonationVault.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\nimport \"./IVault.sol\";\nimport \"../bank/Bank.sol\";\n\n/// @title BTC donation vault\n/// @notice Vault that allows making BTC donations to the system. Upon deposit,\n///         this vault does not increase depositors' balances and always\n///         decreases its own balance in the same transaction. The vault also\n///         allows making donations using existing Bank balances.\n///\n///         BEWARE: ALL BTC DEPOSITS TARGETING THIS VAULT ARE NOT REDEEMABLE\n///         AND THERE IS NO WAY TO RESTORE THE DONATED BALANCE.\n///         USE THIS VAULT ONLY WHEN YOU REALLY KNOW WHAT YOU ARE DOING!\ncontract DonationVault is IVault {\n    Bank public bank;\n\n    event DonationReceived(address donor, uint256 donatedAmount);\n\n    modifier onlyBank() {\n        require(msg.sender == address(bank), \"Caller is not the Bank\");\n        _;\n    }\n\n    constructor(Bank _bank) {\n        require(\n            address(_bank) != address(0),\n            \"Bank can not be the zero address\"\n        );\n\n        bank = _bank;\n    }\n\n    /// @notice Transfers the given `amount` of the Bank balance from the\n    ///         caller to the Donation Vault and immediately decreases the\n    ///         vault's balance in the Bank by the transferred `amount`.\n    /// @param amount Amount of the Bank balance to donate.\n    /// @dev Requirements:\n    ///      - The caller's balance in the Bank must be greater than or equal\n    ///        to the `amount`,\n    ///      - Donation Vault must have an allowance for caller's balance in\n    ///        the Bank for at least `amount`.\n    function donate(uint256 amount) external {\n        address donor = msg.sender;\n\n        require(\n            bank.balanceOf(donor) >= amount,\n            \"Amount exceeds balance in the bank\"\n        );\n\n        emit DonationReceived(donor, amount);\n\n        bank.transferBalanceFrom(donor, address(this), amount);\n        bank.decreaseBalance(amount);\n    }\n\n    /// @notice Transfers the given `amount` of the Bank balance from the\n    ///         `owner` to the Donation Vault and immediately decreases the\n    ///         vault's balance in the Bank by the transferred `amount`.\n    /// @param owner Address of the Bank balance owner who approved their\n    ///        balance to be used by the vault.\n    /// @param amount The amount of the Bank balance approved by the owner\n    ///        to be used by the vault.\n    /// @dev Requirements:\n    ///      - Can only be called by the Bank via `approveBalanceAndCall`,\n    ///      - The `owner` balance in the Bank must be greater than or equal\n    ///        to the `amount`.\n    function receiveBalanceApproval(\n        address owner,\n        uint256 amount,\n        bytes memory\n    ) external override onlyBank {\n        require(\n            bank.balanceOf(owner) >= amount,\n            \"Amount exceeds balance in the bank\"\n        );\n\n        emit DonationReceived(owner, amount);\n\n        bank.transferBalanceFrom(owner, address(this), amount);\n        bank.decreaseBalance(amount);\n    }\n\n    /// @notice Ignores the deposited amounts and does not increase depositors'\n    ///         individual balances. The vault decreases its own tBTC balance\n    ///         in the Bank by the total deposited amount.\n    /// @param depositors Addresses of depositors whose deposits have been swept.\n    /// @param depositedAmounts Amounts deposited by individual depositors and\n    ///        swept.\n    /// @dev Requirements:\n    ///      - Can only be called by the Bank after the Bridge swept deposits\n    ///        and Bank increased balance for the vault,\n    ///      - The `depositors` array must not be empty,\n    ///      - The `depositors` array length must be equal to the\n    ///        `depositedAmounts` array length.\n    function receiveBalanceIncrease(\n        address[] calldata depositors,\n        uint256[] calldata depositedAmounts\n    ) external override onlyBank {\n        require(depositors.length != 0, \"No depositors specified\");\n\n        uint256 totalAmount = 0;\n        for (uint256 i = 0; i < depositors.length; i++) {\n            totalAmount += depositedAmounts[i];\n            emit DonationReceived(depositors[i], depositedAmounts[i]);\n        }\n\n        bank.decreaseBalance(totalAmount);\n    }\n}\n"
+    },
     "@threshold-network/solidity-contracts/contracts/staking/IApplication.sol": {
       "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity 0.8.9;\n\n/// @title  Application interface for Threshold Network applications\n/// @notice Generic interface for an application. Application is an external\n///         smart contract or a set of smart contracts utilizing functionalities\n///         offered by Threshold Network. Applications authorized for the given\n///         staking provider are eligible to slash the stake delegated to that\n///         staking provider.\ninterface IApplication {\n    /// @dev Event emitted by `withdrawRewards` function.\n    event RewardsWithdrawn(address indexed stakingProvider, uint96 amount);\n\n    /// @notice Withdraws application rewards for the given staking provider.\n    ///         Rewards are withdrawn to the staking provider's beneficiary\n    ///         address set in the staking contract.\n    /// @dev Emits `RewardsWithdrawn` event.\n    function withdrawRewards(address stakingProvider) external;\n\n    /// @notice Used by T staking contract to inform the application that the\n    ///         authorized amount for the given staking provider increased.\n    ///         The application may do any necessary housekeeping. The\n    ///         application must revert the transaction in case the\n    ///         authorization is below the minimum required.\n    function authorizationIncreased(\n        address stakingProvider,\n        uint96 fromAmount,\n        uint96 toAmount\n    ) external;\n\n    /// @notice Used by T staking contract to inform the application that the\n    ///         authorization decrease for the given staking provider has been\n    ///         requested. The application should mark the authorization as\n    ///         pending decrease and respond to the staking contract with\n    ///         `approveAuthorizationDecrease` at its discretion. It may\n    ///         happen right away but it also may happen several months later.\n    function authorizationDecreaseRequested(\n        address stakingProvider,\n        uint96 fromAmount,\n        uint96 toAmount\n    ) external;\n\n    /// @notice Used by T staking contract to inform the application the\n    ///         authorization has been decreased for the given staking provider\n    ///         involuntarily, as a result of slashing. Lets the application to\n    ///         do any housekeeping neccessary. Called with 250k gas limit and\n    ///         does not revert the transaction if\n    ///         `involuntaryAuthorizationDecrease` call failed.\n    function involuntaryAuthorizationDecrease(\n        address stakingProvider,\n        uint96 fromAmount,\n        uint96 toAmount\n    ) external;\n\n    /// @notice Returns the amount of application rewards available for\n    ///         withdrawal for the given staking provider.\n    function availableRewards(address stakingProvider)\n        external\n        view\n        returns (uint96);\n\n    /// @notice The minimum authorization amount required for the staking\n    ///         provider so that they can participate in the application.\n    function minimumAuthorization() external view returns (uint96);\n}\n"
     },
@@ -274,9 +280,6 @@
     "contracts/test/TestERC721.sol": {
       "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts/token/ERC721/ERC721.sol\";\n\ncontract TestERC721 is ERC721 {\n    string public constant NAME = \"Test ERC721 Token\";\n    string public constant SYMBOL = \"TT\";\n\n    constructor() ERC721(NAME, SYMBOL) {}\n\n    function mint(address to, uint256 tokenId) public {\n        _mint(to, tokenId);\n    }\n}\n"
     },
-    "contracts/vault/DonationVault.sol": {
-      "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\nimport \"./IVault.sol\";\nimport \"../bank/Bank.sol\";\n\n/// @title BTC donation vault\n/// @notice Vault that allows making BTC donations to the system. Upon deposit,\n///         this vault does not increase depositors' balances and always\n///         decreases its own balance in the same transaction. The vault also\n///         allows making donations using existing Bank balances.\n///\n///         BEWARE: ALL BTC DEPOSITS TARGETING THIS VAULT ARE NOT REDEEMABLE\n///         AND THERE IS NO WAY TO RESTORE THE DONATED BALANCE.\n///         USE THIS VAULT ONLY WHEN YOU REALLY KNOW WHAT YOU ARE DOING!\ncontract DonationVault is IVault {\n    Bank public bank;\n\n    event DonationReceived(address donor, uint256 donatedAmount);\n\n    modifier onlyBank() {\n        require(msg.sender == address(bank), \"Caller is not the Bank\");\n        _;\n    }\n\n    constructor(Bank _bank) {\n        require(\n            address(_bank) != address(0),\n            \"Bank can not be the zero address\"\n        );\n\n        bank = _bank;\n    }\n\n    /// @notice Transfers the given `amount` of the Bank balance from the\n    ///         caller to the Donation Vault and immediately decreases the\n    ///         vault's balance in the Bank by the transferred `amount`.\n    /// @param amount Amount of the Bank balance to donate.\n    /// @dev Requirements:\n    ///      - The caller's balance in the Bank must be greater than or equal\n    ///        to the `amount`,\n    ///      - Donation Vault must have an allowance for caller's balance in\n    ///        the Bank for at least `amount`.\n    function donate(uint256 amount) external {\n        address donor = msg.sender;\n\n        require(\n            bank.balanceOf(donor) >= amount,\n            \"Amount exceeds balance in the bank\"\n        );\n\n        emit DonationReceived(donor, amount);\n\n        bank.transferBalanceFrom(donor, address(this), amount);\n        bank.decreaseBalance(amount);\n    }\n\n    /// @notice Transfers the given `amount` of the Bank balance from the\n    ///         `owner` to the Donation Vault and immediately decreases the\n    ///         vault's balance in the Bank by the transferred `amount`.\n    /// @param owner Address of the Bank balance owner who approved their\n    ///        balance to be used by the vault.\n    /// @param amount The amount of the Bank balance approved by the owner\n    ///        to be used by the vault.\n    /// @dev Requirements:\n    ///      - Can only be called by the Bank via `approveBalanceAndCall`,\n    ///      - The `owner` balance in the Bank must be greater than or equal\n    ///        to the `amount`.\n    function receiveBalanceApproval(\n        address owner,\n        uint256 amount,\n        bytes memory\n    ) external override onlyBank {\n        require(\n            bank.balanceOf(owner) >= amount,\n            \"Amount exceeds balance in the bank\"\n        );\n\n        emit DonationReceived(owner, amount);\n\n        bank.transferBalanceFrom(owner, address(this), amount);\n        bank.decreaseBalance(amount);\n    }\n\n    /// @notice Ignores the deposited amounts and does not increase depositors'\n    ///         individual balances. The vault decreases its own tBTC balance\n    ///         in the Bank by the total deposited amount.\n    /// @param depositors Addresses of depositors whose deposits have been swept.\n    /// @param depositedAmounts Amounts deposited by individual depositors and\n    ///        swept.\n    /// @dev Requirements:\n    ///      - Can only be called by the Bank after the Bridge swept deposits\n    ///        and Bank increased balance for the vault,\n    ///      - The `depositors` array must not be empty,\n    ///      - The `depositors` array length must be equal to the\n    ///        `depositedAmounts` array length.\n    function receiveBalanceIncrease(\n        address[] calldata depositors,\n        uint256[] calldata depositedAmounts\n    ) external override onlyBank {\n        require(depositors.length != 0, \"No depositors specified\");\n\n        uint256 totalAmount = 0;\n        for (uint256 i = 0; i < depositors.length; i++) {\n            totalAmount += depositedAmounts[i];\n            emit DonationReceived(depositors[i], depositedAmounts[i]);\n        }\n\n        bank.decreaseBalance(totalAmount);\n    }\n}\n"
-    },
     "contracts/test/BankStub.sol": {
       "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.9;\n\nimport \"../bank/Bank.sol\";\n\ncontract BankStub is Bank {\n    function setBalance(address addr, uint256 amount) external {\n        balanceOf[addr] = amount;\n    }\n}\n"
     }