@keep-network/tbtc-v2 0.1.1-dev.91 → 0.1.1-dev.92

package/artifacts/solcInputs/{6e28b66ed60b6dd7b2b25b3a1c4fe89b.json → 2522ad78efeee521d6cb3252a08f9f62.json}

@@ -59,7 +59,7 @@
       "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"
     },
     "contracts/bridge/VendingMachine.sol": {
-      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport \"@thesis/solidity-contracts/contracts/token/IReceiveApproval.sol\";\n\nimport \"../token/TBTC.sol\";\nimport \"../GovernanceUtils.sol\";\n\n/// @title TBTC v2 Vending Machine\n/// @notice The Vending Machine is the owner of TBTC v2 token and can mint\n///         TBTC v2 tokens in 1:1 ratio from TBTC v1 tokens with TBTC v1\n///         deposited in the contract as collateral. TBTC v2 can be\n///         unminted back to TBTC v1 with or without a fee - fee parameter is\n///         controlled by the Governance. This implementation acts as a bridge\n///         between TBTC v1 and TBTC v2 token, allowing to mint TBTC v2 before\n///         the system is ready and fully operational without sacrificing any\n///         security guarantees and decentralization of the project.\n///         Vending Machine can be upgraded in a two-step, governance-controlled\n///         process. The new version of the Vending Machine will receive the\n///         ownership of TBTC v2 token and entire TBTC v1 balance stored as\n///         collateral. It is expected that this process will be executed before\n///         the v2 system launch. There is an optional unmint fee with a value\n///         that can be updated in a two-step, governance-controlled process.\n///         All governable parameters are controlled by two roles: update\n///         initiator and finalizer. There is a separate initiator role for\n///         unmint fee update and vending machine upgrade. The initiator\n///         proposes the change by initiating the update and the finalizer\n///         (contract owner) may approve it by finalizing the change after the\n///         governance delay passes.\ncontract VendingMachine is Ownable, IReceiveApproval {\n    using SafeERC20 for IERC20;\n    using SafeERC20 for TBTC;\n\n    /// @notice The time delay that needs to pass between initializing and\n    ///         finalizing update of any governable parameter in this contract.\n    uint256 public constant GOVERNANCE_DELAY = 7 days;\n\n    /// @notice Divisor for precision purposes. Used to represent fractions\n    ///         in parameter values.\n    uint256 public constant FLOATING_POINT_DIVISOR = 1e18;\n\n    IERC20 public immutable tbtcV1;\n    TBTC public immutable tbtcV2;\n\n    /// @notice The fee for unminting TBTC v2 back into TBTC v1 represented as\n    ///         1e18 precision fraction. The fee is proportional to the amount\n    ///         being unminted and added on the top of the amount being unminted.\n    ///         To calculate the fee value, the amount being unminted needs\n    ///         to be multiplied by `unmintFee` and divided by 1e18.\n    ///         For example, `unmintFee` set to 1000000000000000\n    ///         means that 0.001 of the amount being unminted needs to be paid\n    ///         to the `VendingMachine` as an unminting fee on the top of the\n    ///         amount being unminted.\n    uint256 public unmintFee;\n    uint256 public newUnmintFee;\n    uint256 public unmintFeeUpdateInitiatedTimestamp;\n    address public unmintFeeUpdateInitiator;\n\n    /// @notice The address of a new vending machine. Set only when the upgrade\n    ///         process is pending. Once the upgrade gets finalized, the new\n    ///         vending machine will become an owner of TBTC v2 token.\n    address public newVendingMachine;\n    uint256 public vendingMachineUpgradeInitiatedTimestamp;\n    address public vendingMachineUpgradeInitiator;\n\n    event UnmintFeeUpdateInitiated(uint256 newUnmintFee, uint256 timestamp);\n    event UnmintFeeUpdated(uint256 newUnmintFee);\n\n    event VendingMachineUpgradeInitiated(\n        address newVendingMachine,\n        uint256 timestamp\n    );\n    event VendingMachineUpgraded(address newVendingMachine);\n\n    event Minted(address indexed recipient, uint256 amount);\n    event Unminted(address indexed recipient, uint256 amount, uint256 fee);\n\n    modifier only(address authorizedCaller) {\n        require(msg.sender == authorizedCaller, \"Caller is not authorized\");\n        _;\n    }\n\n    modifier onlyAfterGovernanceDelay(uint256 changeInitiatedTimestamp) {\n        GovernanceUtils.onlyAfterGovernanceDelay(\n            changeInitiatedTimestamp,\n            GOVERNANCE_DELAY\n        );\n        _;\n    }\n\n    constructor(\n        IERC20 _tbtcV1,\n        TBTC _tbtcV2,\n        uint256 _unmintFee\n    ) {\n        tbtcV1 = _tbtcV1;\n        tbtcV2 = _tbtcV2;\n        unmintFee = _unmintFee;\n\n        unmintFeeUpdateInitiator = msg.sender;\n        vendingMachineUpgradeInitiator = msg.sender;\n    }\n\n    /// @notice Mints TBTC v2 to the caller from TBTC v1 with 1:1 ratio.\n    ///         The caller needs to have at least `amount` of TBTC v1 balance\n    ///         approved for transfer to the `VendingMachine` before calling\n    ///         this function.\n    /// @param amount The amount of TBTC v2 to mint from TBTC v1\n    function mint(uint256 amount) external {\n        _mint(msg.sender, amount);\n    }\n\n    /// @notice Mints TBTC v2 to `from` address from TBTC v1 with 1:1 ratio.\n    ///         `from` address needs to have at least `amount` of TBTC v1\n    ///         balance approved for transfer to the `VendingMachine` before\n    ///         calling this function.\n    /// @dev This function is a shortcut for approve + mint. Only TBTC v1\n    ///      caller is allowed and only TBTC v1 is allowed as a token to\n    ///      transfer.\n    /// @param from TBTC v1 token holder minting TBTC v2 tokens\n    /// @param amount The amount of TBTC v2 to mint from TBTC v1\n    /// @param token TBTC v1 token address\n    function receiveApproval(\n        address from,\n        uint256 amount,\n        address token,\n        bytes calldata\n    ) external override {\n        require(token == address(tbtcV1), \"Token is not TBTC v1\");\n        require(msg.sender == address(tbtcV1), \"Only TBTC v1 caller allowed\");\n        _mint(from, amount);\n    }\n\n    /// @notice Unmints TBTC v2 from the caller into TBTC v1. Depending on\n    ///         `unmintFee` value, may require paying an additional unmint fee\n    ///         in TBTC v2 in addition to the amount being unminted. To see\n    ///         what is the value of the fee, please call `unmintFeeFor(amount)`\n    ///         function. The caller needs to have at least\n    ///         `amount + unmintFeeFor(amount)` of TBTC v2 balance approved for\n    ///         transfer to the `VendingMachine` before calling this function.\n    /// @param amount The amount of TBTC v2 to unmint to TBTC v1\n    function unmint(uint256 amount) external {\n        uint256 fee = unmintFeeFor(amount);\n        emit Unminted(msg.sender, amount, fee);\n\n        require(\n            tbtcV2.balanceOf(msg.sender) >= amount + fee,\n            \"Amount + fee exceeds TBTC v2 balance\"\n        );\n\n        tbtcV2.safeTransferFrom(msg.sender, address(this), fee);\n        tbtcV2.burnFrom(msg.sender, amount);\n        tbtcV1.safeTransfer(msg.sender, amount);\n    }\n\n    /// @notice Allows the Governance to withdraw unmint fees accumulated by\n    ///         `VendingMachine`.\n    /// @param recipient The address receiving the fees\n    /// @param amount The amount of fees in TBTC v2 to withdraw\n    function withdrawFees(address recipient, uint256 amount)\n        external\n        onlyOwner\n    {\n        tbtcV2.safeTransfer(recipient, amount);\n    }\n\n    /// @notice Initiates unmint fee update process. The update process needs to\n    ///         be finalized with a call to `finalizeUnmintFeeUpdate` function\n    ///         after the `GOVERNANCE_DELAY` passes. Only unmint fee update\n    ///         initiator role can initiate the update.\n    /// @param _newUnmintFee The new unmint fee\n    function initiateUnmintFeeUpdate(uint256 _newUnmintFee)\n        external\n        only(unmintFeeUpdateInitiator)\n    {\n        /* solhint-disable-next-line not-rely-on-time */\n        emit UnmintFeeUpdateInitiated(_newUnmintFee, block.timestamp);\n        newUnmintFee = _newUnmintFee;\n        /* solhint-disable-next-line not-rely-on-time */\n        unmintFeeUpdateInitiatedTimestamp = block.timestamp;\n    }\n\n    /// @notice Allows the contract owner to finalize unmint fee update process.\n    ///         The update process needs to be first initiated with a call to\n    ///         `initiateUnmintFeeUpdate` and the `GOVERNANCE_DELAY` needs to\n    ///         pass.\n    function finalizeUnmintFeeUpdate()\n        external\n        onlyOwner\n        onlyAfterGovernanceDelay(unmintFeeUpdateInitiatedTimestamp)\n    {\n        emit UnmintFeeUpdated(newUnmintFee);\n        unmintFee = newUnmintFee;\n        newUnmintFee = 0;\n        unmintFeeUpdateInitiatedTimestamp = 0;\n    }\n\n    /// @notice Initiates vending machine upgrade process. The upgrade process\n    ///          needs to be finalized with a call to\n    ///         `finalizeVendingMachineUpgrade` function after the\n    ///         `GOVERNANCE_DELAY` passes. Only vending machine upgrade\n    ///         initiator role can initiate the upgrade.\n    /// @param _newVendingMachine The new vending machine address\n    function initiateVendingMachineUpgrade(address _newVendingMachine)\n        external\n        only(vendingMachineUpgradeInitiator)\n    {\n        require(\n            _newVendingMachine != address(0),\n            \"New VendingMachine cannot be zero address\"\n        );\n\n        emit VendingMachineUpgradeInitiated(\n            _newVendingMachine,\n            /* solhint-disable-next-line not-rely-on-time */\n            block.timestamp\n        );\n        newVendingMachine = _newVendingMachine;\n        /* solhint-disable-next-line not-rely-on-time */\n        vendingMachineUpgradeInitiatedTimestamp = block.timestamp;\n    }\n\n    /// @notice Allows the contract owner to finalize vending machine upgrade\n    ///         process. The upgrade process needs to be first initiated with a\n    ///         call to `initiateVendingMachineUpgrade` and the `GOVERNANCE_DELAY`\n    ///         needs to pass. Once the upgrade is finalized, the new vending\n    ///         machine will become an owner of TBTC v2 token and all TBTC v1\n    ///         held by this contract will be transferred to the new vending\n    ///         machine.\n    function finalizeVendingMachineUpgrade()\n        external\n        onlyOwner\n        onlyAfterGovernanceDelay(vendingMachineUpgradeInitiatedTimestamp)\n    {\n        emit VendingMachineUpgraded(newVendingMachine);\n        //slither-disable-next-line reentrancy-no-eth\n        tbtcV2.transferOwnership(newVendingMachine);\n        tbtcV1.safeTransfer(newVendingMachine, tbtcV1.balanceOf(address(this)));\n        newVendingMachine = address(0);\n        vendingMachineUpgradeInitiatedTimestamp = 0;\n    }\n\n    /// @notice Transfers unmint fee update initiator role to another address.\n    ///         Can be called only by the current unmint fee update initiator.\n    /// @param newInitiator The new unmint fee update initiator\n    function transferUnmintFeeUpdateInitiatorRole(address newInitiator)\n        external\n        only(unmintFeeUpdateInitiator)\n    {\n        require(\n            newInitiator != address(0),\n            \"New initiator must not be zero address\"\n        );\n        unmintFeeUpdateInitiator = newInitiator;\n    }\n\n    /// @notice Transfers vending machine upgrade initiator role to another\n    ///         address. Can be called only by the current vending machine\n    ///         upgrade initiator.\n    /// @param newInitiator The new vending machine upgrade initator\n    function transferVendingMachineUpgradeInitiatorRole(address newInitiator)\n        external\n        only(vendingMachineUpgradeInitiator)\n    {\n        require(\n            newInitiator != address(0),\n            \"New initiator must not be zero address\"\n        );\n        vendingMachineUpgradeInitiator = newInitiator;\n    }\n\n    /// @notice Get the remaining time that needs to pass until unmint fee\n    ///         update can be finalized by the Governance. If the update has\n    ///         not been initiated, the function reverts.\n    function getRemainingUnmintFeeUpdateTime() external view returns (uint256) {\n        return\n            GovernanceUtils.getRemainingGovernanceDelay(\n                unmintFeeUpdateInitiatedTimestamp,\n                GOVERNANCE_DELAY\n            );\n    }\n\n    /// @notice Get the remaining time that needs to pass until vending machine\n    ///         upgrade can be finalized by the Governance. If the upgrade has\n    ///         not been initiated, the function reverts.\n    function getRemainingVendingMachineUpgradeTime()\n        external\n        view\n        returns (uint256)\n    {\n        return\n            GovernanceUtils.getRemainingGovernanceDelay(\n                vendingMachineUpgradeInitiatedTimestamp,\n                GOVERNANCE_DELAY\n            );\n    }\n\n    /// @notice Calculates the fee that needs to be paid to the `VendingMachine`\n    ///         to unmint the given amount of TBTC v2 back into TBTC v1.\n    function unmintFeeFor(uint256 amount) public view returns (uint256) {\n        return (amount * unmintFee) / FLOATING_POINT_DIVISOR;\n    }\n\n    function _mint(address tokenOwner, uint256 amount) internal {\n        emit Minted(tokenOwner, amount);\n        tbtcV1.safeTransferFrom(tokenOwner, address(this), amount);\n        tbtcV2.mint(tokenOwner, amount);\n    }\n}\n"
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport \"@thesis/solidity-contracts/contracts/token/IReceiveApproval.sol\";\n\nimport \"../token/TBTC.sol\";\nimport \"../GovernanceUtils.sol\";\n\n/// @title TBTC v2 Vending Machine\n/// @notice The Vending Machine is the owner of TBTC v2 token and can mint\n///         TBTC v2 tokens in 1:1 ratio from TBTC v1 tokens with TBTC v1\n///         deposited in the contract as collateral. TBTC v2 can be\n///         unminted back to TBTC v1 with or without a fee - fee parameter is\n///         controlled by the Governance. This implementation acts as a bridge\n///         between TBTC v1 and TBTC v2 token, allowing to mint TBTC v2 before\n///         the system is ready and fully operational without sacrificing any\n///         security guarantees and decentralization of the project.\n///         Vending Machine can be upgraded in a two-step, governance-controlled\n///         process. The new version of the Vending Machine will receive the\n///         ownership of TBTC v2 token and entire TBTC v1 balance stored as\n///         collateral. It is expected that this process will be executed before\n///         the v2 system launch. There is an optional unmint fee with a value\n///         that can be updated in a two-step, governance-controlled process.\n///         All governable parameters are controlled by two roles: update\n///         initiator and finalizer. There is a separate initiator role for\n///         unmint fee update and vending machine upgrade. The initiator\n///         proposes the change by initiating the update and the finalizer\n///         (contract owner) may approve it by finalizing the change after the\n///         governance delay passes.\ncontract VendingMachine is Ownable, IReceiveApproval {\n    using SafeERC20 for IERC20;\n    using SafeERC20 for TBTC;\n\n    /// @notice The time delay that needs to pass between initializing and\n    ///         finalizing update of any governable parameter in this contract.\n    uint256 public constant GOVERNANCE_DELAY = 7 days;\n\n    /// @notice Divisor for precision purposes. Used to represent fractions\n    ///         in parameter values.\n    uint256 public constant FLOATING_POINT_DIVISOR = 1e18;\n\n    IERC20 public immutable tbtcV1;\n    TBTC public immutable tbtcV2;\n\n    /// @notice The fee for unminting TBTC v2 back into TBTC v1 represented as\n    ///         1e18 precision fraction. The fee is proportional to the amount\n    ///         being unminted and added on the top of the amount being unminted.\n    ///         To calculate the fee value, the amount being unminted needs\n    ///         to be multiplied by `unmintFee` and divided by 1e18.\n    ///         For example, `unmintFee` set to 1000000000000000\n    ///         means that 0.001 of the amount being unminted needs to be paid\n    ///         to the `VendingMachine` as an unminting fee on the top of the\n    ///         amount being unminted.\n    uint256 public unmintFee;\n    uint256 public newUnmintFee;\n    uint256 public unmintFeeUpdateInitiatedTimestamp;\n    address public unmintFeeUpdateInitiator;\n\n    /// @notice The address of a new vending machine. Set only when the upgrade\n    ///         process is pending. Once the upgrade gets finalized, the new\n    ///         vending machine will become an owner of TBTC v2 token.\n    address public newVendingMachine;\n    uint256 public vendingMachineUpgradeInitiatedTimestamp;\n    address public vendingMachineUpgradeInitiator;\n\n    event UnmintFeeUpdateInitiated(uint256 newUnmintFee, uint256 timestamp);\n    event UnmintFeeUpdated(uint256 newUnmintFee);\n\n    event VendingMachineUpgradeInitiated(\n        address newVendingMachine,\n        uint256 timestamp\n    );\n    event VendingMachineUpgraded(address newVendingMachine);\n\n    event Minted(address indexed recipient, uint256 amount);\n    event Unminted(address indexed recipient, uint256 amount, uint256 fee);\n\n    modifier only(address authorizedCaller) {\n        require(msg.sender == authorizedCaller, \"Caller is not authorized\");\n        _;\n    }\n\n    modifier onlyAfterGovernanceDelay(uint256 changeInitiatedTimestamp) {\n        GovernanceUtils.onlyAfterGovernanceDelay(\n            changeInitiatedTimestamp,\n            GOVERNANCE_DELAY\n        );\n        _;\n    }\n\n    constructor(\n        IERC20 _tbtcV1,\n        TBTC _tbtcV2,\n        uint256 _unmintFee\n    ) {\n        tbtcV1 = _tbtcV1;\n        tbtcV2 = _tbtcV2;\n        unmintFee = _unmintFee;\n\n        unmintFeeUpdateInitiator = msg.sender;\n        vendingMachineUpgradeInitiator = msg.sender;\n    }\n\n    /// @notice Mints TBTC v2 to the caller from TBTC v1 with 1:1 ratio.\n    ///         The caller needs to have at least `amount` of TBTC v1 balance\n    ///         approved for transfer to the `VendingMachine` before calling\n    ///         this function.\n    /// @param amount The amount of TBTC v2 to mint from TBTC v1\n    function mint(uint256 amount) external {\n        _mint(msg.sender, amount);\n    }\n\n    /// @notice Mints TBTC v2 to `from` address from TBTC v1 with 1:1 ratio.\n    ///         `from` address needs to have at least `amount` of TBTC v1\n    ///         balance approved for transfer to the `VendingMachine` before\n    ///         calling this function.\n    /// @dev This function is a shortcut for approve + mint. Only TBTC v1\n    ///      caller is allowed and only TBTC v1 is allowed as a token to\n    ///      transfer.\n    /// @param from TBTC v1 token holder minting TBTC v2 tokens\n    /// @param amount The amount of TBTC v2 to mint from TBTC v1\n    /// @param token TBTC v1 token address\n    function receiveApproval(\n        address from,\n        uint256 amount,\n        address token,\n        bytes calldata\n    ) external override {\n        require(token == address(tbtcV1), \"Token is not TBTC v1\");\n        require(msg.sender == address(tbtcV1), \"Only TBTC v1 caller allowed\");\n        _mint(from, amount);\n    }\n\n    /// @notice Unmints TBTC v2 from the caller into TBTC v1. Depending on\n    ///         `unmintFee` value, may require paying an additional unmint fee\n    ///         in TBTC v2 in addition to the amount being unminted. To see\n    ///         what is the value of the fee, please call `unmintFeeFor(amount)`\n    ///         function. The caller needs to have at least\n    ///         `amount + unmintFeeFor(amount)` of TBTC v2 balance approved for\n    ///         transfer to the `VendingMachine` before calling this function.\n    /// @param amount The amount of TBTC v2 to unmint to TBTC v1\n    function unmint(uint256 amount) external {\n        uint256 fee = unmintFeeFor(amount);\n        emit Unminted(msg.sender, amount, fee);\n\n        require(\n            tbtcV2.balanceOf(msg.sender) >= amount + fee,\n            \"Amount + fee exceeds TBTC v2 balance\"\n        );\n\n        tbtcV2.safeTransferFrom(msg.sender, address(this), fee);\n        tbtcV2.burnFrom(msg.sender, amount);\n        tbtcV1.safeTransfer(msg.sender, amount);\n    }\n\n    /// @notice Allows the Governance to withdraw unmint fees accumulated by\n    ///         `VendingMachine`.\n    /// @param recipient The address receiving the fees\n    /// @param amount The amount of fees in TBTC v2 to withdraw\n    function withdrawFees(address recipient, uint256 amount)\n        external\n        onlyOwner\n    {\n        tbtcV2.safeTransfer(recipient, amount);\n    }\n\n    /// @notice Initiates unmint fee update process. The update process needs to\n    ///         be finalized with a call to `finalizeUnmintFeeUpdate` function\n    ///         after the `GOVERNANCE_DELAY` passes. Only unmint fee update\n    ///         initiator role can initiate the update.\n    /// @param _newUnmintFee The new unmint fee\n    function initiateUnmintFeeUpdate(uint256 _newUnmintFee)\n        external\n        only(unmintFeeUpdateInitiator)\n    {\n        /* solhint-disable-next-line not-rely-on-time */\n        emit UnmintFeeUpdateInitiated(_newUnmintFee, block.timestamp);\n        newUnmintFee = _newUnmintFee;\n        /* solhint-disable-next-line not-rely-on-time */\n        unmintFeeUpdateInitiatedTimestamp = block.timestamp;\n    }\n\n    /// @notice Allows the contract owner to finalize unmint fee update process.\n    ///         The update process needs to be first initiated with a call to\n    ///         `initiateUnmintFeeUpdate` and the `GOVERNANCE_DELAY` needs to\n    ///         pass.\n    function finalizeUnmintFeeUpdate()\n        external\n        onlyOwner\n        onlyAfterGovernanceDelay(unmintFeeUpdateInitiatedTimestamp)\n    {\n        emit UnmintFeeUpdated(newUnmintFee);\n        unmintFee = newUnmintFee;\n        newUnmintFee = 0;\n        unmintFeeUpdateInitiatedTimestamp = 0;\n    }\n\n    /// @notice Initiates vending machine upgrade process. The upgrade process\n    ///          needs to be finalized with a call to\n    ///         `finalizeVendingMachineUpgrade` function after the\n    ///         `GOVERNANCE_DELAY` passes. Only vending machine upgrade\n    ///         initiator role can initiate the upgrade.\n    /// @param _newVendingMachine The new vending machine address\n    function initiateVendingMachineUpgrade(address _newVendingMachine)\n        external\n        only(vendingMachineUpgradeInitiator)\n    {\n        require(\n            _newVendingMachine != address(0),\n            \"New VendingMachine cannot be zero address\"\n        );\n\n        emit VendingMachineUpgradeInitiated(\n            _newVendingMachine,\n            /* solhint-disable-next-line not-rely-on-time */\n            block.timestamp\n        );\n        newVendingMachine = _newVendingMachine;\n        /* solhint-disable-next-line not-rely-on-time */\n        vendingMachineUpgradeInitiatedTimestamp = block.timestamp;\n    }\n\n    /// @notice Allows the contract owner to finalize vending machine upgrade\n    ///         process. The upgrade process needs to be first initiated with a\n    ///         call to `initiateVendingMachineUpgrade` and the `GOVERNANCE_DELAY`\n    ///         needs to pass. Once the upgrade is finalized, the new vending\n    ///         machine will become an owner of TBTC v2 token and all TBTC v1\n    ///         held by this contract will be transferred to the new vending\n    ///         machine.\n    function finalizeVendingMachineUpgrade()\n        external\n        onlyOwner\n        onlyAfterGovernanceDelay(vendingMachineUpgradeInitiatedTimestamp)\n    {\n        emit VendingMachineUpgraded(newVendingMachine);\n        //slither-disable-next-line reentrancy-no-eth\n        tbtcV2.transferOwnership(newVendingMachine);\n        tbtcV1.safeTransfer(newVendingMachine, tbtcV1.balanceOf(address(this)));\n        newVendingMachine = address(0);\n        vendingMachineUpgradeInitiatedTimestamp = 0;\n    }\n\n    /// @notice Transfers unmint fee update initiator role to another address.\n    ///         Can be called only by the current unmint fee update initiator.\n    /// @param newInitiator The new unmint fee update initiator\n    function transferUnmintFeeUpdateInitiatorRole(address newInitiator)\n        external\n        only(unmintFeeUpdateInitiator)\n    {\n        require(\n            newInitiator != address(0),\n            \"New initiator must not be zero address\"\n        );\n        unmintFeeUpdateInitiator = newInitiator;\n    }\n\n    /// @notice Transfers vending machine upgrade initiator role to another\n    ///         address. Can be called only by the current vending machine\n    ///         upgrade initiator.\n    /// @param newInitiator The new vending machine upgrade initiator\n    function transferVendingMachineUpgradeInitiatorRole(address newInitiator)\n        external\n        only(vendingMachineUpgradeInitiator)\n    {\n        require(\n            newInitiator != address(0),\n            \"New initiator must not be zero address\"\n        );\n        vendingMachineUpgradeInitiator = newInitiator;\n    }\n\n    /// @notice Get the remaining time that needs to pass until unmint fee\n    ///         update can be finalized by the Governance. If the update has\n    ///         not been initiated, the function reverts.\n    function getRemainingUnmintFeeUpdateTime() external view returns (uint256) {\n        return\n            GovernanceUtils.getRemainingGovernanceDelay(\n                unmintFeeUpdateInitiatedTimestamp,\n                GOVERNANCE_DELAY\n            );\n    }\n\n    /// @notice Get the remaining time that needs to pass until vending machine\n    ///         upgrade can be finalized by the Governance. If the upgrade has\n    ///         not been initiated, the function reverts.\n    function getRemainingVendingMachineUpgradeTime()\n        external\n        view\n        returns (uint256)\n    {\n        return\n            GovernanceUtils.getRemainingGovernanceDelay(\n                vendingMachineUpgradeInitiatedTimestamp,\n                GOVERNANCE_DELAY\n            );\n    }\n\n    /// @notice Calculates the fee that needs to be paid to the `VendingMachine`\n    ///         to unmint the given amount of TBTC v2 back into TBTC v1.\n    function unmintFeeFor(uint256 amount) public view returns (uint256) {\n        return (amount * unmintFee) / FLOATING_POINT_DIVISOR;\n    }\n\n    function _mint(address tokenOwner, uint256 amount) internal {\n        emit Minted(tokenOwner, amount);\n        tbtcV1.safeTransferFrom(tokenOwner, address(this), amount);\n        tbtcV2.mint(tokenOwner, amount);\n    }\n}\n"
     },
     "contracts/test/ReceiveApprovalStub.sol": {
       "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.9;\n\nimport \"../token/TBTC.sol\";\n\ncontract ReceiveApprovalStub is IReceiveApproval {\n    bool public shouldRevert;\n\n    event ApprovalReceived(\n        address from,\n        uint256 value,\n        address token,\n        bytes extraData\n    );\n\n    function receiveApproval(\n        address from,\n        uint256 value,\n        address token,\n        bytes calldata extraData\n    ) external override {\n        if (shouldRevert) {\n            revert(\"i am your father luke\");\n        }\n\n        emit ApprovalReceived(from, value, token, extraData);\n    }\n\n    function setShouldRevert(bool _shouldRevert) external {\n        shouldRevert = _shouldRevert;\n    }\n}\n"
@@ -152,7 +152,7 @@
       "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    ///         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"
+      "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 `redeemer`.\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 `redeemer` 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        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"

package/build/contracts/GovernanceUtils.sol/GovernanceUtils.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../build-info/e07d01dafd7ce3616d5d05f91c8194b1.json"
+  "buildInfo": "../../build-info/403fd8e633def74564a38859b2f54294.json"
 }

package/build/contracts/bank/Bank.sol/Bank.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/e07d01dafd7ce3616d5d05f91c8194b1.json"
+  "buildInfo": "../../../build-info/403fd8e633def74564a38859b2f54294.json"
 }

package/build/contracts/bank/IReceiveBalanceApproval.sol/IReceiveBalanceApproval.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/e07d01dafd7ce3616d5d05f91c8194b1.json"
+  "buildInfo": "../../../build-info/403fd8e633def74564a38859b2f54294.json"
 }

package/build/contracts/bridge/BitcoinTx.sol/BitcoinTx.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/e07d01dafd7ce3616d5d05f91c8194b1.json"
+  "buildInfo": "../../../build-info/403fd8e633def74564a38859b2f54294.json"
 }

package/build/contracts/bridge/BitcoinTx.sol/BitcoinTx.json

@@ -3,8 +3,8 @@
   "contractName": "BitcoinTx",
   "sourceName": "contracts/bridge/BitcoinTx.sol",
   "abi": [],
-  "bytecode": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220859c0bd8a513718aefb371dbcc1d8995fa266e02e96de41acaba9edd4bf41b7f64736f6c63430008090033",
-  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220859c0bd8a513718aefb371dbcc1d8995fa266e02e96de41acaba9edd4bf41b7f64736f6c63430008090033",
+  "bytecode": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212209ae07158c2143ccdec75523e8bcdcf71d46baecf4b444f6549840cf4483e11e464736f6c63430008090033",
+  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212209ae07158c2143ccdec75523e8bcdcf71d46baecf4b444f6549840cf4483e11e464736f6c63430008090033",
   "linkReferences": {},
   "deployedLinkReferences": {}
 }

package/build/contracts/bridge/Bridge.sol/Bridge.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/e07d01dafd7ce3616d5d05f91c8194b1.json"
+  "buildInfo": "../../../build-info/403fd8e633def74564a38859b2f54294.json"
 }