@keep-network/tbtc-v2 0.1.1-dev.55 → 0.1.1-dev.58

package/artifacts/solcInputs/{6d69fc514efd874ebb1cb86b04981772.json → 452e42f1afe94d8639a5bf98bed9e151.json}

@@ -113,7 +113,7 @@
       "content": "// SPDX-License-Identifier: MIT\n//\n// ▓▓▌ ▓▓ ▐▓▓ ▓▓▓▓▓▓▓▓▓▓▌▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▄\n// ▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▌▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓\n//   ▓▓▓▓▓▓    ▓▓▓▓▓▓▓▀    ▐▓▓▓▓▓▓    ▐▓▓▓▓▓   ▓▓▓▓▓▓     ▓▓▓▓▓   ▐▓▓▓▓▓▌   ▐▓▓▓▓▓▓\n//   ▓▓▓▓▓▓▄▄▓▓▓▓▓▓▓▀      ▐▓▓▓▓▓▓▄▄▄▄         ▓▓▓▓▓▓▄▄▄▄         ▐▓▓▓▓▓▌   ▐▓▓▓▓▓▓\n//   ▓▓▓▓▓▓▓▓▓▓▓▓▓▀        ▐▓▓▓▓▓▓▓▓▓▓         ▓▓▓▓▓▓▓▓▓▓         ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓\n//   ▓▓▓▓▓▓▀▀▓▓▓▓▓▓▄       ▐▓▓▓▓▓▓▀▀▀▀         ▓▓▓▓▓▓▀▀▀▀         ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▀\n//   ▓▓▓▓▓▓   ▀▓▓▓▓▓▓▄     ▐▓▓▓▓▓▓     ▓▓▓▓▓   ▓▓▓▓▓▓     ▓▓▓▓▓   ▐▓▓▓▓▓▌\n// ▓▓▓▓▓▓▓▓▓▓ █▓▓▓▓▓▓▓▓▓ ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓▓▓\n// ▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓ ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓▓▓\n//\n//\n\n// Initial version copied from Keep Network Random Beacon:\n// https://github.com/keep-network/keep-core/blob/5138c7628868dbeed3ae2164f76fccc6c1fbb9e8/solidity/random-beacon/contracts/libraries/DKG.sol\n//\n// With the following differences:\n// - the group size was set to 100,\n// - offchainDkgTimeout was removed,\n// - submission eligibility verification is not performed on-chain,\n// - submission eligibility delay was replaced with a submission timeout,\n// - seed timeout notification requires seedTimeout period to pass.\n\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\";\nimport \"@keep-network/sortition-pools/contracts/SortitionPool.sol\";\nimport \"@keep-network/random-beacon/contracts/libraries/BytesLib.sol\";\nimport \"../EcdsaDkgValidator.sol\";\n\nlibrary EcdsaDkg {\n    using BytesLib for bytes;\n    using ECDSA for bytes32;\n\n    struct Parameters {\n        // Time in blocks during which a seed is expected to be delivered.\n        // DKG starts only after a seed is delivered. The time the contract\n        // awaits for a seed is not included in the DKG timeout.\n        uint256 seedTimeout;\n        // Time in blocks during which a submitted result can be challenged.\n        uint256 resultChallengePeriodLength;\n        // Time in blocks during which a result is expected to be submitted.\n        uint256 resultSubmissionTimeout;\n        // Time in blocks during which only the result submitter is allowed to\n        // approve it. Once this period ends and the submitter have not approved\n        // the result, anyone can do it.\n        uint256 submitterPrecedencePeriodLength;\n    }\n\n    struct Data {\n        // Address of the Sortition Pool contract.\n        SortitionPool sortitionPool;\n        // Address of the EcdsaDkgValidator contract.\n        EcdsaDkgValidator dkgValidator;\n        // DKG parameters. The parameters should persist between DKG executions.\n        // They should be updated with dedicated set functions only when DKG is not\n        // in progress.\n        Parameters parameters;\n        // Time in block at which DKG state was locked.\n        uint256 stateLockBlock;\n        // Time in blocks at which DKG started.\n        uint256 startBlock;\n        // Seed used to start DKG.\n        uint256 seed;\n        // Time in blocks that should be added to result submission eligibility\n        // delay calculation. It is used in case of a challenge to adjust\n        // DKG timeout calculation.\n        uint256 resultSubmissionStartBlockOffset;\n        // Hash of submitted DKG result.\n        bytes32 submittedResultHash;\n        // Block number from the moment of the DKG result submission.\n        uint256 submittedResultBlock;\n    }\n\n    /// @notice DKG result.\n    struct Result {\n        // Claimed submitter candidate group member index.\n        // Must be in range [1, groupSize].\n        uint256 submitterMemberIndex;\n        // Generated candidate group public key\n        bytes groupPubKey;\n        // Array of misbehaved members indices (disqualified or inactive).\n        // Indices must be in range [1, groupSize], unique, and sorted in ascending\n        // order.\n        uint8[] misbehavedMembersIndices;\n        // Concatenation of signatures from members supporting the result.\n        // The message to be signed by each member is keccak256 hash of the\n        // calculated group public key, misbehaved members indices and DKG\n        // start block. The calculated hash should be prefixed with prefixed with\n        // `\\x19Ethereum signed message:\\n` before signing, so the message to\n        // sign is:\n        // `\\x19Ethereum signed message:\\n${keccak256(\n        //    groupPubKey, misbehavedMembersIndices, dkgStartBlock\n        // )}`\n        bytes signatures;\n        // Indices of members corresponding to each signature. Indices must be\n        // be in range [1, groupSize], unique, and sorted in ascending order.\n        uint256[] signingMembersIndices;\n        // Identifiers of candidate group members as outputted by the group\n        // selection protocol.\n        uint32[] members;\n        // Keccak256 hash of group members identifiers that actively took part\n        // in DKG (excluding IA/DQ members).\n        bytes32 membersHash;\n    }\n\n    /// @notice States for phases of group creation. The states doesn't include\n    ///         timeouts which should be tracked and notified individually.\n    enum State {\n        // Group creation is not in progress. It is a state set after group creation\n        // completion either by timeout or by a result approval.\n        IDLE,\n        // Group creation is awaiting the seed and sortition pool is locked.\n        AWAITING_SEED,\n        // DKG protocol execution is in progress. A result is being calculated\n        // by the clients in this state and the contract awaits a result submission.\n        // This is a state to which group creation returns in case of a result\n        // challenge notification.\n        AWAITING_RESULT,\n        // DKG result was submitted and awaits an approval or a challenge. If a result\n        // gets challenge the state returns to `AWAITING_RESULT`. If a result gets\n        // approval the state changes to `IDLE`.\n        CHALLENGE\n    }\n\n    /// @dev Size of a group in ECDSA wallet.\n    uint256 public constant groupSize = 100;\n\n    event DkgStarted(uint256 indexed seed);\n\n    // To recreate the members that actively took part in dkg, the selected members\n    // array should be filtered out from misbehavedMembersIndices.\n    event DkgResultSubmitted(\n        bytes32 indexed resultHash,\n        uint256 indexed seed,\n        Result result\n    );\n\n    event DkgTimedOut();\n\n    event DkgResultApproved(\n        bytes32 indexed resultHash,\n        address indexed approver\n    );\n\n    event DkgResultChallenged(\n        bytes32 indexed resultHash,\n        address indexed challenger,\n        string reason\n    );\n\n    event DkgStateLocked();\n\n    event DkgSeedTimedOut();\n\n    /// @notice Initializes SortitionPool and EcdsaDkgValidator addresses.\n    ///        Can be performed only once.\n    /// @param _sortitionPool Sortition Pool reference\n    /// @param _dkgValidator EcdsaDkgValidator reference\n    function init(\n        Data storage self,\n        SortitionPool _sortitionPool,\n        EcdsaDkgValidator _dkgValidator\n    ) internal {\n        require(\n            address(self.sortitionPool) == address(0),\n            \"Sortition Pool address already set\"\n        );\n\n        require(\n            address(self.dkgValidator) == address(0),\n            \"DKG Validator address already set\"\n        );\n\n        self.sortitionPool = _sortitionPool;\n        self.dkgValidator = _dkgValidator;\n    }\n\n    /// @notice Determines the current state of group creation. It doesn't take\n    ///         timeouts into consideration. The timeouts should be tracked and\n    ///         notified separately.\n    function currentState(Data storage self)\n        internal\n        view\n        returns (State state)\n    {\n        state = State.IDLE;\n\n        if (self.sortitionPool.isLocked()) {\n            state = State.AWAITING_SEED;\n\n            if (self.startBlock > 0) {\n                state = State.AWAITING_RESULT;\n\n                if (self.submittedResultBlock > 0) {\n                    state = State.CHALLENGE;\n                }\n            }\n        }\n    }\n\n    /// @notice Locks the sortition pool and starts awaiting for the\n    ///         group creation seed.\n    function lockState(Data storage self) internal {\n        require(currentState(self) == State.IDLE, \"Current state is not IDLE\");\n\n        emit DkgStateLocked();\n\n        self.sortitionPool.lock();\n\n        self.stateLockBlock = block.number;\n    }\n\n    function start(Data storage self, uint256 seed) internal {\n        require(\n            currentState(self) == State.AWAITING_SEED,\n            \"Current state is not AWAITING_SEED\"\n        );\n\n        emit DkgStarted(seed);\n\n        self.startBlock = block.number;\n        self.seed = seed;\n    }\n\n    /// @notice Allows to submit a DKG result. The submitted result does not go\n    ///         through a validation and before it gets accepted, it needs to\n    ///         wait through the challenge period during which everyone has\n    ///         a chance to challenge the result as invalid one. Submitter of\n    ///         the result needs to be in the sortition pool and if the result\n    ///         gets challenged, the submitter will get slashed.\n    function submitResult(Data storage self, Result calldata result) internal {\n        require(\n            currentState(self) == State.AWAITING_RESULT,\n            \"Current state is not AWAITING_RESULT\"\n        );\n        require(!hasDkgTimedOut(self), \"DKG timeout already passed\");\n\n        SortitionPool sortitionPool = self.sortitionPool;\n\n        // Submitter must be an operator in the sortition pool.\n        // Declared submitter's member index in the DKG result needs to match\n        // the address calling this function.\n        require(\n            sortitionPool.isOperatorInPool(msg.sender),\n            \"Submitter not in the sortition pool\"\n        );\n        require(\n            sortitionPool.getIDOperator(\n                result.members[result.submitterMemberIndex - 1]\n            ) == msg.sender,\n            \"Unexpected submitter index\"\n        );\n\n        self.submittedResultHash = keccak256(abi.encode(result));\n        self.submittedResultBlock = block.number;\n\n        emit DkgResultSubmitted(self.submittedResultHash, self.seed, result);\n    }\n\n    /// @notice Checks if awaiting seed timed out.\n    /// @return True if awaiting seed timed out, false otherwise.\n    function hasSeedTimedOut(Data storage self) internal view returns (bool) {\n        return\n            currentState(self) == State.AWAITING_SEED &&\n            block.number > (self.stateLockBlock + self.parameters.seedTimeout);\n    }\n\n    /// @notice Checks if DKG timed out. The DKG timeout period includes time required\n    ///         for off-chain protocol execution and time for the result publication.\n    ///         After this time a result cannot be submitted and DKG can be notified\n    ///         about the timeout. DKG period is adjusted by result submission\n    ///         offset that include blocks that were mined while invalid result\n    ///         has been registered until it got challenged.\n    /// @return True if DKG timed out, false otherwise.\n    function hasDkgTimedOut(Data storage self) internal view returns (bool) {\n        return\n            currentState(self) == State.AWAITING_RESULT &&\n            block.number >\n            (self.startBlock +\n                self.resultSubmissionStartBlockOffset +\n                self.parameters.resultSubmissionTimeout);\n    }\n\n    /// @notice Notifies about the seed was not delivered and restores the\n    ///         initial DKG state (IDLE).\n    function notifySeedTimeout(Data storage self) internal {\n        require(hasSeedTimedOut(self), \"Awaiting seed has not timed out\");\n\n        emit DkgSeedTimedOut();\n\n        complete(self);\n    }\n\n    /// @notice Notifies about DKG timeout.\n    function notifyDkgTimeout(Data storage self) internal {\n        require(hasDkgTimedOut(self), \"DKG has not timed out\");\n\n        emit DkgTimedOut();\n\n        complete(self);\n    }\n\n    /// @notice Approves DKG result. Can be called when the challenge period for\n    ///         the submitted result is finished. Considers the submitted result\n    ///         as valid. For the first `submitterPrecedencePeriodLength`\n    ///         blocks after the end of the challenge period can be called only\n    ///         by the DKG result submitter. After that time, can be called by\n    ///         anyone.\n    /// @dev Can be called after a challenge period for the submitted result.\n    /// @param result Result to approve. Must match the submitted result stored\n    ///        during `submitResult`.\n    /// @return misbehavedMembers Identifiers of members who misbehaved during DKG.\n    function approveResult(Data storage self, Result calldata result)\n        internal\n        returns (uint32[] memory misbehavedMembers)\n    {\n        require(\n            currentState(self) == State.CHALLENGE,\n            \"Current state is not CHALLENGE\"\n        );\n\n        uint256 challengePeriodEnd = self.submittedResultBlock +\n            self.parameters.resultChallengePeriodLength;\n\n        require(\n            block.number > challengePeriodEnd,\n            \"Challenge period has not passed yet\"\n        );\n\n        require(\n            keccak256(abi.encode(result)) == self.submittedResultHash,\n            \"Result under approval is different than the submitted one\"\n        );\n\n        // Extract submitter member address. Submitter member index is in\n        // range [1, groupSize] so we need to -1 when fetching identifier from members\n        // array.\n        address submitterMember = self.sortitionPool.getIDOperator(\n            result.members[result.submitterMemberIndex - 1]\n        );\n\n        require(\n            msg.sender == submitterMember ||\n                block.number >\n                challengePeriodEnd +\n                    self.parameters.submitterPrecedencePeriodLength,\n            \"Only the DKG result submitter can approve the result at this moment\"\n        );\n\n        // Extract misbehaved members identifiers. Misbehaved members indices\n        // are in range [1, groupSize], so we need to -1 when fetching identifiers from\n        // members array.\n        misbehavedMembers = new uint32[](\n            result.misbehavedMembersIndices.length\n        );\n        for (uint256 i = 0; i < result.misbehavedMembersIndices.length; i++) {\n            misbehavedMembers[i] = result.members[\n                result.misbehavedMembersIndices[i] - 1\n            ];\n        }\n\n        emit DkgResultApproved(self.submittedResultHash, msg.sender);\n\n        return misbehavedMembers;\n    }\n\n    /// @notice Challenges DKG result. If the submitted result is proved to be\n    ///         invalid it reverts the DKG back to the result submission phase.\n    /// @dev Can be called during a challenge period for the submitted result.\n    /// @param result Result to challenge. Must match the submitted result\n    ///        stored during `submitResult`.\n    /// @return maliciousResultHash Hash of the malicious result.\n    /// @return maliciousSubmitter Identifier of the malicious submitter.\n    function challengeResult(Data storage self, Result calldata result)\n        internal\n        returns (bytes32 maliciousResultHash, uint32 maliciousSubmitter)\n    {\n        require(\n            currentState(self) == State.CHALLENGE,\n            \"Current state is not CHALLENGE\"\n        );\n\n        require(\n            block.number <=\n                self.submittedResultBlock +\n                    self.parameters.resultChallengePeriodLength,\n            \"Challenge period has already passed\"\n        );\n\n        require(\n            keccak256(abi.encode(result)) == self.submittedResultHash,\n            \"Result under challenge is different than the submitted one\"\n        );\n\n        // https://github.com/crytic/slither/issues/982\n        // slither-disable-next-line unused-return\n        try\n            self.dkgValidator.validate(result, self.seed, self.startBlock)\n        returns (\n            // slither-disable-next-line uninitialized-local,variable-scope\n            bool isValid,\n            // slither-disable-next-line uninitialized-local,variable-scope\n            string memory errorMsg\n        ) {\n            if (isValid) {\n                revert(\"unjustified challenge\");\n            }\n\n            emit DkgResultChallenged(\n                self.submittedResultHash,\n                msg.sender,\n                errorMsg\n            );\n        } catch {\n            // if the validation reverted we consider the DKG result as invalid\n            emit DkgResultChallenged(\n                self.submittedResultHash,\n                msg.sender,\n                \"validation reverted\"\n            );\n        }\n\n        // Consider result hash as malicious.\n        maliciousResultHash = self.submittedResultHash;\n        maliciousSubmitter = result.members[result.submitterMemberIndex - 1];\n\n        // Adjust DKG result submission block start, so submission stage starts\n        // from the beginning.\n        self.resultSubmissionStartBlockOffset = block.number - self.startBlock;\n\n        submittedResultCleanup(self);\n\n        return (maliciousResultHash, maliciousSubmitter);\n    }\n\n    /// @notice Checks if DKG result is valid for the current DKG.\n    /// @param result DKG result.\n    /// @return True if the result is valid. If the result is invalid it returns\n    ///         false and an error message.\n    function isResultValid(Data storage self, Result calldata result)\n        internal\n        view\n        returns (bool, string memory)\n    {\n        require(self.startBlock > 0, \"DKG has not been started\");\n\n        return self.dkgValidator.validate(result, self.seed, self.startBlock);\n    }\n\n    /// @notice Set setSeedTimeout parameter.\n    function setSeedTimeout(Data storage self, uint256 newSeedTimeout)\n        internal\n    {\n        require(currentState(self) == State.IDLE, \"Current state is not IDLE\");\n\n        require(newSeedTimeout > 0, \"New value should be greater than zero\");\n\n        self.parameters.seedTimeout = newSeedTimeout;\n    }\n\n    /// @notice Set resultChallengePeriodLength parameter.\n    function setResultChallengePeriodLength(\n        Data storage self,\n        uint256 newResultChallengePeriodLength\n    ) internal {\n        require(currentState(self) == State.IDLE, \"Current state is not IDLE\");\n\n        require(\n            newResultChallengePeriodLength > 0,\n            \"New value should be greater than zero\"\n        );\n\n        self\n            .parameters\n            .resultChallengePeriodLength = newResultChallengePeriodLength;\n    }\n\n    /// @notice Set resultSubmissionTimeout parameter.\n    function setResultSubmissionTimeout(\n        Data storage self,\n        uint256 newResultSubmissionTimeout\n    ) internal {\n        require(currentState(self) == State.IDLE, \"Current state is not IDLE\");\n\n        require(\n            newResultSubmissionTimeout > 0,\n            \"New value should be greater than zero\"\n        );\n\n        self.parameters.resultSubmissionTimeout = newResultSubmissionTimeout;\n    }\n\n    /// @notice Set submitterPrecedencePeriodLength parameter.\n    function setSubmitterPrecedencePeriodLength(\n        Data storage self,\n        uint256 newSubmitterPrecedencePeriodLength\n    ) internal {\n        require(currentState(self) == State.IDLE, \"Current state is not IDLE\");\n\n        require(\n            newSubmitterPrecedencePeriodLength <\n                self.parameters.resultSubmissionTimeout,\n            \"New value should be less than result submission period length\"\n        );\n\n        self\n            .parameters\n            .submitterPrecedencePeriodLength = newSubmitterPrecedencePeriodLength;\n    }\n\n    /// @notice Completes DKG by cleaning up state.\n    /// @dev Should be called after DKG times out or a result is approved.\n    function complete(Data storage self) internal {\n        delete self.startBlock;\n        delete self.seed;\n        delete self.resultSubmissionStartBlockOffset;\n        submittedResultCleanup(self);\n        self.sortitionPool.unlock();\n    }\n\n    /// @notice Cleans up submitted result state either after DKG completion\n    ///         (as part of `complete` method) or after justified challenge.\n    function submittedResultCleanup(Data storage self) private {\n        delete self.submittedResultHash;\n        delete self.submittedResultBlock;\n    }\n}\n"
     },
     "contracts/bridge/Wallets.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 {EcdsaDkg} from \"@keep-network/ecdsa/contracts/libraries/EcdsaDkg.sol\";\nimport {Math} from \"@openzeppelin/contracts/utils/math/Math.sol\";\n\nimport \"./BitcoinTx.sol\";\nimport \"./EcdsaLib.sol\";\nimport \"./BridgeState.sol\";\n\n/// @title Wallet library\n/// @notice Library responsible for handling integration between Bridge\n///         contract and ECDSA wallets.\nlibrary Wallets {\n    using BTCUtils for bytes;\n\n    /// @notice Represents wallet state:\n    enum WalletState {\n        /// @dev The wallet is unknown to the Bridge.\n        Unknown,\n        /// @dev The wallet can sweep deposits and accept redemption requests.\n        Live,\n        /// @dev The wallet was deemed unhealthy and is expected to move their\n        ///      outstanding funds to another wallet. The wallet can still\n        ///      fulfill their pending redemption requests although new\n        ///      redemption requests and new deposit reveals are not accepted.\n        MovingFunds,\n        /// @dev The wallet moved or redeemed all their funds and is in the\n        ///      closing period where they can be subject of fraud challenges\n        ///      and must defend against them. This state is needed to protect\n        ///      against deposit frauds on deposits revealed but not swept.\n        ///      The closing period must be greater that the deposit refund\n        ///      time plus some time margin.\n        Closing,\n        /// @dev The wallet finalized the closing period successfully and\n        ///      cannot perform any action in the Bridge.\n        Closed,\n        /// @dev The wallet committed a fraud that was reported. The wallet is\n        ///      blocked and can not perform any actions in the Bridge.\n        ///      Off-chain coordination with the wallet operators is needed to\n        ///      recover funds.\n        Terminated\n    }\n\n    /// @notice Holds information about a wallet.\n    struct Wallet {\n        // Identifier of a ECDSA Wallet registered in the ECDSA Wallet Registry.\n        bytes32 ecdsaWalletID;\n        // Latest wallet's main UTXO hash computed as\n        // keccak256(txHash | txOutputIndex | txOutputValue). The `tx` prefix\n        // refers to the transaction which created that main UTXO. The `txHash`\n        // is `bytes32` (ordered as in Bitcoin internally), `txOutputIndex`\n        // an `uint32`, and `txOutputValue` an `uint64` value.\n        bytes32 mainUtxoHash;\n        // The total redeemable value of pending redemption requests targeting\n        // that wallet.\n        uint64 pendingRedemptionsValue;\n        // UNIX timestamp the wallet was created at.\n        uint32 createdAt;\n        // UNIX timestamp indicating the moment the wallet was requested to\n        // move their funds.\n        uint32 movingFundsRequestedAt;\n        // UNIX timestamp indicating the moment the wallet's closing period\n        // started.\n        uint32 closingStartedAt;\n        // Current state of the wallet.\n        WalletState state;\n        // Moving funds target wallet commitment submitted by the wallet. It\n        // is built by applying the keccak256 hash over the list of 20-byte\n        // public key hashes of the target wallets.\n        bytes32 movingFundsTargetWalletsCommitmentHash;\n    }\n\n    event NewWalletRequested();\n\n    event NewWalletRegistered(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletMovingFunds(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletClosing(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletClosed(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletTerminated(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    /// @notice Requests creation of a new wallet. This function just\n    ///         forms a request and the creation process is performed\n    ///         asynchronously. Outcome of that process should be delivered\n    ///         using `registerNewWallet` function.\n    /// @param activeWalletMainUtxo Data of the active wallet's main UTXO, as\n    ///        currently known on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - `activeWalletMainUtxo` components must point to the recent main\n    ///        UTXO of the given active wallet, as currently known on the\n    ///        Ethereum chain. If there is no active wallet at the moment, or\n    ///        the active wallet has no main UTXO, this parameter can be\n    ///        empty as it is ignored.\n    ///      - Wallet creation must not be in progress\n    ///      - If the active wallet is set, one of the following\n    ///        conditions must be true:\n    ///        - The active wallet BTC balance is above the minimum threshold\n    ///          and the active wallet is old enough, i.e. the creation period\n    ///           was elapsed since its creation time\n    ///        - The active wallet BTC balance is above the maximum threshold\n    function requestNewWallet(\n        BridgeState.Storage storage self,\n        BitcoinTx.UTXO calldata activeWalletMainUtxo\n    ) external {\n        require(\n            self.ecdsaWalletRegistry.getWalletCreationState() ==\n                EcdsaDkg.State.IDLE,\n            \"Wallet creation already in progress\"\n        );\n\n        bytes20 activeWalletPubKeyHash = self.activeWalletPubKeyHash;\n\n        // If the active wallet is set, fetch this wallet's details from\n        // storage to perform conditions check. The `registerNewWallet`\n        // function guarantees an active wallet is always one of the\n        // registered ones.\n        if (activeWalletPubKeyHash != bytes20(0)) {\n            uint64 activeWalletBtcBalance = getWalletBtcBalance(\n                self,\n                activeWalletPubKeyHash,\n                activeWalletMainUtxo\n            );\n            uint32 activeWalletCreatedAt = self\n                .registeredWallets[activeWalletPubKeyHash]\n                .createdAt;\n            /* solhint-disable-next-line not-rely-on-time */\n            bool activeWalletOldEnough = block.timestamp >=\n                activeWalletCreatedAt + self.walletCreationPeriod;\n\n            require(\n                (activeWalletOldEnough &&\n                    activeWalletBtcBalance >=\n                    self.walletCreationMinBtcBalance) ||\n                    activeWalletBtcBalance >= self.walletCreationMaxBtcBalance,\n                \"Wallet creation conditions are not met\"\n            );\n        }\n\n        emit NewWalletRequested();\n\n        self.ecdsaWalletRegistry.requestNewWallet();\n    }\n\n    /// @notice Gets BTC balance for given the wallet.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param walletMainUtxo Data of the wallet's main UTXO, as currently\n    ///        known on the Ethereum chain.\n    /// @return walletBtcBalance Current BTC balance for the given wallet.\n    /// @dev Requirements:\n    ///      - `walletMainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        If the wallet has no main UTXO, this parameter can be empty as it\n    ///        is ignored.\n    function getWalletBtcBalance(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata walletMainUtxo\n    ) internal view returns (uint64 walletBtcBalance) {\n        bytes32 walletMainUtxoHash = self\n            .registeredWallets[walletPubKeyHash]\n            .mainUtxoHash;\n\n        // If the wallet has a main UTXO hash set, cross-check it with the\n        // provided plain-text parameter and get the transaction output value\n        // as BTC balance. Otherwise, the BTC balance is just zero.\n        if (walletMainUtxoHash != bytes32(0)) {\n            require(\n                keccak256(\n                    abi.encodePacked(\n                        walletMainUtxo.txHash,\n                        walletMainUtxo.txOutputIndex,\n                        walletMainUtxo.txOutputValue\n                    )\n                ) == walletMainUtxoHash,\n                \"Invalid wallet main UTXO data\"\n            );\n\n            walletBtcBalance = walletMainUtxo.txOutputValue;\n        }\n\n        return walletBtcBalance;\n    }\n\n    /// @notice Registers a new wallet. This function should be called\n    ///         after the wallet creation process initiated using\n    ///         `requestNewWallet` completes and brings the outcomes.\n    /// @param ecdsaWalletID Wallet's unique identifier.\n    /// @param publicKeyX Wallet's public key's X coordinate.\n    /// @param publicKeyY Wallet's public key's Y coordinate.\n    /// @dev Requirements:\n    ///      - The only caller authorized to call this function is `registry`\n    ///      - Given wallet data must not belong to an already registered wallet\n    function registerNewWallet(\n        BridgeState.Storage storage self,\n        bytes32 ecdsaWalletID,\n        bytes32 publicKeyX,\n        bytes32 publicKeyY\n    ) external {\n        require(\n            msg.sender == address(self.ecdsaWalletRegistry),\n            \"Caller is not the ECDSA Wallet Registry\"\n        );\n\n        // Compress wallet's public key and calculate Bitcoin's hash160 of it.\n        bytes20 walletPubKeyHash = bytes20(\n            EcdsaLib.compressPublicKey(publicKeyX, publicKeyY).hash160View()\n        );\n\n        Wallet storage wallet = self.registeredWallets[walletPubKeyHash];\n        require(\n            wallet.state == WalletState.Unknown,\n            \"ECDSA wallet has been already registered\"\n        );\n        wallet.ecdsaWalletID = ecdsaWalletID;\n        wallet.state = WalletState.Live;\n        /* solhint-disable-next-line not-rely-on-time */\n        wallet.createdAt = uint32(block.timestamp);\n\n        // Set the freshly created wallet as the new active wallet.\n        self.activeWalletPubKeyHash = walletPubKeyHash;\n\n        self.liveWalletsCount++;\n\n        emit NewWalletRegistered(ecdsaWalletID, walletPubKeyHash);\n    }\n\n    /// @notice Handles a notification about a wallet heartbeat failure and\n    ///         triggers the wallet moving funds process.\n    /// @param publicKeyX Wallet's public key's X coordinate.\n    /// @param publicKeyY Wallet's public key's Y coordinate.\n    /// @dev Requirements:\n    ///      - The only caller authorized to call this function is `registry`\n    ///      - Wallet must be in Live state\n    function notifyWalletHeartbeatFailed(\n        BridgeState.Storage storage self,\n        bytes32 publicKeyX,\n        bytes32 publicKeyY\n    ) external {\n        require(\n            msg.sender == address(self.ecdsaWalletRegistry),\n            \"Caller is not the ECDSA Wallet Registry\"\n        );\n\n        // Compress wallet's public key and calculate Bitcoin's hash160 of it.\n        bytes20 walletPubKeyHash = bytes20(\n            EcdsaLib.compressPublicKey(publicKeyX, publicKeyY).hash160View()\n        );\n\n        require(\n            self.registeredWallets[walletPubKeyHash].state == WalletState.Live,\n            \"ECDSA wallet must be in Live state\"\n        );\n\n        moveFunds(self, walletPubKeyHash);\n    }\n\n    /// @notice Handles a notification about a wallet redemption timeout.\n    ///         Triggers the wallet moving funds process only if the wallet is\n    ///         still in the Live state. That means multiple action timeouts can\n    ///         be reported for the same wallet but only the first report\n    ///         requests the wallet to move their funds.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @dev Requirements:\n    ///      - The wallet must be in the `Live` or `MovingFunds` state\n    function notifyWalletTimedOutRedemption(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash\n    ) internal {\n        WalletState walletState = self\n            .registeredWallets[walletPubKeyHash]\n            .state;\n\n        require(\n            walletState == WalletState.Live ||\n                walletState == WalletState.MovingFunds,\n            \"ECDSA wallet must be in Live or MovingFunds state\"\n        );\n\n        if (walletState == WalletState.Live) {\n            moveFunds(self, walletPubKeyHash);\n        }\n    }\n\n    /// @notice Notifies that the wallet is either old enough or has too few\n    ///         satoshis left and qualifies to be closed.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param walletMainUtxo Data of the wallet's main UTXO, as currently\n    ///        known on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - Wallet must not be set as the current active wallet\n    ///      - Wallet must exceed the wallet maximum age OR the wallet BTC\n    ///        balance must be lesser than the minimum threshold. If the latter\n    ///        case is true, the `walletMainUtxo` components must point to the\n    ///        recent main UTXO of the given wallet, as currently known on the\n    ///        Ethereum chain. If the wallet has no main UTXO, this parameter\n    ///        can be empty as it is ignored since the wallet balance is\n    ///        assumed to be zero.\n    ///      - Wallet must be in Live state\n    function notifyCloseableWallet(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata walletMainUtxo\n    ) external {\n        require(\n            self.activeWalletPubKeyHash != walletPubKeyHash,\n            \"Active wallet cannot be considered closeable\"\n        );\n\n        Wallet storage wallet = self.registeredWallets[walletPubKeyHash];\n        require(\n            wallet.state == WalletState.Live,\n            \"ECDSA wallet must be in Live state\"\n        );\n\n        /* solhint-disable-next-line not-rely-on-time */\n        bool walletOldEnough = block.timestamp >=\n            wallet.createdAt + self.walletMaxAge;\n\n        require(\n            walletOldEnough ||\n                getWalletBtcBalance(self, walletPubKeyHash, walletMainUtxo) <\n                self.walletClosureMinBtcBalance,\n            \"Wallet needs to be old enough or have too few satoshis\"\n        );\n\n        moveFunds(self, walletPubKeyHash);\n    }\n\n    /// @notice Requests a wallet to move their funds. If the wallet balance\n    ///         is zero, the wallet closing begins immediately. If the move\n    ///         funds request refers to the current active wallet, such a wallet\n    ///         is no longer considered active and the active wallet slot\n    ///         is unset allowing to trigger a new wallet creation immediately.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @dev Requirements:\n    ///      - The caller must make sure that the wallet is in the Live state\n    function moveFunds(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash\n    ) internal {\n        Wallet storage wallet = self.registeredWallets[walletPubKeyHash];\n\n        if (wallet.mainUtxoHash == bytes32(0)) {\n            // If the wallet has no main UTXO, that means its BTC balance\n            // is zero and the wallet closing should begin immediately.\n            beginWalletClosing(self, walletPubKeyHash);\n        } else {\n            // Otherwise, initialize the moving funds process.\n            wallet.state = WalletState.MovingFunds;\n            /* solhint-disable-next-line not-rely-on-time */\n            wallet.movingFundsRequestedAt = uint32(block.timestamp);\n\n            emit WalletMovingFunds(wallet.ecdsaWalletID, walletPubKeyHash);\n        }\n\n        if (self.activeWalletPubKeyHash == walletPubKeyHash) {\n            // If the move funds request refers to the current active wallet,\n            // unset the active wallet and make the wallet creation process\n            // possible in order to get a new healthy active wallet.\n            delete self.activeWalletPubKeyHash;\n        }\n\n        self.liveWalletsCount--;\n    }\n\n    /// @notice Begins the closing period of the given wallet.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @dev Requirements:\n    ///      - The caller must make sure that the wallet is in the\n    ///        MovingFunds state\n    function beginWalletClosing(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash\n    ) internal {\n        Wallet storage wallet = self.registeredWallets[walletPubKeyHash];\n        // Initialize the closing period.\n        wallet.state = WalletState.Closing;\n        /* solhint-disable-next-line not-rely-on-time */\n        wallet.closingStartedAt = uint32(block.timestamp);\n\n        emit WalletClosing(wallet.ecdsaWalletID, walletPubKeyHash);\n    }\n\n    /// @notice Notifies about the end of the closing period for the given wallet.\n    ///         Closes the wallet ultimately and notifies the ECDSA registry\n    ///         about this fact.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @dev Requirements:\n    ///      - The wallet must be in the Closing state\n    ///      - The wallet closing period must have elapsed\n    function notifyWalletClosingPeriodElapsed(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash\n    ) internal {\n        Wallet storage wallet = self.registeredWallets[walletPubKeyHash];\n\n        require(\n            wallet.state == WalletState.Closing,\n            \"ECDSA wallet must be in Closing state\"\n        );\n\n        require(\n            /* solhint-disable-next-line not-rely-on-time */\n            block.timestamp >\n                wallet.closingStartedAt + self.walletClosingPeriod,\n            \"Closing period has not elapsed yet\"\n        );\n\n        finalizeWalletClosing(self, walletPubKeyHash);\n    }\n\n    /// @notice Finalizes the closing period of the given wallet and notifies\n    ///         the ECDSA registry about this fact.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @dev Requirements:\n    ///      - The caller must make sure that the wallet is in the Closing state\n    function finalizeWalletClosing(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash\n    ) internal {\n        Wallet storage wallet = self.registeredWallets[walletPubKeyHash];\n\n        wallet.state = WalletState.Closed;\n\n        emit WalletClosed(wallet.ecdsaWalletID, walletPubKeyHash);\n\n        self.ecdsaWalletRegistry.closeWallet(wallet.ecdsaWalletID);\n    }\n\n    /// @notice Terminates the given wallet and notifies the ECDSA registry\n    ///         about this fact. If the wallet termination refers to the current\n    ///         active wallet, such a wallet is no longer considered active and\n    ///         the active wallet slot is unset allowing to trigger a new wallet\n    ///         creation immediately.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @dev Requirements:\n    ///      - The caller must make sure that the wallet is in the\n    ///        Live or MovingFunds or Closing state.\n    function terminateWallet(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash\n    ) internal {\n        Wallet storage wallet = self.registeredWallets[walletPubKeyHash];\n\n        if (wallet.state == WalletState.Live) {\n            self.liveWalletsCount--;\n        }\n\n        wallet.state = WalletState.Terminated;\n\n        emit WalletTerminated(wallet.ecdsaWalletID, walletPubKeyHash);\n\n        if (self.activeWalletPubKeyHash == walletPubKeyHash) {\n            // If termination refers to the current active wallet,\n            // unset the active wallet and make the wallet creation process\n            // possible in order to get a new healthy active wallet.\n            delete self.activeWalletPubKeyHash;\n        }\n\n        self.ecdsaWalletRegistry.closeWallet(wallet.ecdsaWalletID);\n    }\n\n    /// @notice Notifies that the wallet completed the moving funds process\n    ///         successfully. Checks if the funds were moved to the expected\n    ///         target wallets. Closes the source wallet if everything went\n    ///         good and reverts otherwise.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param targetWalletsHash 32-byte keccak256 hash over the list of\n    ///        20-byte public key hashes of the target wallets actually used\n    ///        within the moving funds transactions.\n    /// @dev Requirements:\n    ///      - The caller must make sure the moving funds transaction actually\n    ///        happened on Bitcoin chain and fits the protocol requirements.\n    ///      - The source wallet must be in the MovingFunds state\n    ///      - The target wallets commitment must be submitted by the source\n    ///        wallet.\n    ///      - The actual target wallets used in the moving funds transaction\n    ///        must be exactly the same as the target wallets commitment.\n    function notifyWalletFundsMoved(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        bytes32 targetWalletsHash\n    ) internal {\n        Wallet storage wallet = self.registeredWallets[walletPubKeyHash];\n        // Check that the wallet is in the MovingFunds state but don't check\n        // if the moving funds timeout is exceeded. That should give a\n        // possibility to move funds in case when timeout was hit but was\n        // not reported yet.\n        require(\n            wallet.state == WalletState.MovingFunds,\n            \"ECDSA wallet must be in MovingFunds state\"\n        );\n\n        bytes32 targetWalletsCommitmentHash = wallet\n            .movingFundsTargetWalletsCommitmentHash;\n\n        require(\n            targetWalletsCommitmentHash != bytes32(0),\n            \"Target wallets commitment not submitted yet\"\n        );\n\n        // Make sure that the target wallets where funds were moved to are\n        // exactly the same as the ones the source wallet committed to.\n        require(\n            targetWalletsCommitmentHash == targetWalletsHash,\n            \"Target wallets don't correspond to the commitment\"\n        );\n\n        // If funds were moved, the wallet has no longer a main UTXO.\n        delete wallet.mainUtxoHash;\n\n        beginWalletClosing(self, walletPubKeyHash);\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 {EcdsaDkg} from \"@keep-network/ecdsa/contracts/libraries/EcdsaDkg.sol\";\nimport {Math} from \"@openzeppelin/contracts/utils/math/Math.sol\";\n\nimport \"./BitcoinTx.sol\";\nimport \"./EcdsaLib.sol\";\nimport \"./BridgeState.sol\";\n\n/// @title Wallet library\n/// @notice Library responsible for handling integration between Bridge\n///         contract and ECDSA wallets.\nlibrary Wallets {\n    using BTCUtils for bytes;\n\n    /// @notice Represents wallet state:\n    enum WalletState {\n        /// @dev The wallet is unknown to the Bridge.\n        Unknown,\n        /// @dev The wallet can sweep deposits and accept redemption requests.\n        Live,\n        /// @dev The wallet was deemed unhealthy and is expected to move their\n        ///      outstanding funds to another wallet. The wallet can still\n        ///      fulfill their pending redemption requests although new\n        ///      redemption requests and new deposit reveals are not accepted.\n        MovingFunds,\n        /// @dev The wallet moved or redeemed all their funds and is in the\n        ///      closing period where they can be subject of fraud challenges\n        ///      and must defend against them. This state is needed to protect\n        ///      against deposit frauds on deposits revealed but not swept.\n        ///      The closing period must be greater that the deposit refund\n        ///      time plus some time margin.\n        Closing,\n        /// @dev The wallet finalized the closing period successfully and\n        ///      cannot perform any action in the Bridge.\n        Closed,\n        /// @dev The wallet committed a fraud that was reported. The wallet is\n        ///      blocked and can not perform any actions in the Bridge.\n        ///      Off-chain coordination with the wallet operators is needed to\n        ///      recover funds.\n        Terminated\n    }\n\n    /// @notice Holds information about a wallet.\n    struct Wallet {\n        // Identifier of a ECDSA Wallet registered in the ECDSA Wallet Registry.\n        bytes32 ecdsaWalletID;\n        // Latest wallet's main UTXO hash computed as\n        // keccak256(txHash | txOutputIndex | txOutputValue). The `tx` prefix\n        // refers to the transaction which created that main UTXO. The `txHash`\n        // is `bytes32` (ordered as in Bitcoin internally), `txOutputIndex`\n        // an `uint32`, and `txOutputValue` an `uint64` value.\n        bytes32 mainUtxoHash;\n        // The total redeemable value of pending redemption requests targeting\n        // that wallet.\n        uint64 pendingRedemptionsValue;\n        // UNIX timestamp the wallet was created at.\n        uint32 createdAt;\n        // UNIX timestamp indicating the moment the wallet was requested to\n        // move their funds.\n        uint32 movingFundsRequestedAt;\n        // UNIX timestamp indicating the moment the wallet's closing period\n        // started.\n        uint32 closingStartedAt;\n        // Total count of pending moved funds sweep requests targeting this wallet.\n        uint32 pendingMovedFundsSweepRequestsCount;\n        // Current state of the wallet.\n        WalletState state;\n        // Moving funds target wallet commitment submitted by the wallet. It\n        // is built by applying the keccak256 hash over the list of 20-byte\n        // public key hashes of the target wallets.\n        bytes32 movingFundsTargetWalletsCommitmentHash;\n    }\n\n    event NewWalletRequested();\n\n    event NewWalletRegistered(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletMovingFunds(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletClosing(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletClosed(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletTerminated(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    /// @notice Requests creation of a new wallet. This function just\n    ///         forms a request and the creation process is performed\n    ///         asynchronously. Outcome of that process should be delivered\n    ///         using `registerNewWallet` function.\n    /// @param activeWalletMainUtxo Data of the active wallet's main UTXO, as\n    ///        currently known on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - `activeWalletMainUtxo` components must point to the recent main\n    ///        UTXO of the given active wallet, as currently known on the\n    ///        Ethereum chain. If there is no active wallet at the moment, or\n    ///        the active wallet has no main UTXO, this parameter can be\n    ///        empty as it is ignored.\n    ///      - Wallet creation must not be in progress\n    ///      - If the active wallet is set, one of the following\n    ///        conditions must be true:\n    ///        - The active wallet BTC balance is above the minimum threshold\n    ///          and the active wallet is old enough, i.e. the creation period\n    ///           was elapsed since its creation time\n    ///        - The active wallet BTC balance is above the maximum threshold\n    function requestNewWallet(\n        BridgeState.Storage storage self,\n        BitcoinTx.UTXO calldata activeWalletMainUtxo\n    ) external {\n        require(\n            self.ecdsaWalletRegistry.getWalletCreationState() ==\n                EcdsaDkg.State.IDLE,\n            \"Wallet creation already in progress\"\n        );\n\n        bytes20 activeWalletPubKeyHash = self.activeWalletPubKeyHash;\n\n        // If the active wallet is set, fetch this wallet's details from\n        // storage to perform conditions check. The `registerNewWallet`\n        // function guarantees an active wallet is always one of the\n        // registered ones.\n        if (activeWalletPubKeyHash != bytes20(0)) {\n            uint64 activeWalletBtcBalance = getWalletBtcBalance(\n                self,\n                activeWalletPubKeyHash,\n                activeWalletMainUtxo\n            );\n            uint32 activeWalletCreatedAt = self\n                .registeredWallets[activeWalletPubKeyHash]\n                .createdAt;\n            /* solhint-disable-next-line not-rely-on-time */\n            bool activeWalletOldEnough = block.timestamp >=\n                activeWalletCreatedAt + self.walletCreationPeriod;\n\n            require(\n                (activeWalletOldEnough &&\n                    activeWalletBtcBalance >=\n                    self.walletCreationMinBtcBalance) ||\n                    activeWalletBtcBalance >= self.walletCreationMaxBtcBalance,\n                \"Wallet creation conditions are not met\"\n            );\n        }\n\n        emit NewWalletRequested();\n\n        self.ecdsaWalletRegistry.requestNewWallet();\n    }\n\n    /// @notice Gets BTC balance for given the wallet.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param walletMainUtxo Data of the wallet's main UTXO, as currently\n    ///        known on the Ethereum chain.\n    /// @return walletBtcBalance Current BTC balance for the given wallet.\n    /// @dev Requirements:\n    ///      - `walletMainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        If the wallet has no main UTXO, this parameter can be empty as it\n    ///        is ignored.\n    function getWalletBtcBalance(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata walletMainUtxo\n    ) internal view returns (uint64 walletBtcBalance) {\n        bytes32 walletMainUtxoHash = self\n            .registeredWallets[walletPubKeyHash]\n            .mainUtxoHash;\n\n        // If the wallet has a main UTXO hash set, cross-check it with the\n        // provided plain-text parameter and get the transaction output value\n        // as BTC balance. Otherwise, the BTC balance is just zero.\n        if (walletMainUtxoHash != bytes32(0)) {\n            require(\n                keccak256(\n                    abi.encodePacked(\n                        walletMainUtxo.txHash,\n                        walletMainUtxo.txOutputIndex,\n                        walletMainUtxo.txOutputValue\n                    )\n                ) == walletMainUtxoHash,\n                \"Invalid wallet main UTXO data\"\n            );\n\n            walletBtcBalance = walletMainUtxo.txOutputValue;\n        }\n\n        return walletBtcBalance;\n    }\n\n    /// @notice Registers a new wallet. This function should be called\n    ///         after the wallet creation process initiated using\n    ///         `requestNewWallet` completes and brings the outcomes.\n    /// @param ecdsaWalletID Wallet's unique identifier.\n    /// @param publicKeyX Wallet's public key's X coordinate.\n    /// @param publicKeyY Wallet's public key's Y coordinate.\n    /// @dev Requirements:\n    ///      - The only caller authorized to call this function is `registry`\n    ///      - Given wallet data must not belong to an already registered wallet\n    function registerNewWallet(\n        BridgeState.Storage storage self,\n        bytes32 ecdsaWalletID,\n        bytes32 publicKeyX,\n        bytes32 publicKeyY\n    ) external {\n        require(\n            msg.sender == address(self.ecdsaWalletRegistry),\n            \"Caller is not the ECDSA Wallet Registry\"\n        );\n\n        // Compress wallet's public key and calculate Bitcoin's hash160 of it.\n        bytes20 walletPubKeyHash = bytes20(\n            EcdsaLib.compressPublicKey(publicKeyX, publicKeyY).hash160View()\n        );\n\n        Wallet storage wallet = self.registeredWallets[walletPubKeyHash];\n        require(\n            wallet.state == WalletState.Unknown,\n            \"ECDSA wallet has been already registered\"\n        );\n        wallet.ecdsaWalletID = ecdsaWalletID;\n        wallet.state = WalletState.Live;\n        /* solhint-disable-next-line not-rely-on-time */\n        wallet.createdAt = uint32(block.timestamp);\n\n        // Set the freshly created wallet as the new active wallet.\n        self.activeWalletPubKeyHash = walletPubKeyHash;\n\n        self.liveWalletsCount++;\n\n        emit NewWalletRegistered(ecdsaWalletID, walletPubKeyHash);\n    }\n\n    /// @notice Handles a notification about a wallet heartbeat failure and\n    ///         triggers the wallet moving funds process.\n    /// @param publicKeyX Wallet's public key's X coordinate.\n    /// @param publicKeyY Wallet's public key's Y coordinate.\n    /// @dev Requirements:\n    ///      - The only caller authorized to call this function is `registry`\n    ///      - Wallet must be in Live state\n    function notifyWalletHeartbeatFailed(\n        BridgeState.Storage storage self,\n        bytes32 publicKeyX,\n        bytes32 publicKeyY\n    ) external {\n        require(\n            msg.sender == address(self.ecdsaWalletRegistry),\n            \"Caller is not the ECDSA Wallet Registry\"\n        );\n\n        // Compress wallet's public key and calculate Bitcoin's hash160 of it.\n        bytes20 walletPubKeyHash = bytes20(\n            EcdsaLib.compressPublicKey(publicKeyX, publicKeyY).hash160View()\n        );\n\n        require(\n            self.registeredWallets[walletPubKeyHash].state == WalletState.Live,\n            \"ECDSA wallet must be in Live state\"\n        );\n\n        moveFunds(self, walletPubKeyHash);\n    }\n\n    /// @notice Handles a notification about a wallet redemption timeout.\n    ///         Triggers the wallet moving funds process only if the wallet is\n    ///         still in the Live state. That means multiple action timeouts can\n    ///         be reported for the same wallet but only the first report\n    ///         requests the wallet to move their funds.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @dev Requirements:\n    ///      - The wallet must be in the `Live` or `MovingFunds` state\n    function notifyWalletTimedOutRedemption(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash\n    ) internal {\n        WalletState walletState = self\n            .registeredWallets[walletPubKeyHash]\n            .state;\n\n        require(\n            walletState == WalletState.Live ||\n                walletState == WalletState.MovingFunds,\n            \"ECDSA wallet must be in Live or MovingFunds state\"\n        );\n\n        if (walletState == WalletState.Live) {\n            moveFunds(self, walletPubKeyHash);\n        }\n    }\n\n    /// @notice Notifies that the wallet is either old enough or has too few\n    ///         satoshis left and qualifies to be closed.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param walletMainUtxo Data of the wallet's main UTXO, as currently\n    ///        known on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - Wallet must not be set as the current active wallet\n    ///      - Wallet must exceed the wallet maximum age OR the wallet BTC\n    ///        balance must be lesser than the minimum threshold. If the latter\n    ///        case is true, the `walletMainUtxo` components must point to the\n    ///        recent main UTXO of the given wallet, as currently known on the\n    ///        Ethereum chain. If the wallet has no main UTXO, this parameter\n    ///        can be empty as it is ignored since the wallet balance is\n    ///        assumed to be zero.\n    ///      - Wallet must be in Live state\n    function notifyCloseableWallet(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata walletMainUtxo\n    ) external {\n        require(\n            self.activeWalletPubKeyHash != walletPubKeyHash,\n            \"Active wallet cannot be considered closeable\"\n        );\n\n        Wallet storage wallet = self.registeredWallets[walletPubKeyHash];\n        require(\n            wallet.state == WalletState.Live,\n            \"ECDSA wallet must be in Live state\"\n        );\n\n        /* solhint-disable-next-line not-rely-on-time */\n        bool walletOldEnough = block.timestamp >=\n            wallet.createdAt + self.walletMaxAge;\n\n        require(\n            walletOldEnough ||\n                getWalletBtcBalance(self, walletPubKeyHash, walletMainUtxo) <\n                self.walletClosureMinBtcBalance,\n            \"Wallet needs to be old enough or have too few satoshis\"\n        );\n\n        moveFunds(self, walletPubKeyHash);\n    }\n\n    /// @notice Requests a wallet to move their funds. If the wallet balance\n    ///         is zero, the wallet closing begins immediately. If the move\n    ///         funds request refers to the current active wallet, such a wallet\n    ///         is no longer considered active and the active wallet slot\n    ///         is unset allowing to trigger a new wallet creation immediately.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @dev Requirements:\n    ///      - The caller must make sure that the wallet is in the Live state\n    function moveFunds(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash\n    ) internal {\n        Wallet storage wallet = self.registeredWallets[walletPubKeyHash];\n\n        if (wallet.mainUtxoHash == bytes32(0)) {\n            // If the wallet has no main UTXO, that means its BTC balance\n            // is zero and the wallet closing should begin immediately.\n            beginWalletClosing(self, walletPubKeyHash);\n        } else {\n            // Otherwise, initialize the moving funds process.\n            wallet.state = WalletState.MovingFunds;\n            /* solhint-disable-next-line not-rely-on-time */\n            wallet.movingFundsRequestedAt = uint32(block.timestamp);\n\n            emit WalletMovingFunds(wallet.ecdsaWalletID, walletPubKeyHash);\n        }\n\n        if (self.activeWalletPubKeyHash == walletPubKeyHash) {\n            // If the move funds request refers to the current active wallet,\n            // unset the active wallet and make the wallet creation process\n            // possible in order to get a new healthy active wallet.\n            delete self.activeWalletPubKeyHash;\n        }\n\n        self.liveWalletsCount--;\n    }\n\n    /// @notice Begins the closing period of the given wallet.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @dev Requirements:\n    ///      - The caller must make sure that the wallet is in the\n    ///        MovingFunds state\n    function beginWalletClosing(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash\n    ) internal {\n        Wallet storage wallet = self.registeredWallets[walletPubKeyHash];\n        // Initialize the closing period.\n        wallet.state = WalletState.Closing;\n        /* solhint-disable-next-line not-rely-on-time */\n        wallet.closingStartedAt = uint32(block.timestamp);\n\n        emit WalletClosing(wallet.ecdsaWalletID, walletPubKeyHash);\n    }\n\n    /// @notice Notifies about the end of the closing period for the given wallet.\n    ///         Closes the wallet ultimately and notifies the ECDSA registry\n    ///         about this fact.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @dev Requirements:\n    ///      - The wallet must be in the Closing state\n    ///      - The wallet closing period must have elapsed\n    function notifyWalletClosingPeriodElapsed(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash\n    ) internal {\n        Wallet storage wallet = self.registeredWallets[walletPubKeyHash];\n\n        require(\n            wallet.state == WalletState.Closing,\n            \"ECDSA wallet must be in Closing state\"\n        );\n\n        require(\n            /* solhint-disable-next-line not-rely-on-time */\n            block.timestamp >\n                wallet.closingStartedAt + self.walletClosingPeriod,\n            \"Closing period has not elapsed yet\"\n        );\n\n        finalizeWalletClosing(self, walletPubKeyHash);\n    }\n\n    /// @notice Finalizes the closing period of the given wallet and notifies\n    ///         the ECDSA registry about this fact.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @dev Requirements:\n    ///      - The caller must make sure that the wallet is in the Closing state\n    function finalizeWalletClosing(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash\n    ) internal {\n        Wallet storage wallet = self.registeredWallets[walletPubKeyHash];\n\n        wallet.state = WalletState.Closed;\n\n        emit WalletClosed(wallet.ecdsaWalletID, walletPubKeyHash);\n\n        self.ecdsaWalletRegistry.closeWallet(wallet.ecdsaWalletID);\n    }\n\n    /// @notice Terminates the given wallet and notifies the ECDSA registry\n    ///         about this fact. If the wallet termination refers to the current\n    ///         active wallet, such a wallet is no longer considered active and\n    ///         the active wallet slot is unset allowing to trigger a new wallet\n    ///         creation immediately.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @dev Requirements:\n    ///      - The caller must make sure that the wallet is in the\n    ///        Live or MovingFunds or Closing state.\n    function terminateWallet(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash\n    ) internal {\n        Wallet storage wallet = self.registeredWallets[walletPubKeyHash];\n\n        if (wallet.state == WalletState.Live) {\n            self.liveWalletsCount--;\n        }\n\n        wallet.state = WalletState.Terminated;\n\n        emit WalletTerminated(wallet.ecdsaWalletID, walletPubKeyHash);\n\n        if (self.activeWalletPubKeyHash == walletPubKeyHash) {\n            // If termination refers to the current active wallet,\n            // unset the active wallet and make the wallet creation process\n            // possible in order to get a new healthy active wallet.\n            delete self.activeWalletPubKeyHash;\n        }\n\n        self.ecdsaWalletRegistry.closeWallet(wallet.ecdsaWalletID);\n    }\n\n    /// @notice Notifies that the wallet completed the moving funds process\n    ///         successfully. Checks if the funds were moved to the expected\n    ///         target wallets. Closes the source wallet if everything went\n    ///         good and reverts otherwise.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param targetWalletsHash 32-byte keccak256 hash over the list of\n    ///        20-byte public key hashes of the target wallets actually used\n    ///        within the moving funds transactions.\n    /// @dev Requirements:\n    ///      - The caller must make sure the moving funds transaction actually\n    ///        happened on Bitcoin chain and fits the protocol requirements.\n    ///      - The source wallet must be in the MovingFunds state\n    ///      - The target wallets commitment must be submitted by the source\n    ///        wallet.\n    ///      - The actual target wallets used in the moving funds transaction\n    ///        must be exactly the same as the target wallets commitment.\n    function notifyWalletFundsMoved(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        bytes32 targetWalletsHash\n    ) internal {\n        Wallet storage wallet = self.registeredWallets[walletPubKeyHash];\n        // Check that the wallet is in the MovingFunds state but don't check\n        // if the moving funds timeout is exceeded. That should give a\n        // possibility to move funds in case when timeout was hit but was\n        // not reported yet.\n        require(\n            wallet.state == WalletState.MovingFunds,\n            \"ECDSA wallet must be in MovingFunds state\"\n        );\n\n        bytes32 targetWalletsCommitmentHash = wallet\n            .movingFundsTargetWalletsCommitmentHash;\n\n        require(\n            targetWalletsCommitmentHash != bytes32(0),\n            \"Target wallets commitment not submitted yet\"\n        );\n\n        // Make sure that the target wallets where funds were moved to are\n        // exactly the same as the ones the source wallet committed to.\n        require(\n            targetWalletsCommitmentHash == targetWalletsHash,\n            \"Target wallets don't correspond to the commitment\"\n        );\n\n        // If funds were moved, the wallet has no longer a main UTXO.\n        delete wallet.mainUtxoHash;\n\n        beginWalletClosing(self, walletPubKeyHash);\n    }\n}\n"
     },
     "@keep-network/bitcoin-spv-sol/contracts/BTCUtils.sol": {
       "content": "pragma solidity ^0.8.4;\n\n/** @title BitcoinSPV */\n/** @author Summa (https://summa.one) */\n\nimport {BytesLib} from \"./BytesLib.sol\";\nimport {SafeMath} from \"./SafeMath.sol\";\n\nlibrary BTCUtils {\n    using BytesLib for bytes;\n    using SafeMath for uint256;\n\n    // The target at minimum Difficulty. Also the target of the genesis block\n    uint256 public constant DIFF1_TARGET = 0xffff0000000000000000000000000000000000000000000000000000;\n\n    uint256 public constant RETARGET_PERIOD = 2 * 7 * 24 * 60 * 60;  // 2 weeks in seconds\n    uint256 public constant RETARGET_PERIOD_BLOCKS = 2016;  // 2 weeks in blocks\n\n    uint256 public constant ERR_BAD_ARG = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;\n\n    /* ***** */\n    /* UTILS */\n    /* ***** */\n\n    /// @notice         Determines the length of a VarInt in bytes\n    /// @dev            A VarInt of >1 byte is prefixed with a flag indicating its length\n    /// @param _flag    The first byte of a VarInt\n    /// @return         The number of non-flag bytes in the VarInt\n    function determineVarIntDataLength(bytes memory _flag) internal pure returns (uint8) {\n        return determineVarIntDataLengthAt(_flag, 0);\n    }\n\n    /// @notice         Determines the length of a VarInt in bytes\n    /// @dev            A VarInt of >1 byte is prefixed with a flag indicating its length\n    /// @param _b       The byte array containing a VarInt\n    /// @param _at      The position of the VarInt in the array\n    /// @return         The number of non-flag bytes in the VarInt\n    function determineVarIntDataLengthAt(bytes memory _b, uint256 _at) internal pure returns (uint8) {\n        if (uint8(_b[_at]) == 0xff) {\n            return 8;  // one-byte flag, 8 bytes data\n        }\n        if (uint8(_b[_at]) == 0xfe) {\n            return 4;  // one-byte flag, 4 bytes data\n        }\n        if (uint8(_b[_at]) == 0xfd) {\n            return 2;  // one-byte flag, 2 bytes data\n        }\n\n        return 0;  // flag is data\n    }\n\n    /// @notice     Parse a VarInt into its data length and the number it represents\n    /// @dev        Useful for Parsing Vins and Vouts. Returns ERR_BAD_ARG if insufficient bytes.\n    ///             Caller SHOULD explicitly handle this case (or bubble it up)\n    /// @param _b   A byte-string starting with a VarInt\n    /// @return     number of bytes in the encoding (not counting the tag), the encoded int\n    function parseVarInt(bytes memory _b) internal pure returns (uint256, uint256) {\n        return parseVarIntAt(_b, 0);\n    }\n\n    /// @notice     Parse a VarInt into its data length and the number it represents\n    /// @dev        Useful for Parsing Vins and Vouts. Returns ERR_BAD_ARG if insufficient bytes.\n    ///             Caller SHOULD explicitly handle this case (or bubble it up)\n    /// @param _b   A byte-string containing a VarInt\n    /// @param _at  The position of the VarInt\n    /// @return     number of bytes in the encoding (not counting the tag), the encoded int\n    function parseVarIntAt(bytes memory _b, uint256 _at) internal pure returns (uint256, uint256) {\n        uint8 _dataLen = determineVarIntDataLengthAt(_b, _at);\n\n        if (_dataLen == 0) {\n            return (0, uint8(_b[_at]));\n        }\n        if (_b.length < 1 + _dataLen + _at) {\n            return (ERR_BAD_ARG, 0);\n        }\n        uint256 _number;\n        if (_dataLen == 2) {\n            _number = reverseUint16(uint16(_b.slice2(1 + _at)));\n        } else if (_dataLen == 4) {\n            _number = reverseUint32(uint32(_b.slice4(1 + _at)));\n        } else if (_dataLen == 8) {\n            _number = reverseUint64(uint64(_b.slice8(1 + _at)));\n        }\n        return (_dataLen, _number);\n    }\n\n    /// @notice          Changes the endianness of a byte array\n    /// @dev             Returns a new, backwards, bytes\n    /// @param _b        The bytes to reverse\n    /// @return          The reversed bytes\n    function reverseEndianness(bytes memory _b) internal pure returns (bytes memory) {\n        bytes memory _newValue = new bytes(_b.length);\n\n        for (uint i = 0; i < _b.length; i++) {\n            _newValue[_b.length - i - 1] = _b[i];\n        }\n\n        return _newValue;\n    }\n\n    /// @notice          Changes the endianness of a uint256\n    /// @dev             https://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel\n    /// @param _b        The unsigned integer to reverse\n    /// @return v        The reversed value\n    function reverseUint256(uint256 _b) internal pure returns (uint256 v) {\n        v = _b;\n\n        // swap bytes\n        v = ((v >> 8) & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) |\n            ((v & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) << 8);\n        // swap 2-byte long pairs\n        v = ((v >> 16) & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) |\n            ((v & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) << 16);\n        // swap 4-byte long pairs\n        v = ((v >> 32) & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) |\n            ((v & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) << 32);\n        // swap 8-byte long pairs\n        v = ((v >> 64) & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) |\n            ((v & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) << 64);\n        // swap 16-byte long pairs\n        v = (v >> 128) | (v << 128);\n    }\n\n    /// @notice          Changes the endianness of a uint64\n    /// @param _b        The unsigned integer to reverse\n    /// @return v        The reversed value\n    function reverseUint64(uint64 _b) internal pure returns (uint64 v) {\n        v = _b;\n\n        // swap bytes\n        v = ((v >> 8) & 0x00FF00FF00FF00FF) |\n            ((v & 0x00FF00FF00FF00FF) << 8);\n        // swap 2-byte long pairs\n        v = ((v >> 16) & 0x0000FFFF0000FFFF) |\n            ((v & 0x0000FFFF0000FFFF) << 16);\n        // swap 4-byte long pairs\n        v = (v >> 32) | (v << 32);\n    }\n\n    /// @notice          Changes the endianness of a uint32\n    /// @param _b        The unsigned integer to reverse\n    /// @return v        The reversed value\n    function reverseUint32(uint32 _b) internal pure returns (uint32 v) {\n        v = _b;\n\n        // swap bytes\n        v = ((v >> 8) & 0x00FF00FF) |\n            ((v & 0x00FF00FF) << 8);\n        // swap 2-byte long pairs\n        v = (v >> 16) | (v << 16);\n    }\n\n    /// @notice          Changes the endianness of a uint24\n    /// @param _b        The unsigned integer to reverse\n    /// @return v        The reversed value\n    function reverseUint24(uint24 _b) internal pure returns (uint24 v) {\n        v =  (_b << 16) | (_b & 0x00FF00) | (_b >> 16);\n    }\n\n    /// @notice          Changes the endianness of a uint16\n    /// @param _b        The unsigned integer to reverse\n    /// @return v        The reversed value\n    function reverseUint16(uint16 _b) internal pure returns (uint16 v) {\n        v =  (_b << 8) | (_b >> 8);\n    }\n\n\n    /// @notice          Converts big-endian bytes to a uint\n    /// @dev             Traverses the byte array and sums the bytes\n    /// @param _b        The big-endian bytes-encoded integer\n    /// @return          The integer representation\n    function bytesToUint(bytes memory _b) internal pure returns (uint256) {\n        uint256 _number;\n\n        for (uint i = 0; i < _b.length; i++) {\n            _number = _number + uint8(_b[i]) * (2 ** (8 * (_b.length - (i + 1))));\n        }\n\n        return _number;\n    }\n\n    /// @notice          Get the last _num bytes from a byte array\n    /// @param _b        The byte array to slice\n    /// @param _num      The number of bytes to extract from the end\n    /// @return          The last _num bytes of _b\n    function lastBytes(bytes memory _b, uint256 _num) internal pure returns (bytes memory) {\n        uint256 _start = _b.length.sub(_num);\n\n        return _b.slice(_start, _num);\n    }\n\n    /// @notice          Implements bitcoin's hash160 (rmd160(sha2()))\n    /// @dev             abi.encodePacked changes the return to bytes instead of bytes32\n    /// @param _b        The pre-image\n    /// @return          The digest\n    function hash160(bytes memory _b) internal pure returns (bytes memory) {\n        return abi.encodePacked(ripemd160(abi.encodePacked(sha256(_b))));\n    }\n\n    /// @notice          Implements bitcoin's hash160 (sha2 + ripemd160)\n    /// @dev             sha2 precompile at address(2), ripemd160 at address(3)\n    /// @param _b        The pre-image\n    /// @return res      The digest\n    function hash160View(bytes memory _b) internal view returns (bytes20 res) {\n        // solium-disable-next-line security/no-inline-assembly\n        assembly {\n            pop(staticcall(gas(), 2, add(_b, 32), mload(_b), 0x00, 32))\n            pop(staticcall(gas(), 3, 0x00, 32, 0x00, 32))\n            // read from position 12 = 0c\n            res := mload(0x0c)\n        }\n    }\n\n    /// @notice          Implements bitcoin's hash256 (double sha2)\n    /// @dev             abi.encodePacked changes the return to bytes instead of bytes32\n    /// @param _b        The pre-image\n    /// @return          The digest\n    function hash256(bytes memory _b) internal pure returns (bytes32) {\n        return sha256(abi.encodePacked(sha256(_b)));\n    }\n\n    /// @notice          Implements bitcoin's hash256 (double sha2)\n    /// @dev             sha2 is precompiled smart contract located at address(2)\n    /// @param _b        The pre-image\n    /// @return res      The digest\n    function hash256View(bytes memory _b) internal view returns (bytes32 res) {\n        // solium-disable-next-line security/no-inline-assembly\n        assembly {\n            pop(staticcall(gas(), 2, add(_b, 32), mload(_b), 0x00, 32))\n            pop(staticcall(gas(), 2, 0x00, 32, 0x00, 32))\n            res := mload(0x00)\n        }\n    }\n\n    /// @notice          Implements bitcoin's hash256 on a pair of bytes32\n    /// @dev             sha2 is precompiled smart contract located at address(2)\n    /// @param _a        The first bytes32 of the pre-image\n    /// @param _b        The second bytes32 of the pre-image\n    /// @return res      The digest\n    function hash256Pair(bytes32 _a, bytes32 _b) internal view returns (bytes32 res) {\n        // solium-disable-next-line security/no-inline-assembly\n        assembly {\n            mstore(0x00, _a)\n            mstore(0x20, _b)\n            pop(staticcall(gas(), 2, 0x00, 64, 0x00, 32))\n            pop(staticcall(gas(), 2, 0x00, 32, 0x00, 32))\n            res := mload(0x00)\n        }\n    }\n\n    /* ************ */\n    /* Legacy Input */\n    /* ************ */\n\n    /// @notice          Extracts the nth input from the vin (0-indexed)\n    /// @dev             Iterates over the vin. If you need to extract several, write a custom function\n    /// @param _vin      The vin as a tightly-packed byte array\n    /// @param _index    The 0-indexed location of the input to extract\n    /// @return          The input as a byte array\n    function extractInputAtIndex(bytes memory _vin, uint256 _index) internal pure returns (bytes memory) {\n        uint256 _varIntDataLen;\n        uint256 _nIns;\n\n        (_varIntDataLen, _nIns) = parseVarInt(_vin);\n        require(_varIntDataLen != ERR_BAD_ARG, \"Read overrun during VarInt parsing\");\n        require(_index < _nIns, \"Vin read overrun\");\n\n        uint256 _len = 0;\n        uint256 _offset = 1 + _varIntDataLen;\n\n        for (uint256 _i = 0; _i < _index; _i ++) {\n            _len = determineInputLengthAt(_vin, _offset);\n            require(_len != ERR_BAD_ARG, \"Bad VarInt in scriptSig\");\n            _offset = _offset + _len;\n        }\n\n        _len = determineInputLengthAt(_vin, _offset);\n        require(_len != ERR_BAD_ARG, \"Bad VarInt in scriptSig\");\n        return _vin.slice(_offset, _len);\n    }\n\n    /// @notice          Determines whether an input is legacy\n    /// @dev             False if no scriptSig, otherwise True\n    /// @param _input    The input\n    /// @return          True for legacy, False for witness\n    function isLegacyInput(bytes memory _input) internal pure returns (bool) {\n        return _input[36] != hex\"00\";\n    }\n\n    /// @notice          Determines the length of a scriptSig in an input\n    /// @dev             Will return 0 if passed a witness input.\n    /// @param _input    The LEGACY input\n    /// @return          The length of the script sig\n    function extractScriptSigLen(bytes memory _input) internal pure returns (uint256, uint256) {\n        return extractScriptSigLenAt(_input, 0);\n    }\n\n    /// @notice          Determines the length of a scriptSig in an input\n    ///                  starting at the specified position\n    /// @dev             Will return 0 if passed a witness input.\n    /// @param _input    The byte array containing the LEGACY input\n    /// @param _at       The position of the input in the array\n    /// @return          The length of the script sig\n    function extractScriptSigLenAt(bytes memory _input, uint256 _at) internal pure returns (uint256, uint256) {\n        if (_input.length < 37 + _at) {\n            return (ERR_BAD_ARG, 0);\n        }\n\n        uint256 _varIntDataLen;\n        uint256 _scriptSigLen;\n        (_varIntDataLen, _scriptSigLen) = parseVarIntAt(_input, _at + 36);\n\n        return (_varIntDataLen, _scriptSigLen);\n    }\n\n    /// @notice          Determines the length of an input from its scriptSig\n    /// @dev             36 for outpoint, 1 for scriptSig length, 4 for sequence\n    /// @param _input    The input\n    /// @return          The length of the input in bytes\n    function determineInputLength(bytes memory _input) internal pure returns (uint256) {\n        return determineInputLengthAt(_input, 0);\n    }\n\n    /// @notice          Determines the length of an input from its scriptSig,\n    ///                  starting at the specified position\n    /// @dev             36 for outpoint, 1 for scriptSig length, 4 for sequence\n    /// @param _input    The byte array containing the input\n    /// @param _at       The position of the input in the array\n    /// @return          The length of the input in bytes\n    function determineInputLengthAt(bytes memory _input, uint256 _at) internal pure returns (uint256) {\n        uint256 _varIntDataLen;\n        uint256 _scriptSigLen;\n        (_varIntDataLen, _scriptSigLen) = extractScriptSigLenAt(_input, _at);\n        if (_varIntDataLen == ERR_BAD_ARG) {\n            return ERR_BAD_ARG;\n        }\n\n        return 36 + 1 + _varIntDataLen + _scriptSigLen + 4;\n    }\n\n    /// @notice          Extracts the LE sequence bytes from an input\n    /// @dev             Sequence is used for relative time locks\n    /// @param _input    The LEGACY input\n    /// @return          The sequence bytes (LE uint)\n    function extractSequenceLELegacy(bytes memory _input) internal pure returns (bytes4) {\n        uint256 _varIntDataLen;\n        uint256 _scriptSigLen;\n        (_varIntDataLen, _scriptSigLen) = extractScriptSigLen(_input);\n        require(_varIntDataLen != ERR_BAD_ARG, \"Bad VarInt in scriptSig\");\n        return _input.slice4(36 + 1 + _varIntDataLen + _scriptSigLen);\n    }\n\n    /// @notice          Extracts the sequence from the input\n    /// @dev             Sequence is a 4-byte little-endian number\n    /// @param _input    The LEGACY input\n    /// @return          The sequence number (big-endian uint)\n    function extractSequenceLegacy(bytes memory _input) internal pure returns (uint32) {\n        uint32 _leSeqence = uint32(extractSequenceLELegacy(_input));\n        uint32 _beSequence = reverseUint32(_leSeqence);\n        return _beSequence;\n    }\n    /// @notice          Extracts the VarInt-prepended scriptSig from the input in a tx\n    /// @dev             Will return hex\"00\" if passed a witness input\n    /// @param _input    The LEGACY input\n    /// @return          The length-prepended scriptSig\n    function extractScriptSig(bytes memory _input) internal pure returns (bytes memory) {\n        uint256 _varIntDataLen;\n        uint256 _scriptSigLen;\n        (_varIntDataLen, _scriptSigLen) = extractScriptSigLen(_input);\n        require(_varIntDataLen != ERR_BAD_ARG, \"Bad VarInt in scriptSig\");\n        return _input.slice(36, 1 + _varIntDataLen + _scriptSigLen);\n    }\n\n\n    /* ************* */\n    /* Witness Input */\n    /* ************* */\n\n    /// @notice          Extracts the LE sequence bytes from an input\n    /// @dev             Sequence is used for relative time locks\n    /// @param _input    The WITNESS input\n    /// @return          The sequence bytes (LE uint)\n    function extractSequenceLEWitness(bytes memory _input) internal pure returns (bytes4) {\n        return _input.slice4(37);\n    }\n\n    /// @notice          Extracts the sequence from the input in a tx\n    /// @dev             Sequence is a 4-byte little-endian number\n    /// @param _input    The WITNESS input\n    /// @return          The sequence number (big-endian uint)\n    function extractSequenceWitness(bytes memory _input) internal pure returns (uint32) {\n        uint32 _leSeqence = uint32(extractSequenceLEWitness(_input));\n        uint32 _inputeSequence = reverseUint32(_leSeqence);\n        return _inputeSequence;\n    }\n\n    /// @notice          Extracts the outpoint from the input in a tx\n    /// @dev             32-byte tx id with 4-byte index\n    /// @param _input    The input\n    /// @return          The outpoint (LE bytes of prev tx hash + LE bytes of prev tx index)\n    function extractOutpoint(bytes memory _input) internal pure returns (bytes memory) {\n        return _input.slice(0, 36);\n    }\n\n    /// @notice          Extracts the outpoint tx id from an input\n    /// @dev             32-byte tx id\n    /// @param _input    The input\n    /// @return          The tx id (little-endian bytes)\n    function extractInputTxIdLE(bytes memory _input) internal pure returns (bytes32) {\n        return _input.slice32(0);\n    }\n\n    /// @notice          Extracts the outpoint tx id from an input\n    ///                  starting at the specified position\n    /// @dev             32-byte tx id\n    /// @param _input    The byte array containing the input\n    /// @param _at       The position of the input\n    /// @return          The tx id (little-endian bytes)\n    function extractInputTxIdLeAt(bytes memory _input, uint256 _at) internal pure returns (bytes32) {\n        return _input.slice32(_at);\n    }\n\n    /// @notice          Extracts the LE tx input index from the input in a tx\n    /// @dev             4-byte tx index\n    /// @param _input    The input\n    /// @return          The tx index (little-endian bytes)\n    function extractTxIndexLE(bytes memory _input) internal pure returns (bytes4) {\n        return _input.slice4(32);\n    }\n\n    /// @notice          Extracts the LE tx input index from the input in a tx\n    ///                  starting at the specified position\n    /// @dev             4-byte tx index\n    /// @param _input    The byte array containing the input\n    /// @param _at       The position of the input\n    /// @return          The tx index (little-endian bytes)\n    function extractTxIndexLeAt(bytes memory _input, uint256 _at) internal pure returns (bytes4) {\n        return _input.slice4(32 + _at);\n    }\n\n    /* ****** */\n    /* Output */\n    /* ****** */\n\n    /// @notice          Determines the length of an output\n    /// @dev             Works with any properly formatted output\n    /// @param _output   The output\n    /// @return          The length indicated by the prefix, error if invalid length\n    function determineOutputLength(bytes memory _output) internal pure returns (uint256) {\n        return determineOutputLengthAt(_output, 0);\n    }\n\n    /// @notice          Determines the length of an output\n    ///                  starting at the specified position\n    /// @dev             Works with any properly formatted output\n    /// @param _output   The byte array containing the output\n    /// @param _at       The position of the output\n    /// @return          The length indicated by the prefix, error if invalid length\n    function determineOutputLengthAt(bytes memory _output, uint256 _at) internal pure returns (uint256) {\n        if (_output.length < 9 + _at) {\n            return ERR_BAD_ARG;\n        }\n        uint256 _varIntDataLen;\n        uint256 _scriptPubkeyLength;\n        (_varIntDataLen, _scriptPubkeyLength) = parseVarIntAt(_output, 8 + _at);\n\n        if (_varIntDataLen == ERR_BAD_ARG) {\n            return ERR_BAD_ARG;\n        }\n\n        // 8-byte value, 1-byte for tag itself\n        return 8 + 1 + _varIntDataLen + _scriptPubkeyLength;\n    }\n\n    /// @notice          Extracts the output at a given index in the TxOuts vector\n    /// @dev             Iterates over the vout. If you need to extract multiple, write a custom function\n    /// @param _vout     The _vout to extract from\n    /// @param _index    The 0-indexed location of the output to extract\n    /// @return          The specified output\n    function extractOutputAtIndex(bytes memory _vout, uint256 _index) internal pure returns (bytes memory) {\n        uint256 _varIntDataLen;\n        uint256 _nOuts;\n\n        (_varIntDataLen, _nOuts) = parseVarInt(_vout);\n        require(_varIntDataLen != ERR_BAD_ARG, \"Read overrun during VarInt parsing\");\n        require(_index < _nOuts, \"Vout read overrun\");\n\n        uint256 _len = 0;\n        uint256 _offset = 1 + _varIntDataLen;\n\n        for (uint256 _i = 0; _i < _index; _i ++) {\n            _len = determineOutputLengthAt(_vout, _offset);\n            require(_len != ERR_BAD_ARG, \"Bad VarInt in scriptPubkey\");\n            _offset += _len;\n        }\n\n        _len = determineOutputLengthAt(_vout, _offset);\n        require(_len != ERR_BAD_ARG, \"Bad VarInt in scriptPubkey\");\n        return _vout.slice(_offset, _len);\n    }\n\n    /// @notice          Extracts the value bytes from the output in a tx\n    /// @dev             Value is an 8-byte little-endian number\n    /// @param _output   The output\n    /// @return          The output value as LE bytes\n    function extractValueLE(bytes memory _output) internal pure returns (bytes8) {\n        return _output.slice8(0);\n    }\n\n    /// @notice          Extracts the value from the output in a tx\n    /// @dev             Value is an 8-byte little-endian number\n    /// @param _output   The output\n    /// @return          The output value\n    function extractValue(bytes memory _output) internal pure returns (uint64) {\n        uint64 _leValue = uint64(extractValueLE(_output));\n        uint64 _beValue = reverseUint64(_leValue);\n        return _beValue;\n    }\n\n    /// @notice          Extracts the data from an op return output\n    /// @dev             Returns hex\"\" if no data or not an op return\n    /// @param _output   The output\n    /// @return          Any data contained in the opreturn output, null if not an op return\n    function extractOpReturnData(bytes memory _output) internal pure returns (bytes memory) {\n        if (_output[9] != hex\"6a\") {\n            return hex\"\";\n        }\n        bytes1 _dataLen = _output[10];\n        return _output.slice(11, uint256(uint8(_dataLen)));\n    }\n\n    /// @notice          Extracts the hash from the output script\n    /// @dev             Determines type by the length prefix and validates format\n    /// @param _output   The output\n    /// @return          The hash committed to by the pk_script, or null for errors\n    function extractHash(bytes memory _output) internal pure returns (bytes memory) {\n        uint8 _scriptLen = uint8(_output[8]);\n\n        // don't have to worry about overflow here.\n        // if _scriptLen + 9 overflows, then output.length would have to be < 9\n        // for this check to pass. if it's < 9, then we errored when assigning\n        // _scriptLen\n        if (_scriptLen + 9 != _output.length) {\n            return hex\"\";\n        }\n\n        if (uint8(_output[9]) == 0) {\n            if (_scriptLen < 2) {\n                return hex\"\";\n            }\n            uint256 _payloadLen = uint8(_output[10]);\n            // Check for maliciously formatted witness outputs.\n            // No need to worry about underflow as long b/c of the `< 2` check\n            if (_payloadLen != _scriptLen - 2 || (_payloadLen != 0x20 && _payloadLen != 0x14)) {\n                return hex\"\";\n            }\n            return _output.slice(11, _payloadLen);\n        } else {\n            bytes3 _tag = _output.slice3(8);\n            // p2pkh\n            if (_tag == hex\"1976a9\") {\n                // Check for maliciously formatted p2pkh\n                // No need to worry about underflow, b/c of _scriptLen check\n                if (uint8(_output[11]) != 0x14 ||\n                    _output.slice2(_output.length - 2) != hex\"88ac\") {\n                    return hex\"\";\n                }\n                return _output.slice(12, 20);\n            //p2sh\n            } else if (_tag == hex\"17a914\") {\n                // Check for maliciously formatted p2sh\n                // No need to worry about underflow, b/c of _scriptLen check\n                if (uint8(_output[_output.length - 1]) != 0x87) {\n                    return hex\"\";\n                }\n                return _output.slice(11, 20);\n            }\n        }\n        return hex\"\";  /* NB: will trigger on OPRETURN and any non-standard that doesn't overrun */\n    }\n\n    /* ********** */\n    /* Witness TX */\n    /* ********** */\n\n\n    /// @notice      Checks that the vin passed up is properly formatted\n    /// @dev         Consider a vin with a valid vout in its scriptsig\n    /// @param _vin  Raw bytes length-prefixed input vector\n    /// @return      True if it represents a validly formatted vin\n    function validateVin(bytes memory _vin) internal pure returns (bool) {\n        uint256 _varIntDataLen;\n        uint256 _nIns;\n\n        (_varIntDataLen, _nIns) = parseVarInt(_vin);\n\n        // Not valid if it says there are too many or no inputs\n        if (_nIns == 0 || _varIntDataLen == ERR_BAD_ARG) {\n            return false;\n        }\n\n        uint256 _offset = 1 + _varIntDataLen;\n\n        for (uint256 i = 0; i < _nIns; i++) {\n            // If we're at the end, but still expect more\n            if (_offset >= _vin.length) {\n                return false;\n            }\n\n            // Grab the next input and determine its length.\n            uint256 _nextLen = determineInputLengthAt(_vin, _offset);\n            if (_nextLen == ERR_BAD_ARG) {\n                return false;\n            }\n\n            // Increase the offset by that much\n            _offset += _nextLen;\n        }\n\n        // Returns false if we're not exactly at the end\n        return _offset == _vin.length;\n    }\n\n    /// @notice      Checks that the vout passed up is properly formatted\n    /// @dev         Consider a vout with a valid scriptpubkey\n    /// @param _vout Raw bytes length-prefixed output vector\n    /// @return      True if it represents a validly formatted vout\n    function validateVout(bytes memory _vout) internal pure returns (bool) {\n        uint256 _varIntDataLen;\n        uint256 _nOuts;\n\n        (_varIntDataLen, _nOuts) = parseVarInt(_vout);\n\n        // Not valid if it says there are too many or no outputs\n        if (_nOuts == 0 || _varIntDataLen == ERR_BAD_ARG) {\n            return false;\n        }\n\n        uint256 _offset = 1 + _varIntDataLen;\n\n        for (uint256 i = 0; i < _nOuts; i++) {\n            // If we're at the end, but still expect more\n            if (_offset >= _vout.length) {\n                return false;\n            }\n\n            // Grab the next output and determine its length.\n            // Increase the offset by that much\n            uint256 _nextLen = determineOutputLengthAt(_vout, _offset);\n            if (_nextLen == ERR_BAD_ARG) {\n                return false;\n            }\n\n            _offset += _nextLen;\n        }\n\n        // Returns false if we're not exactly at the end\n        return _offset == _vout.length;\n    }\n\n\n\n    /* ************ */\n    /* Block Header */\n    /* ************ */\n\n    /// @notice          Extracts the transaction merkle root from a block header\n    /// @dev             Use verifyHash256Merkle to verify proofs with this root\n    /// @param _header   The header\n    /// @return          The merkle root (little-endian)\n    function extractMerkleRootLE(bytes memory _header) internal pure returns (bytes32) {\n        return _header.slice32(36);\n    }\n\n    /// @notice          Extracts the target from a block header\n    /// @dev             Target is a 256-bit number encoded as a 3-byte mantissa and 1-byte exponent\n    /// @param _header   The header\n    /// @return          The target threshold\n    function extractTarget(bytes memory _header) internal pure returns (uint256) {\n        uint24 _m = uint24(_header.slice3(72));\n        uint8 _e = uint8(_header[75]);\n        uint256 _mantissa = uint256(reverseUint24(_m));\n        uint _exponent = _e - 3;\n\n        return _mantissa * (256 ** _exponent);\n    }\n\n    /// @notice          Calculate difficulty from the difficulty 1 target and current target\n    /// @dev             Difficulty 1 is 0x1d00ffff on mainnet and testnet\n    /// @dev             Difficulty 1 is a 256-bit number encoded as a 3-byte mantissa and 1-byte exponent\n    /// @param _target   The current target\n    /// @return          The block difficulty (bdiff)\n    function calculateDifficulty(uint256 _target) internal pure returns (uint256) {\n        // Difficulty 1 calculated from 0x1d00ffff\n        return DIFF1_TARGET.div(_target);\n    }\n\n    /// @notice          Extracts the previous block's hash from a block header\n    /// @dev             Block headers do NOT include block number :(\n    /// @param _header   The header\n    /// @return          The previous block's hash (little-endian)\n    function extractPrevBlockLE(bytes memory _header) internal pure returns (bytes32) {\n        return _header.slice32(4);\n    }\n\n    /// @notice          Extracts the timestamp from a block header\n    /// @dev             Time is not 100% reliable\n    /// @param _header   The header\n    /// @return          The timestamp (little-endian bytes)\n    function extractTimestampLE(bytes memory _header) internal pure returns (bytes4) {\n        return _header.slice4(68);\n    }\n\n    /// @notice          Extracts the timestamp from a block header\n    /// @dev             Time is not 100% reliable\n    /// @param _header   The header\n    /// @return          The timestamp (uint)\n    function extractTimestamp(bytes memory _header) internal pure returns (uint32) {\n        return reverseUint32(uint32(extractTimestampLE(_header)));\n    }\n\n    /// @notice          Extracts the expected difficulty from a block header\n    /// @dev             Does NOT verify the work\n    /// @param _header   The header\n    /// @return          The difficulty as an integer\n    function extractDifficulty(bytes memory _header) internal pure returns (uint256) {\n        return calculateDifficulty(extractTarget(_header));\n    }\n\n    /// @notice          Concatenates and hashes two inputs for merkle proving\n    /// @param _a        The first hash\n    /// @param _b        The second hash\n    /// @return          The double-sha256 of the concatenated hashes\n    function _hash256MerkleStep(bytes memory _a, bytes memory _b) internal view returns (bytes32) {\n        return hash256View(abi.encodePacked(_a, _b));\n    }\n\n    /// @notice          Concatenates and hashes two inputs for merkle proving\n    /// @param _a        The first hash\n    /// @param _b        The second hash\n    /// @return          The double-sha256 of the concatenated hashes\n    function _hash256MerkleStep(bytes32 _a, bytes32 _b) internal view returns (bytes32) {\n        return hash256Pair(_a, _b);\n    }\n\n\n    /// @notice          Verifies a Bitcoin-style merkle tree\n    /// @dev             Leaves are 0-indexed. Inefficient version.\n    /// @param _proof    The proof. Tightly packed LE sha256 hashes. The last hash is the root\n    /// @param _index    The index of the leaf\n    /// @return          true if the proof is valid, else false\n    function verifyHash256Merkle(bytes memory _proof, uint _index) internal view returns (bool) {\n        // Not an even number of hashes\n        if (_proof.length % 32 != 0) {\n            return false;\n        }\n\n        // Special case for coinbase-only blocks\n        if (_proof.length == 32) {\n            return true;\n        }\n\n        // Should never occur\n        if (_proof.length == 64) {\n            return false;\n        }\n\n        bytes32 _root = _proof.slice32(_proof.length - 32);\n        bytes32 _current = _proof.slice32(0);\n        bytes memory _tree = _proof.slice(32, _proof.length - 64);\n\n        return verifyHash256Merkle(_current, _tree, _root, _index);\n    }\n\n    /// @notice          Verifies a Bitcoin-style merkle tree\n    /// @dev             Leaves are 0-indexed. Efficient version.\n    /// @param _leaf     The leaf of the proof. LE sha256 hash.\n    /// @param _tree     The intermediate nodes in the proof.\n    ///                  Tightly packed LE sha256 hashes.\n    /// @param _root     The root of the proof. LE sha256 hash.\n    /// @param _index    The index of the leaf\n    /// @return          true if the proof is valid, else false\n    function verifyHash256Merkle(\n        bytes32 _leaf,\n        bytes memory _tree,\n        bytes32 _root,\n        uint _index\n    ) internal view returns (bool) {\n        // Not an even number of hashes\n        if (_tree.length % 32 != 0) {\n            return false;\n        }\n\n        // Should never occur\n        if (_tree.length == 0) {\n            return false;\n        }\n\n        uint _idx = _index;\n        bytes32 _current = _leaf;\n\n        // i moves in increments of 32\n        for (uint i = 0; i < _tree.length; i += 32) {\n            if (_idx % 2 == 1) {\n                _current = _hash256MerkleStep(_tree.slice32(i), _current);\n            } else {\n                _current = _hash256MerkleStep(_current, _tree.slice32(i));\n            }\n            _idx = _idx >> 1;\n        }\n        return _current == _root;\n    }\n\n    /*\n    NB: https://github.com/bitcoin/bitcoin/blob/78dae8caccd82cfbfd76557f1fb7d7557c7b5edb/src/pow.cpp#L49-L72\n    NB: We get a full-bitlength target from this. For comparison with\n        header-encoded targets we need to mask it with the header target\n        e.g. (full & truncated) == truncated\n    */\n    /// @notice                 performs the bitcoin difficulty retarget\n    /// @dev                    implements the Bitcoin algorithm precisely\n    /// @param _previousTarget  the target of the previous period\n    /// @param _firstTimestamp  the timestamp of the first block in the difficulty period\n    /// @param _secondTimestamp the timestamp of the last block in the difficulty period\n    /// @return                 the new period's target threshold\n    function retargetAlgorithm(\n        uint256 _previousTarget,\n        uint256 _firstTimestamp,\n        uint256 _secondTimestamp\n    ) internal pure returns (uint256) {\n        uint256 _elapsedTime = _secondTimestamp.sub(_firstTimestamp);\n\n        // Normalize ratio to factor of 4 if very long or very short\n        if (_elapsedTime < RETARGET_PERIOD.div(4)) {\n            _elapsedTime = RETARGET_PERIOD.div(4);\n        }\n        if (_elapsedTime > RETARGET_PERIOD.mul(4)) {\n            _elapsedTime = RETARGET_PERIOD.mul(4);\n        }\n\n        /*\n          NB: high targets e.g. ffff0020 can cause overflows here\n              so we divide it by 256**2, then multiply by 256**2 later\n              we know the target is evenly divisible by 256**2, so this isn't an issue\n        */\n\n        uint256 _adjusted = _previousTarget.div(65536).mul(_elapsedTime);\n        return _adjusted.div(RETARGET_PERIOD).mul(65536);\n    }\n}\n"
@@ -122,13 +122,13 @@
       "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a >= b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow, so we distribute.\n        return (a / 2) + (b / 2) + (((a % 2) + (b % 2)) / 2);\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds up instead\n     * of rounding down.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b - 1) / b can overflow on addition, so we distribute.\n        return a / b + (a % b == 0 ? 0 : 1);\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 {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///\nlibrary BitcoinTx {\n    using BTCUtils for bytes;\n    using BTCUtils for uint256;\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    }\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    }\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    }\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    }\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"
+      "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///\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    }\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    }\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    }\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    }\n\n    /// @notice Validates the SPV proof of the Bitcoin transaction.\n    ///         Reverts in case the validation or proof verification fail.\n    /// @param txInfo Bitcoin transaction data\n    /// @param proof Bitcoin proof data\n    /// @return txHash Proven 32-byte transaction hash.\n    function validateProof(\n        BridgeState.Storage storage self,\n        Info calldata txInfo,\n        Proof calldata proof\n    ) internal view returns (bytes32 txHash) {\n        require(\n            txInfo.inputVector.validateVin(),\n            \"Invalid input vector provided\"\n        );\n        require(\n            txInfo.outputVector.validateVout(),\n            \"Invalid output vector provided\"\n        );\n\n        txHash = abi\n            .encodePacked(\n                txInfo.version,\n                txInfo.inputVector,\n                txInfo.outputVector,\n                txInfo.locktime\n            )\n            .hash256View();\n\n        require(\n            txHash.prove(\n                proof.bitcoinHeaders.extractMerkleRootLE(),\n                proof.merkleProof,\n                proof.txIndexInBlock\n            ),\n            \"Tx merkle proof is not valid for provided header and tx hash\"\n        );\n\n        evaluateProofDifficulty(self, proof.bitcoinHeaders);\n\n        return txHash;\n    }\n\n    /// @notice Evaluates the given Bitcoin proof difficulty against the actual\n    ///         Bitcoin chain difficulty provided by the relay oracle.\n    ///         Reverts in case the evaluation fails.\n    /// @param bitcoinHeaders Bitcoin headers chain being part of the SPV\n    ///        proof. Used to extract the observed proof difficulty\n    function evaluateProofDifficulty(\n        BridgeState.Storage storage self,\n        bytes memory bitcoinHeaders\n    ) internal view {\n        IRelay relay = self.relay;\n        uint256 currentEpochDifficulty = relay.getCurrentEpochDifficulty();\n        uint256 previousEpochDifficulty = relay.getPrevEpochDifficulty();\n\n        uint256 requestedDiff = 0;\n        uint256 firstHeaderDiff = bitcoinHeaders\n            .extractTarget()\n            .calculateDifficulty();\n\n        if (firstHeaderDiff == currentEpochDifficulty) {\n            requestedDiff = currentEpochDifficulty;\n        } else if (firstHeaderDiff == previousEpochDifficulty) {\n            requestedDiff = previousEpochDifficulty;\n        } else {\n            revert(\"Not at current or previous difficulty\");\n        }\n\n        uint256 observedDiff = bitcoinHeaders.validateHeaderChain();\n\n        require(\n            observedDiff != ValidateSPV.getErrBadLength(),\n            \"Invalid length of the headers chain\"\n        );\n        require(\n            observedDiff != ValidateSPV.getErrInvalidChain(),\n            \"Invalid headers chain\"\n        );\n        require(\n            observedDiff != ValidateSPV.getErrLowWork(),\n            \"Insufficient work in a header\"\n        );\n\n        require(\n            observedDiff >= requestedDiff * self.txProofDifficultyFactor,\n            \"Insufficient accumulated difficulty in header chain\"\n        );\n    }\n\n    /// @notice Extracts public key hash from the provided P2PKH or P2WPKH output.\n    ///         Reverts if the validation fails.\n    /// @param output The transaction output\n    /// @return pubKeyHash 20-byte public key hash the output locks funds on\n    /// @dev Requirements:\n    ///      - The output must be of P2PKH or P2WPKH type and lock the funds\n    ///        on a 20-byte public key hash\n    function extractPubKeyHash(BridgeState.Storage storage, bytes memory output)\n        internal\n        view\n        returns (bytes20 pubKeyHash)\n    {\n        bytes memory pubKeyHashBytes = output.extractHash();\n\n        require(\n            pubKeyHashBytes.length == 20,\n            \"Output's public key hash must have 20 bytes\"\n        );\n\n        pubKeyHash = pubKeyHashBytes.slice20(0);\n\n        // We need to make sure that the 20-byte public key hash\n        // is actually used in the right context of a P2PKH or P2WPKH\n        // output. To do so, we must extract the full script from the output\n        // and compare with the expected P2PKH and P2WPKH scripts\n        // referring to that 20-byte public key hash. The output consists\n        // of an 8-byte value and a variable length script. To extract the\n        // script we slice the output starting from 9th byte until the end.\n        bytes32 outputScriptKeccak = keccak256(\n            output.slice(8, output.length - 8)\n        );\n        // Build the expected P2PKH script which has the following byte\n        // format: <0x1976a914> <20-byte PKH> <0x88ac>. According to\n        // https://en.bitcoin.it/wiki/Script#Opcodes this translates to:\n        // - 0x19: Byte length of the entire script\n        // - 0x76: OP_DUP\n        // - 0xa9: OP_HASH160\n        // - 0x14: Byte length of the public key hash\n        // - 0x88: OP_EQUALVERIFY\n        // - 0xac: OP_CHECKSIG\n        // which matches the P2PKH structure as per:\n        // https://en.bitcoin.it/wiki/Transaction#Pay-to-PubkeyHash\n        bytes32 P2PKHScriptKeccak = keccak256(\n            abi.encodePacked(hex\"1976a914\", pubKeyHash, hex\"88ac\")\n        );\n        // Build the expected P2WPKH script which has the following format:\n        // <0x160014> <20-byte PKH>. According to\n        // https://en.bitcoin.it/wiki/Script#Opcodes this translates to:\n        // - 0x16: Byte length of the entire script\n        // - 0x00: OP_0\n        // - 0x14: Byte length of the public key hash\n        // which matches the P2WPKH structure as per:\n        // https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#P2WPKH\n        bytes32 P2WPKHScriptKeccak = keccak256(\n            abi.encodePacked(hex\"160014\", pubKeyHash)\n        );\n        // Make sure the actual output script matches either the P2PKH\n        // or P2WPKH format.\n        require(\n            outputScriptKeccak == P2PKHScriptKeccak ||\n                outputScriptKeccak == P2WPKHScriptKeccak,\n            \"Output must be P2PKH or P2WPKH\"\n        );\n\n        return pubKeyHash;\n    }\n}\n"
     },
     "contracts/bridge/EcdsaLib.sol": {
       "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\nimport \"@keep-network/bitcoin-spv-sol/contracts/BytesLib.sol\";\n\nlibrary EcdsaLib {\n    using BytesLib for bytes;\n\n    /// @notice Converts public key X and Y coordinates (32-byte each) to a\n    ///         compressed public key (33-byte). Compressed public key is X\n    ///         coordinate prefixed with `02` or `03` based on the Y coordinate parity.\n    ///         It is expected that the uncompressed public key is stripped\n    ///         (i.e. it is not prefixed with `04`).\n    /// @param x Wallet's public key's X coordinate.\n    /// @param y Wallet's public key's Y coordinate.\n    /// @return Compressed public key (33-byte), prefixed with `02` or `03`.\n    function compressPublicKey(bytes32 x, bytes32 y)\n        internal\n        pure\n        returns (bytes memory)\n    {\n        bytes1 prefix;\n        if (uint256(y) % 2 == 0) {\n            prefix = hex\"02\";\n        } else {\n            prefix = hex\"03\";\n        }\n\n        return bytes.concat(prefix, x);\n    }\n}\n"
     },
     "contracts/bridge/BridgeState.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 {IWalletRegistry as EcdsaWalletRegistry} from \"@keep-network/ecdsa/contracts/api/IWalletRegistry.sol\";\n\nimport \"./IRelay.sol\";\nimport \"./Deposit.sol\";\nimport \"./Redemption.sol\";\nimport \"./Fraud.sol\";\nimport \"./Wallets.sol\";\n\nimport \"../bank/Bank.sol\";\n\nlibrary BridgeState {\n    // TODO: Make parameters governable\n    struct Storage {\n        // Address of the Bank the Bridge belongs to.\n        Bank bank;\n        // Bitcoin relay providing the current Bitcoin network difficulty.\n        IRelay relay;\n        // ECDSA Wallet Registry contract handle.\n        EcdsaWalletRegistry ecdsaWalletRegistry;\n        // The number of confirmations on the Bitcoin chain required to\n        // successfully evaluate an SPV proof.\n        uint256 txProofDifficultyFactor;\n        // Address where the deposit and redemption treasury fees will be sent\n        // to. Treasury takes part in the operators rewarding process.\n        address treasury;\n        // The minimal amount that can be requested to deposit.\n        // Value of this parameter must take into account the value of\n        // `depositTreasuryFeeDivisor` and `depositTxMaxFee` parameters in order\n        // to make requests that can incur the treasury and transaction fee and\n        // still satisfy the depositor.\n        uint64 depositDustThreshold;\n        // Divisor used to compute the treasury fee taken from each deposit and\n        // transferred to the treasury upon sweep proof submission. That fee is\n        // computed as follows:\n        // `treasuryFee = depositedAmount / depositTreasuryFeeDivisor`\n        // For example, if the treasury fee needs to be 2% of each deposit,\n        // the `depositTreasuryFeeDivisor` should be set to `50` because\n        // `1/50 = 0.02 = 2%`.\n        uint64 depositTreasuryFeeDivisor;\n        // Maximum amount of BTC transaction fee that can be incurred by each\n        // swept deposit being part of the given sweep transaction. If the\n        // maximum BTC transaction fee is exceeded, such transaction is\n        // considered a fraud.\n        //\n        // This is a per-deposit input max fee for the sweep transaction.\n        uint64 depositTxMaxFee;\n        // Collection of all revealed deposits indexed by\n        // `keccak256(fundingTxHash | fundingOutputIndex)`.\n        // The `fundingTxHash` is `bytes32` (ordered as in Bitcoin internally)\n        // and `fundingOutputIndex` an `uint32`. This mapping may contain valid\n        // and invalid deposits and the wallet is responsible for validating\n        // them before attempting to execute a sweep.\n        mapping(uint256 => Deposit.DepositRequest) deposits;\n        // Indicates if the vault with the given address is trusted or not.\n        // Depositors can route their revealed deposits only to trusted vaults\n        // and have trusted vaults notified about new deposits as soon as these\n        // deposits get swept. Vaults not trusted by the Bridge can still be\n        // used by Bank balance owners on their own responsibility - anyone can\n        // approve their Bank balance to any address.\n        mapping(address => bool) isVaultTrusted;\n        // Maximum amount of the total BTC transaction fee that is acceptable in\n        // a single moving funds transaction.\n        //\n        // This is a TOTAL max fee for the moving funds transaction. Note\n        // that `depositTxMaxFee` is per single deposit and `redemptionTxMaxFee`\n        // if per single redemption. `movingFundsTxMaxTotalFee` is a total\n        // fee for the entire transaction.\n        uint64 movingFundsTxMaxTotalFee;\n        // The minimal satoshi amount that makes sense to be transferred during\n        // the moving funds process. Moving funds wallets having their BTC\n        // balance below that value can begin closing immediately as\n        // transferring such a low value may not be possible due to\n        // BTC network fees.\n        uint64 movingFundsDustThreshold;\n        // Time after which the moving funds process can be reported as\n        // timed out. It is counted from the moment when the wallet\n        // was requested to move their funds and switched to the MovingFunds\n        // state. Value in seconds.\n        uint32 movingFundsTimeout;\n        // The amount of stake slashed from each member of a wallet for a moving\n        // funds timeout.\n        uint96 movingFundsTimeoutSlashingAmount;\n        // The percentage of the notifier reward from the staking contract\n        // the notifier of a moving funds timeout receives. The value is in the\n        // range [0, 100].\n        uint256 movingFundsTimeoutNotifierRewardMultiplier;\n        // The minimal amount that can be requested for redemption.\n        // Value of this parameter must take into account the value of\n        // `redemptionTreasuryFeeDivisor` and `redemptionTxMaxFee`\n        // parameters in order to make requests that can incur the\n        // treasury and transaction fee and still satisfy the redeemer.\n        uint64 redemptionDustThreshold;\n        // Divisor used to compute the treasury fee taken from each\n        // redemption request and transferred to the treasury upon\n        // successful request finalization. That fee is computed as follows:\n        // `treasuryFee = requestedAmount / redemptionTreasuryFeeDivisor`\n        // For example, if the treasury fee needs to be 2% of each\n        // redemption request, the `redemptionTreasuryFeeDivisor` should\n        // be set to `50` because `1/50 = 0.02 = 2%`.\n        uint64 redemptionTreasuryFeeDivisor;\n        // Maximum amount of BTC transaction fee that can be incurred by\n        // each redemption request being part of the given redemption\n        // transaction. If the maximum BTC transaction fee is exceeded, such\n        // transaction is considered a fraud.\n        //\n        // This is a per-redemption output max fee for the redemption\n        // transaction.\n        uint64 redemptionTxMaxFee;\n        // Time after which the redemption request can be reported as\n        // timed out. It is counted from the moment when the redemption\n        // request was created via `requestRedemption` call. Reported\n        // timed out requests are cancelled and locked TBTC is returned\n        // to the redeemer in full amount.\n        uint256 redemptionTimeout;\n        // The amount of stake slashed from each member of a wallet for a\n        // redemption timeout.\n        uint96 redemptionTimeoutSlashingAmount;\n        // The percentage of the notifier reward from the staking contract\n        // the notifier of a redemption timeout receives. The value is in the\n        // range [0, 100].\n        uint256 redemptionTimeoutNotifierRewardMultiplier;\n        // Collection of all pending redemption requests indexed by\n        // redemption key built as\n        // `keccak256(walletPubKeyHash | redeemerOutputScript)`.\n        // The `walletPubKeyHash` is the 20-byte wallet's public key hash\n        // (computed using Bitcoin HASH160 over the compressed ECDSA\n        // public key) and `redeemerOutputScript` is a Bitcoin script\n        // (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock\n        // redeemed BTC as requested by the redeemer. Requests are added\n        // to this mapping by the `requestRedemption` method (duplicates\n        // not allowed) and are removed by one of the following methods:\n        // - `submitRedemptionProof` in case the request was handled\n        //    successfully\n        // - `notifyRedemptionTimeout` in case the request was reported\n        //    to be timed out\n        mapping(uint256 => Redemption.RedemptionRequest) pendingRedemptions;\n        // Collection of all timed out redemptions requests indexed by\n        // redemption key built as\n        // `keccak256(walletPubKeyHash | redeemerOutputScript)`. The\n        // `walletPubKeyHash` is the 20-byte wallet's public key hash\n        // (computed using Bitcoin HASH160 over the compressed ECDSA\n        // public key) and `redeemerOutputScript` is the Bitcoin script\n        // (P2PKH, P2WPKH, P2SH or P2WSH) that is involved in the timed\n        // out request. Timed out requests are stored in this mapping to\n        // avoid slashing the wallets multiple times for the same timeout.\n        // Only one method can add to this mapping:\n        // - `notifyRedemptionTimeout` which puts the redemption key to this\n        //    mapping basing on a timed out request stored previously in\n        //    `pendingRedemptions` mapping.\n        mapping(uint256 => Redemption.RedemptionRequest) timedOutRedemptions;\n        // The amount of ETH in wei the party challenging the wallet for fraud\n        // needs to deposit.\n        uint256 fraudChallengeDepositAmount;\n        // The amount of time the wallet has to defeat a fraud challenge.\n        uint256 fraudChallengeDefeatTimeout;\n        // The amount of stake slashed from each member of a wallet for a fraud.\n        uint96 fraudSlashingAmount;\n        // The percentage of the notifier reward from the staking contract\n        // the notifier of a fraud receives. The value is in the range [0, 100].\n        uint256 fraudNotifierRewardMultiplier;\n        // Collection of all submitted fraud challenges indexed by challenge\n        // key built as `keccak256(walletPublicKey|sighash)`.\n        mapping(uint256 => Fraud.FraudChallenge) fraudChallenges;\n        // Collection of main UTXOs that are honestly spent indexed by\n        // `keccak256(fundingTxHash | fundingOutputIndex)`. The `fundingTxHash`\n        // is `bytes32` (ordered as in Bitcoin internally) and\n        // `fundingOutputIndex` an `uint32`. A main UTXO is considered honestly\n        // spent if it was used as an input of a transaction that have been\n        // proven in the Bridge.\n        mapping(uint256 => bool) spentMainUTXOs;\n        // Determines how frequently a new wallet creation can be requested.\n        // Value in seconds.\n        uint32 walletCreationPeriod;\n        // The minimum BTC threshold in satoshi that is used to decide about\n        // wallet creation. Specifically, we allow for the creation of a new\n        // wallet if the active wallet is old enough and their amount of BTC\n        // is greater than or equal this threshold.\n        uint64 walletCreationMinBtcBalance;\n        // The maximum BTC threshold in satoshi that is used to decide about\n        // wallet creation. Specifically, we allow for the creation of a new\n        // wallet if the active wallet's amount of BTC is greater than or equal\n        // this threshold, regardless of the active wallet's age.\n        uint64 walletCreationMaxBtcBalance;\n        // The minimum BTC threshold in satoshi that is used to decide about\n        // wallet closing. Specifically, we allow for the closure of the given\n        // wallet if their amount of BTC is lesser than this threshold,\n        // regardless of the wallet's age.\n        uint64 walletClosureMinBtcBalance;\n        // The maximum age of a wallet in seconds, after which the wallet\n        // moving funds process can be requested.\n        uint32 walletMaxAge;\n        // 20-byte wallet public key hash being reference to the currently\n        // active wallet. Can be unset to the zero value under certain\n        // circumstances.\n        bytes20 activeWalletPubKeyHash;\n        // The current number of wallets in the Live state.\n        uint32 liveWalletsCount;\n        // The maximum BTC amount in satoshi than can be transferred to a single\n        // target wallet during the moving funds process.\n        uint64 walletMaxBtcTransfer;\n        // Determines the length of the wallet closing period, i.e. the period\n        // when the wallet remains in the Closing state and can be subject\n        // of deposit fraud challenges. This value is in seconds and should be\n        // greater than the deposit refund time plus some time margin.\n        uint32 walletClosingPeriod;\n        // Maps the 20-byte wallet public key hash (computed using Bitcoin\n        // HASH160 over the compressed ECDSA public key) to the basic wallet\n        // information like state and pending redemptions value.\n        mapping(bytes20 => Wallets.Wallet) registeredWallets;\n    }\n\n    event DepositParametersUpdated(\n        uint64 depositDustThreshold,\n        uint64 depositTreasuryFeeDivisor,\n        uint64 depositTxMaxFee\n    );\n\n    event RedemptionParametersUpdated(\n        uint64 redemptionDustThreshold,\n        uint64 redemptionTreasuryFeeDivisor,\n        uint64 redemptionTxMaxFee,\n        uint256 redemptionTimeout,\n        uint96 redemptionTimeoutSlashingAmount,\n        uint256 redemptionTimeoutNotifierRewardMultiplier\n    );\n\n    event MovingFundsParametersUpdated(\n        uint64 movingFundsTxMaxTotalFee,\n        uint64 movingFundsDustThreshold,\n        uint32 movingFundsTimeout,\n        uint96 movingFundsTimeoutSlashingAmount,\n        uint256 movingFundsTimeoutNotifierRewardMultiplier\n    );\n\n    event WalletParametersUpdated(\n        uint32 walletCreationPeriod,\n        uint64 walletCreationMinBtcBalance,\n        uint64 walletCreationMaxBtcBalance,\n        uint64 walletClosureMinBtcBalance,\n        uint32 walletMaxAge,\n        uint64 walletMaxBtcTransfer,\n        uint32 walletClosingPeriod\n    );\n\n    event FraudParametersUpdated(\n        uint256 fraudChallengeDepositAmount,\n        uint256 fraudChallengeDefeatTimeout,\n        uint96 fraudSlashingAmount,\n        uint256 fraudNotifierRewardMultiplier\n    );\n\n    /// @notice Updates parameters of deposits.\n    /// @param _depositDustThreshold New value of the deposit dust threshold in\n    ///        satoshis. It is the minimal amount that can be requested to\n    ////       deposit. Value of this parameter must take into account the value\n    ///        of `depositTreasuryFeeDivisor` and `depositTxMaxFee` parameters\n    ///        in order to make requests that can incur the treasury and\n    ///        transaction fee and still satisfy the depositor\n    /// @param _depositTreasuryFeeDivisor New value of the treasury fee divisor.\n    ///        It is the divisor used to compute the treasury fee taken from\n    ///        each deposit and transferred to the treasury upon sweep proof\n    ///        submission. That fee is computed as follows:\n    ///        `treasuryFee = depositedAmount / depositTreasuryFeeDivisor`\n    ///        For example, if the treasury fee needs to be 2% of each deposit,\n    ///        the `depositTreasuryFeeDivisor` should be set to `50`\n    ///        because `1/50 = 0.02 = 2%`\n    /// @param _depositTxMaxFee New value of the deposit tx max fee in satoshis.\n    ///        It is the maximum amount of BTC transaction fee that can\n    ///        be incurred by each swept deposit being part of the given sweep\n    ///        transaction. If the maximum BTC transaction fee is exceeded,\n    ///        such transaction is considered a fraud\n    /// @dev Requirements:\n    ///      - Deposit dust threshold must be greater than zero\n    ///      - Deposit treasury fee divisor must be greater than zero\n    ///      - Deposit transaction max fee must be greater than zero\n    function updateDepositParameters(\n        Storage storage self,\n        uint64 _depositDustThreshold,\n        uint64 _depositTreasuryFeeDivisor,\n        uint64 _depositTxMaxFee\n    ) internal {\n        require(\n            _depositDustThreshold > 0,\n            \"Deposit dust threshold must be greater than zero\"\n        );\n\n        require(\n            _depositTreasuryFeeDivisor > 0,\n            \"Deposit treasury fee divisor must be greater than zero\"\n        );\n\n        require(\n            _depositTxMaxFee > 0,\n            \"Deposit transaction max fee must be greater than zero\"\n        );\n\n        self.depositDustThreshold = _depositDustThreshold;\n        self.depositTreasuryFeeDivisor = _depositTreasuryFeeDivisor;\n        self.depositTxMaxFee = _depositTxMaxFee;\n\n        emit DepositParametersUpdated(\n            _depositDustThreshold,\n            _depositTreasuryFeeDivisor,\n            _depositTxMaxFee\n        );\n    }\n\n    /// @notice Updates parameters of redemptions.\n    /// @param _redemptionDustThreshold New value of the redemption dust\n    ///        threshold in satoshis. It is the minimal amount that can be\n    ///        requested for redemption. Value of this parameter must take into\n    ///        account the value of `redemptionTreasuryFeeDivisor` and\n    ///        `redemptionTxMaxFee` parameters in order to make requests that\n    ///        can incur the treasury and transaction fee and still satisfy the\n    ///        redeemer.\n    /// @param _redemptionTreasuryFeeDivisor New value of the redemption\n    ///        treasury fee divisor. It is the divisor used to compute the\n    ///        treasury fee taken from each redemption request and transferred\n    ///        to the treasury upon successful request finalization. That fee is\n    ///        computed as follows:\n    ///        `treasuryFee = requestedAmount / redemptionTreasuryFeeDivisor`\n    ///        For example, if the treasury fee needs to be 2% of each\n    ///        redemption request, the `redemptionTreasuryFeeDivisor` should\n    ///        be set to `50` because `1/50 = 0.02 = 2%`.\n    /// @param _redemptionTxMaxFee New value of the redemption transaction max\n    ///        fee in satoshis. It is the maximum amount of BTC transaction fee\n    ///        that can be incurred by each redemption request being part of the\n    ///        given redemption transaction. If the maximum BTC transaction fee\n    ///        is exceeded, such transaction is considered a fraud.\n    ///        This is a per-redemption output max fee for the redemption\n    ///        transaction.\n    /// @param _redemptionTimeout New value of the redemption timeout in seconds.\n    ///        It is the time after which the redemption request can be reported\n    ///        as timed out. It is counted from the moment when the redemption\n    ///        request was created via `requestRedemption` call. Reported  timed\n    ///        out requests are cancelled and locked TBTC is returned to the\n    ///        redeemer in full amount.\n    /// @param _redemptionTimeoutSlashingAmount New value of the redemption\n    ///        timeout slashing amount in T, it is the amount slashed from each\n    ///        wallet member for redemption timeout\n    /// @param _redemptionTimeoutNotifierRewardMultiplier New value of the\n    ///        redemption timeout notifier reward multiplier as percentage,\n    ///        it determines the percentage of the notifier reward from the\n    ///        staking contact the notifier of a redemption timeout receives.\n    ///        The value must be in the range [0, 100]\n    /// @dev Requirements:\n    ///      - Redemption dust threshold must be greater than zero\n    ///      - Redemption treasury fee divisor must be greater than zero\n    ///      - Redemption transaction max fee must be greater than zero\n    ///      - Redemption timeout must be greater than zero\n    ///      - Redemption timeout notifier reward multiplier must be in the\n    ///        range [0, 100]\n    function updateRedemptionParameters(\n        Storage storage self,\n        uint64 _redemptionDustThreshold,\n        uint64 _redemptionTreasuryFeeDivisor,\n        uint64 _redemptionTxMaxFee,\n        uint256 _redemptionTimeout,\n        uint96 _redemptionTimeoutSlashingAmount,\n        uint256 _redemptionTimeoutNotifierRewardMultiplier\n    ) internal {\n        require(\n            _redemptionDustThreshold > 0,\n            \"Redemption dust threshold must be greater than zero\"\n        );\n\n        require(\n            _redemptionTreasuryFeeDivisor > 0,\n            \"Redemption treasury fee divisor must be greater than zero\"\n        );\n\n        require(\n            _redemptionTxMaxFee > 0,\n            \"Redemption transaction max fee must be greater than zero\"\n        );\n\n        require(\n            _redemptionTimeout > 0,\n            \"Redemption timeout must be greater than zero\"\n        );\n\n        require(\n            _redemptionTimeoutNotifierRewardMultiplier <= 100,\n            \"Redemption timeout notifier reward multiplier must be in the range [0, 100]\"\n        );\n\n        self.redemptionDustThreshold = _redemptionDustThreshold;\n        self.redemptionTreasuryFeeDivisor = _redemptionTreasuryFeeDivisor;\n        self.redemptionTxMaxFee = _redemptionTxMaxFee;\n        self.redemptionTimeout = _redemptionTimeout;\n        self.redemptionTimeoutSlashingAmount = _redemptionTimeoutSlashingAmount;\n        self\n            .redemptionTimeoutNotifierRewardMultiplier = _redemptionTimeoutNotifierRewardMultiplier;\n\n        emit RedemptionParametersUpdated(\n            _redemptionDustThreshold,\n            _redemptionTreasuryFeeDivisor,\n            _redemptionTxMaxFee,\n            _redemptionTimeout,\n            _redemptionTimeoutSlashingAmount,\n            _redemptionTimeoutNotifierRewardMultiplier\n        );\n    }\n\n    /// @notice Updates parameters of moving funds.\n    /// @param _movingFundsTxMaxTotalFee New value of the moving funds transaction\n    ///        max total fee in satoshis. It is the maximum amount of the total\n    ///        BTC transaction fee that is acceptable in a single moving funds\n    ///        transaction. This is a _total_ max fee for the entire moving\n    ///        funds transaction.\n    /// @param _movingFundsDustThreshold New value of the moving funds dust\n    ///        threshold. It is the minimal satoshi amount that makes sense to\n    //         be transferred during the moving funds process. Moving funds\n    //         wallets having their BTC balance below that value can begin\n    //         closing immediately as transferring such a low value may not be\n    //         possible due to BTC network fees.\n    /// @param _movingFundsTimeout New value of the moving funds timeout in\n    ///        seconds. It is the time after which the moving funds process can\n    ///        be reported as timed out. It is counted from the moment when the\n    ///        wallet was requested to move their funds and switched to the\n    ///        MovingFunds state.\n    /// @param _movingFundsTimeoutSlashingAmount New value of the moving funds\n    ///        timeout slashing amount in T, it is the amount slashed from each\n    ///        wallet member for moving funds timeout\n    /// @param _movingFundsTimeoutNotifierRewardMultiplier New value of the\n    ///        moving funds timeout notifier reward multiplier as percentage,\n    ///        it determines the percentage of the notifier reward from the\n    ///        staking contact the notifier of a moving funds timeout receives.\n    ///        The value must be in the range [0, 100]\n    /// @dev Requirements:\n    ///      - Moving funds transaction max total fee must be greater than zero\n    ///      - Moving funds dust threshold must be greater than zero\n    ///      - Moving funds timeout must be greater than zero\n    ///      - Moving funds timeout notifier reward multiplier must be in the\n    ///        range [0, 100]\n    function updateMovingFundsParameters(\n        Storage storage self,\n        uint64 _movingFundsTxMaxTotalFee,\n        uint64 _movingFundsDustThreshold,\n        uint32 _movingFundsTimeout,\n        uint96 _movingFundsTimeoutSlashingAmount,\n        uint256 _movingFundsTimeoutNotifierRewardMultiplier\n    ) internal {\n        require(\n            _movingFundsTxMaxTotalFee > 0,\n            \"Moving funds transaction max total fee must be greater than zero\"\n        );\n\n        require(\n            _movingFundsDustThreshold > 0,\n            \"Moving funds dust threshold must be greater than zero\"\n        );\n\n        require(\n            _movingFundsTimeout > 0,\n            \"Moving funds timeout must be greater than zero\"\n        );\n\n        require(\n            _movingFundsTimeoutNotifierRewardMultiplier <= 100,\n            \"Moving funds timeout notifier reward multiplier must be in the range [0, 100]\"\n        );\n\n        self.movingFundsTxMaxTotalFee = _movingFundsTxMaxTotalFee;\n        self.movingFundsDustThreshold = _movingFundsDustThreshold;\n        self.movingFundsTimeout = _movingFundsTimeout;\n        self\n            .movingFundsTimeoutSlashingAmount = _movingFundsTimeoutSlashingAmount;\n        self\n            .movingFundsTimeoutNotifierRewardMultiplier = _movingFundsTimeoutNotifierRewardMultiplier;\n\n        emit MovingFundsParametersUpdated(\n            _movingFundsTxMaxTotalFee,\n            _movingFundsDustThreshold,\n            _movingFundsTimeout,\n            _movingFundsTimeoutSlashingAmount,\n            _movingFundsTimeoutNotifierRewardMultiplier\n        );\n    }\n\n    /// @notice Updates parameters of wallets.\n    /// @param _walletCreationPeriod New value of the wallet creation period in\n    ///        seconds, determines how frequently a new wallet creation can be\n    ///        requested\n    /// @param _walletCreationMinBtcBalance New value of the wallet minimum BTC\n    ///        balance in satoshi, used to decide about wallet creation\n    /// @param _walletCreationMaxBtcBalance New value of the wallet maximum BTC\n    ///        balance in satoshi, used to decide about wallet creation\n    /// @param _walletClosureMinBtcBalance New value of the wallet minimum BTC\n    ///        balance in satoshi, used to decide about wallet closure\n    /// @param _walletMaxAge New value of the wallet maximum age in seconds,\n    ///        indicates the maximum age of a wallet in seconds, after which\n    ///        the wallet moving funds process can be requested\n    /// @param _walletMaxBtcTransfer New value of the wallet maximum BTC transfer\n    ///        in satoshi, determines the maximum amount that can be transferred\n    ///        to a single target wallet during the moving funds process\n    /// @param _walletClosingPeriod New value of the wallet closing period in\n    ///        seconds, determines the length of the wallet closing period,\n    //         i.e. the period when the wallet remains in the Closing state\n    //         and can be subject of deposit fraud challenges\n    /// @dev Requirements:\n    ///      - Wallet minimum BTC balance must be greater than zero\n    ///      - Wallet maximum BTC balance must be greater than the wallet\n    ///        minimum BTC balance\n    ///      - Wallet maximum BTC transfer must be greater than zero\n    ///      - Wallet closing period must be greater than zero\n    function updateWalletParameters(\n        Storage storage self,\n        uint32 _walletCreationPeriod,\n        uint64 _walletCreationMinBtcBalance,\n        uint64 _walletCreationMaxBtcBalance,\n        uint64 _walletClosureMinBtcBalance,\n        uint32 _walletMaxAge,\n        uint64 _walletMaxBtcTransfer,\n        uint32 _walletClosingPeriod\n    ) internal {\n        require(\n            _walletCreationMaxBtcBalance > _walletCreationMinBtcBalance,\n            \"Wallet creation maximum BTC balance must be greater than the creation minimum BTC balance\"\n        );\n        require(\n            _walletClosureMinBtcBalance > 0,\n            \"Wallet closure minimum BTC balance must be greater than zero\"\n        );\n        require(\n            _walletMaxBtcTransfer > 0,\n            \"Wallet maximum BTC transfer must be greater than zero\"\n        );\n        require(\n            _walletClosingPeriod > 0,\n            \"Wallet closing period must be greater than zero\"\n        );\n\n        self.walletCreationPeriod = _walletCreationPeriod;\n        self.walletCreationMinBtcBalance = _walletCreationMinBtcBalance;\n        self.walletCreationMaxBtcBalance = _walletCreationMaxBtcBalance;\n        self.walletClosureMinBtcBalance = _walletClosureMinBtcBalance;\n        self.walletMaxAge = _walletMaxAge;\n        self.walletMaxBtcTransfer = _walletMaxBtcTransfer;\n        self.walletClosingPeriod = _walletClosingPeriod;\n\n        emit WalletParametersUpdated(\n            _walletCreationPeriod,\n            _walletCreationMinBtcBalance,\n            _walletCreationMaxBtcBalance,\n            _walletClosureMinBtcBalance,\n            _walletMaxAge,\n            _walletMaxBtcTransfer,\n            _walletClosingPeriod\n        );\n    }\n\n    /// @notice Updates parameters related to frauds.\n    /// @param _fraudChallengeDepositAmount New value of the fraud challenge\n    ///        deposit amount in wei, it is the amount of ETH the party\n    ///        challenging the wallet for fraud needs to deposit\n    /// @param _fraudChallengeDefeatTimeout New value of the challenge defeat\n    ///        timeout in seconds, it is the amount of time the wallet has to\n    ///        defeat a fraud challenge. The value must be greater than zero\n    /// @param _fraudSlashingAmount New value of the fraud slashing amount in T,\n    ///        it is the amount slashed from each wallet member for committing\n    ///        a fraud\n    /// @param _fraudNotifierRewardMultiplier New value of the fraud notifier\n    ///        reward multiplier as percentage, it determines the percentage of\n    ///        the notifier reward from the staking contact the notifier of\n    ///        a fraud receives. The value must be in the range [0, 100]\n    /// @dev Requirements:\n    ///      - Fraud challenge defeat timeout must be greater than 0\n    ///      - Fraud notifier reward multiplier must be in the range [0, 100]\n    function updateFraudParameters(\n        Storage storage self,\n        uint256 _fraudChallengeDepositAmount,\n        uint256 _fraudChallengeDefeatTimeout,\n        uint96 _fraudSlashingAmount,\n        uint256 _fraudNotifierRewardMultiplier\n    ) internal {\n        require(\n            _fraudChallengeDefeatTimeout > 0,\n            \"Fraud challenge defeat timeout must be greater than zero\"\n        );\n\n        require(\n            _fraudNotifierRewardMultiplier <= 100,\n            \"Fraud notifier reward multiplier must be in the range [0, 100]\"\n        );\n\n        self.fraudChallengeDepositAmount = _fraudChallengeDepositAmount;\n        self.fraudChallengeDefeatTimeout = _fraudChallengeDefeatTimeout;\n        self.fraudSlashingAmount = _fraudSlashingAmount;\n        self.fraudNotifierRewardMultiplier = _fraudNotifierRewardMultiplier;\n\n        emit FraudParametersUpdated(\n            _fraudChallengeDepositAmount,\n            _fraudChallengeDefeatTimeout,\n            _fraudSlashingAmount,\n            _fraudNotifierRewardMultiplier\n        );\n    }\n}\n"
+      "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\nimport {IWalletRegistry as EcdsaWalletRegistry} from \"@keep-network/ecdsa/contracts/api/IWalletRegistry.sol\";\n\nimport \"./IRelay.sol\";\nimport \"./Deposit.sol\";\nimport \"./Redemption.sol\";\nimport \"./Fraud.sol\";\nimport \"./Wallets.sol\";\nimport \"./MovingFunds.sol\";\n\nimport \"../bank/Bank.sol\";\n\nlibrary BridgeState {\n    // TODO: Make parameters governable\n    struct Storage {\n        // Address of the Bank the Bridge belongs to.\n        Bank bank;\n        // Bitcoin relay providing the current Bitcoin network difficulty.\n        IRelay relay;\n        // ECDSA Wallet Registry contract handle.\n        EcdsaWalletRegistry ecdsaWalletRegistry;\n        // The number of confirmations on the Bitcoin chain required to\n        // successfully evaluate an SPV proof.\n        uint256 txProofDifficultyFactor;\n        // Address where the deposit and redemption treasury fees will be sent\n        // to. Treasury takes part in the operators rewarding process.\n        address treasury;\n        // The minimal amount that can be requested to deposit.\n        // Value of this parameter must take into account the value of\n        // `depositTreasuryFeeDivisor` and `depositTxMaxFee` parameters in order\n        // to make requests that can incur the treasury and transaction fee and\n        // still satisfy the depositor.\n        uint64 depositDustThreshold;\n        // Divisor used to compute the treasury fee taken from each deposit and\n        // transferred to the treasury upon sweep proof submission. That fee is\n        // computed as follows:\n        // `treasuryFee = depositedAmount / depositTreasuryFeeDivisor`\n        // For example, if the treasury fee needs to be 2% of each deposit,\n        // the `depositTreasuryFeeDivisor` should be set to `50` because\n        // `1/50 = 0.02 = 2%`.\n        uint64 depositTreasuryFeeDivisor;\n        // Maximum amount of BTC transaction fee that can be incurred by each\n        // swept deposit being part of the given sweep transaction. If the\n        // maximum BTC transaction fee is exceeded, such transaction is\n        // considered a fraud.\n        //\n        // This is a per-deposit input max fee for the sweep transaction.\n        uint64 depositTxMaxFee;\n        // Collection of all revealed deposits indexed by\n        // `keccak256(fundingTxHash | fundingOutputIndex)`.\n        // The `fundingTxHash` is `bytes32` (ordered as in Bitcoin internally)\n        // and `fundingOutputIndex` an `uint32`. This mapping may contain valid\n        // and invalid deposits and the wallet is responsible for validating\n        // them before attempting to execute a sweep.\n        mapping(uint256 => Deposit.DepositRequest) deposits;\n        // Indicates if the vault with the given address is trusted or not.\n        // Depositors can route their revealed deposits only to trusted vaults\n        // and have trusted vaults notified about new deposits as soon as these\n        // deposits get swept. Vaults not trusted by the Bridge can still be\n        // used by Bank balance owners on their own responsibility - anyone can\n        // approve their Bank balance to any address.\n        mapping(address => bool) isVaultTrusted;\n        // Maximum amount of the total BTC transaction fee that is acceptable in\n        // a single moving funds transaction.\n        //\n        // This is a TOTAL max fee for the moving funds transaction. Note\n        // that `depositTxMaxFee` is per single deposit and `redemptionTxMaxFee`\n        // if per single redemption. `movingFundsTxMaxTotalFee` is a total\n        // fee for the entire transaction.\n        uint64 movingFundsTxMaxTotalFee;\n        // The minimal satoshi amount that makes sense to be transferred during\n        // the moving funds process. Moving funds wallets having their BTC\n        // balance below that value can begin closing immediately as\n        // transferring such a low value may not be possible due to\n        // BTC network fees.\n        uint64 movingFundsDustThreshold;\n        // Time after which the moving funds process can be reported as\n        // timed out. It is counted from the moment when the wallet\n        // was requested to move their funds and switched to the MovingFunds\n        // state. Value in seconds.\n        uint32 movingFundsTimeout;\n        // The amount of stake slashed from each member of a wallet for a moving\n        // funds timeout.\n        uint96 movingFundsTimeoutSlashingAmount;\n        // The percentage of the notifier reward from the staking contract\n        // the notifier of a moving funds timeout receives. The value is in the\n        // range [0, 100].\n        uint256 movingFundsTimeoutNotifierRewardMultiplier;\n        // Maximum amount of the total BTC transaction fee that is acceptable in\n        // a single moved funds sweep transaction.\n        //\n        // This is a TOTAL max fee for the moved funds sweep transaction. Note\n        // that `depositTxMaxFee` is per single deposit and `redemptionTxMaxFee`\n        // if per single redemption. `movedFundsSweepTxMaxTotalFee` is a total\n        // fee for the entire transaction.\n        uint64 movedFundsSweepTxMaxTotalFee;\n        // Time after which the moved funds sweep process can be reported as\n        // timed out. It is counted from the moment when the recipient wallet\n        // was requested to sweep the received funds. Value in seconds.\n        uint32 movedFundsSweepTimeout;\n        // The amount of stake slashed from each member of a wallet for a moved\n        // funds sweep timeout.\n        uint96 movedFundsSweepTimeoutSlashingAmount;\n        // The percentage of the notifier reward from the staking contract\n        // the notifier of a moved funds sweep timeout receives. The value is\n        // in the range [0, 100].\n        uint256 movedFundsSweepTimeoutNotifierRewardMultiplier;\n        // Collection of all moved funds sweep requests indexed by\n        // `keccak256(movingFundsTxHash | movingFundsOutputIndex)`.\n        // The `movingFundsTxHash` is `bytes32` (ordered as in Bitcoin\n        // internally) and `movingFundsOutputIndex` an `uint32`. Each entry\n        // is actually an UTXO representing the moved funds and is supposed\n        // to be swept with the current main UTXO of the recipient wallet.\n        mapping(uint256 => MovingFunds.MovedFundsSweepRequest) movedFundsSweepRequests;\n        // The minimal amount that can be requested for redemption.\n        // Value of this parameter must take into account the value of\n        // `redemptionTreasuryFeeDivisor` and `redemptionTxMaxFee`\n        // parameters in order to make requests that can incur the\n        // treasury and transaction fee and still satisfy the redeemer.\n        uint64 redemptionDustThreshold;\n        // Divisor used to compute the treasury fee taken from each\n        // redemption request and transferred to the treasury upon\n        // successful request finalization. That fee is computed as follows:\n        // `treasuryFee = requestedAmount / redemptionTreasuryFeeDivisor`\n        // For example, if the treasury fee needs to be 2% of each\n        // redemption request, the `redemptionTreasuryFeeDivisor` should\n        // be set to `50` because `1/50 = 0.02 = 2%`.\n        uint64 redemptionTreasuryFeeDivisor;\n        // Maximum amount of BTC transaction fee that can be incurred by\n        // each redemption request being part of the given redemption\n        // transaction. If the maximum BTC transaction fee is exceeded, such\n        // transaction is considered a fraud.\n        //\n        // This is a per-redemption output max fee for the redemption\n        // transaction.\n        uint64 redemptionTxMaxFee;\n        // Time after which the redemption request can be reported as\n        // timed out. It is counted from the moment when the redemption\n        // request was created via `requestRedemption` call. Reported\n        // timed out requests are cancelled and locked TBTC is returned\n        // to the redeemer in full amount.\n        uint256 redemptionTimeout;\n        // The amount of stake slashed from each member of a wallet for a\n        // redemption timeout.\n        uint96 redemptionTimeoutSlashingAmount;\n        // The percentage of the notifier reward from the staking contract\n        // the notifier of a redemption timeout receives. The value is in the\n        // range [0, 100].\n        uint256 redemptionTimeoutNotifierRewardMultiplier;\n        // Collection of all pending redemption requests indexed by\n        // redemption key built as\n        // `keccak256(walletPubKeyHash | redeemerOutputScript)`.\n        // The `walletPubKeyHash` is the 20-byte wallet's public key hash\n        // (computed using Bitcoin HASH160 over the compressed ECDSA\n        // public key) and `redeemerOutputScript` is a Bitcoin script\n        // (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock\n        // redeemed BTC as requested by the redeemer. Requests are added\n        // to this mapping by the `requestRedemption` method (duplicates\n        // not allowed) and are removed by one of the following methods:\n        // - `submitRedemptionProof` in case the request was handled\n        //    successfully\n        // - `notifyRedemptionTimeout` in case the request was reported\n        //    to be timed out\n        mapping(uint256 => Redemption.RedemptionRequest) pendingRedemptions;\n        // Collection of all timed out redemptions requests indexed by\n        // redemption key built as\n        // `keccak256(walletPubKeyHash | redeemerOutputScript)`. The\n        // `walletPubKeyHash` is the 20-byte wallet's public key hash\n        // (computed using Bitcoin HASH160 over the compressed ECDSA\n        // public key) and `redeemerOutputScript` is the Bitcoin script\n        // (P2PKH, P2WPKH, P2SH or P2WSH) that is involved in the timed\n        // out request. Timed out requests are stored in this mapping to\n        // avoid slashing the wallets multiple times for the same timeout.\n        // Only one method can add to this mapping:\n        // - `notifyRedemptionTimeout` which puts the redemption key to this\n        //    mapping basing on a timed out request stored previously in\n        //    `pendingRedemptions` mapping.\n        mapping(uint256 => Redemption.RedemptionRequest) timedOutRedemptions;\n        // The amount of ETH in wei the party challenging the wallet for fraud\n        // needs to deposit.\n        uint256 fraudChallengeDepositAmount;\n        // The amount of time the wallet has to defeat a fraud challenge.\n        uint256 fraudChallengeDefeatTimeout;\n        // The amount of stake slashed from each member of a wallet for a fraud.\n        uint96 fraudSlashingAmount;\n        // The percentage of the notifier reward from the staking contract\n        // the notifier of a fraud receives. The value is in the range [0, 100].\n        uint256 fraudNotifierRewardMultiplier;\n        // Collection of all submitted fraud challenges indexed by challenge\n        // key built as `keccak256(walletPublicKey|sighash)`.\n        mapping(uint256 => Fraud.FraudChallenge) fraudChallenges;\n        // Collection of main UTXOs that are honestly spent indexed by\n        // `keccak256(fundingTxHash | fundingOutputIndex)`. The `fundingTxHash`\n        // is `bytes32` (ordered as in Bitcoin internally) and\n        // `fundingOutputIndex` an `uint32`. A main UTXO is considered honestly\n        // spent if it was used as an input of a transaction that have been\n        // proven in the Bridge.\n        mapping(uint256 => bool) spentMainUTXOs;\n        // Determines how frequently a new wallet creation can be requested.\n        // Value in seconds.\n        uint32 walletCreationPeriod;\n        // The minimum BTC threshold in satoshi that is used to decide about\n        // wallet creation. Specifically, we allow for the creation of a new\n        // wallet if the active wallet is old enough and their amount of BTC\n        // is greater than or equal this threshold.\n        uint64 walletCreationMinBtcBalance;\n        // The maximum BTC threshold in satoshi that is used to decide about\n        // wallet creation. Specifically, we allow for the creation of a new\n        // wallet if the active wallet's amount of BTC is greater than or equal\n        // this threshold, regardless of the active wallet's age.\n        uint64 walletCreationMaxBtcBalance;\n        // The minimum BTC threshold in satoshi that is used to decide about\n        // wallet closing. Specifically, we allow for the closure of the given\n        // wallet if their amount of BTC is lesser than this threshold,\n        // regardless of the wallet's age.\n        uint64 walletClosureMinBtcBalance;\n        // The maximum age of a wallet in seconds, after which the wallet\n        // moving funds process can be requested.\n        uint32 walletMaxAge;\n        // 20-byte wallet public key hash being reference to the currently\n        // active wallet. Can be unset to the zero value under certain\n        // circumstances.\n        bytes20 activeWalletPubKeyHash;\n        // The current number of wallets in the Live state.\n        uint32 liveWalletsCount;\n        // The maximum BTC amount in satoshi than can be transferred to a single\n        // target wallet during the moving funds process.\n        uint64 walletMaxBtcTransfer;\n        // Determines the length of the wallet closing period, i.e. the period\n        // when the wallet remains in the Closing state and can be subject\n        // of deposit fraud challenges. This value is in seconds and should be\n        // greater than the deposit refund time plus some time margin.\n        uint32 walletClosingPeriod;\n        // Maps the 20-byte wallet public key hash (computed using Bitcoin\n        // HASH160 over the compressed ECDSA public key) to the basic wallet\n        // information like state and pending redemptions value.\n        mapping(bytes20 => Wallets.Wallet) registeredWallets;\n    }\n\n    event DepositParametersUpdated(\n        uint64 depositDustThreshold,\n        uint64 depositTreasuryFeeDivisor,\n        uint64 depositTxMaxFee\n    );\n\n    event RedemptionParametersUpdated(\n        uint64 redemptionDustThreshold,\n        uint64 redemptionTreasuryFeeDivisor,\n        uint64 redemptionTxMaxFee,\n        uint256 redemptionTimeout,\n        uint96 redemptionTimeoutSlashingAmount,\n        uint256 redemptionTimeoutNotifierRewardMultiplier\n    );\n\n    event MovingFundsParametersUpdated(\n        uint64 movingFundsTxMaxTotalFee,\n        uint64 movingFundsDustThreshold,\n        uint32 movingFundsTimeout,\n        uint96 movingFundsTimeoutSlashingAmount,\n        uint256 movingFundsTimeoutNotifierRewardMultiplier,\n        uint64 movedFundsSweepTxMaxTotalFee,\n        uint32 movedFundsSweepTimeout,\n        uint96 movedFundsSweepTimeoutSlashingAmount,\n        uint256 movedFundsSweepTimeoutNotifierRewardMultiplier\n    );\n\n    event WalletParametersUpdated(\n        uint32 walletCreationPeriod,\n        uint64 walletCreationMinBtcBalance,\n        uint64 walletCreationMaxBtcBalance,\n        uint64 walletClosureMinBtcBalance,\n        uint32 walletMaxAge,\n        uint64 walletMaxBtcTransfer,\n        uint32 walletClosingPeriod\n    );\n\n    event FraudParametersUpdated(\n        uint256 fraudChallengeDepositAmount,\n        uint256 fraudChallengeDefeatTimeout,\n        uint96 fraudSlashingAmount,\n        uint256 fraudNotifierRewardMultiplier\n    );\n\n    /// @notice Updates parameters of deposits.\n    /// @param _depositDustThreshold New value of the deposit dust threshold in\n    ///        satoshis. It is the minimal amount that can be requested to\n    ////       deposit. Value of this parameter must take into account the value\n    ///        of `depositTreasuryFeeDivisor` and `depositTxMaxFee` parameters\n    ///        in order to make requests that can incur the treasury and\n    ///        transaction fee and still satisfy the depositor\n    /// @param _depositTreasuryFeeDivisor New value of the treasury fee divisor.\n    ///        It is the divisor used to compute the treasury fee taken from\n    ///        each deposit and transferred to the treasury upon sweep proof\n    ///        submission. That fee is computed as follows:\n    ///        `treasuryFee = depositedAmount / depositTreasuryFeeDivisor`\n    ///        For example, if the treasury fee needs to be 2% of each deposit,\n    ///        the `depositTreasuryFeeDivisor` should be set to `50`\n    ///        because `1/50 = 0.02 = 2%`\n    /// @param _depositTxMaxFee New value of the deposit tx max fee in satoshis.\n    ///        It is the maximum amount of BTC transaction fee that can\n    ///        be incurred by each swept deposit being part of the given sweep\n    ///        transaction. If the maximum BTC transaction fee is exceeded,\n    ///        such transaction is considered a fraud\n    /// @dev Requirements:\n    ///      - Deposit dust threshold must be greater than zero\n    ///      - Deposit treasury fee divisor must be greater than zero\n    ///      - Deposit transaction max fee must be greater than zero\n    function updateDepositParameters(\n        Storage storage self,\n        uint64 _depositDustThreshold,\n        uint64 _depositTreasuryFeeDivisor,\n        uint64 _depositTxMaxFee\n    ) internal {\n        require(\n            _depositDustThreshold > 0,\n            \"Deposit dust threshold must be greater than zero\"\n        );\n\n        require(\n            _depositTreasuryFeeDivisor > 0,\n            \"Deposit treasury fee divisor must be greater than zero\"\n        );\n\n        require(\n            _depositTxMaxFee > 0,\n            \"Deposit transaction max fee must be greater than zero\"\n        );\n\n        self.depositDustThreshold = _depositDustThreshold;\n        self.depositTreasuryFeeDivisor = _depositTreasuryFeeDivisor;\n        self.depositTxMaxFee = _depositTxMaxFee;\n\n        emit DepositParametersUpdated(\n            _depositDustThreshold,\n            _depositTreasuryFeeDivisor,\n            _depositTxMaxFee\n        );\n    }\n\n    /// @notice Updates parameters of redemptions.\n    /// @param _redemptionDustThreshold New value of the redemption dust\n    ///        threshold in satoshis. It is the minimal amount that can be\n    ///        requested for redemption. Value of this parameter must take into\n    ///        account the value of `redemptionTreasuryFeeDivisor` and\n    ///        `redemptionTxMaxFee` parameters in order to make requests that\n    ///        can incur the treasury and transaction fee and still satisfy the\n    ///        redeemer.\n    /// @param _redemptionTreasuryFeeDivisor New value of the redemption\n    ///        treasury fee divisor. It is the divisor used to compute the\n    ///        treasury fee taken from each redemption request and transferred\n    ///        to the treasury upon successful request finalization. That fee is\n    ///        computed as follows:\n    ///        `treasuryFee = requestedAmount / redemptionTreasuryFeeDivisor`\n    ///        For example, if the treasury fee needs to be 2% of each\n    ///        redemption request, the `redemptionTreasuryFeeDivisor` should\n    ///        be set to `50` because `1/50 = 0.02 = 2%`.\n    /// @param _redemptionTxMaxFee New value of the redemption transaction max\n    ///        fee in satoshis. It is the maximum amount of BTC transaction fee\n    ///        that can be incurred by each redemption request being part of the\n    ///        given redemption transaction. If the maximum BTC transaction fee\n    ///        is exceeded, such transaction is considered a fraud.\n    ///        This is a per-redemption output max fee for the redemption\n    ///        transaction.\n    /// @param _redemptionTimeout New value of the redemption timeout in seconds.\n    ///        It is the time after which the redemption request can be reported\n    ///        as timed out. It is counted from the moment when the redemption\n    ///        request was created via `requestRedemption` call. Reported  timed\n    ///        out requests are cancelled and locked TBTC is returned to the\n    ///        redeemer in full amount.\n    /// @param _redemptionTimeoutSlashingAmount New value of the redemption\n    ///        timeout slashing amount in T, it is the amount slashed from each\n    ///        wallet member for redemption timeout\n    /// @param _redemptionTimeoutNotifierRewardMultiplier New value of the\n    ///        redemption timeout notifier reward multiplier as percentage,\n    ///        it determines the percentage of the notifier reward from the\n    ///        staking contact the notifier of a redemption timeout receives.\n    ///        The value must be in the range [0, 100]\n    /// @dev Requirements:\n    ///      - Redemption dust threshold must be greater than zero\n    ///      - Redemption treasury fee divisor must be greater than zero\n    ///      - Redemption transaction max fee must be greater than zero\n    ///      - Redemption timeout must be greater than zero\n    ///      - Redemption timeout notifier reward multiplier must be in the\n    ///        range [0, 100]\n    function updateRedemptionParameters(\n        Storage storage self,\n        uint64 _redemptionDustThreshold,\n        uint64 _redemptionTreasuryFeeDivisor,\n        uint64 _redemptionTxMaxFee,\n        uint256 _redemptionTimeout,\n        uint96 _redemptionTimeoutSlashingAmount,\n        uint256 _redemptionTimeoutNotifierRewardMultiplier\n    ) internal {\n        require(\n            _redemptionDustThreshold > 0,\n            \"Redemption dust threshold must be greater than zero\"\n        );\n\n        require(\n            _redemptionTreasuryFeeDivisor > 0,\n            \"Redemption treasury fee divisor must be greater than zero\"\n        );\n\n        require(\n            _redemptionTxMaxFee > 0,\n            \"Redemption transaction max fee must be greater than zero\"\n        );\n\n        require(\n            _redemptionTimeout > 0,\n            \"Redemption timeout must be greater than zero\"\n        );\n\n        require(\n            _redemptionTimeoutNotifierRewardMultiplier <= 100,\n            \"Redemption timeout notifier reward multiplier must be in the range [0, 100]\"\n        );\n\n        self.redemptionDustThreshold = _redemptionDustThreshold;\n        self.redemptionTreasuryFeeDivisor = _redemptionTreasuryFeeDivisor;\n        self.redemptionTxMaxFee = _redemptionTxMaxFee;\n        self.redemptionTimeout = _redemptionTimeout;\n        self.redemptionTimeoutSlashingAmount = _redemptionTimeoutSlashingAmount;\n        self\n            .redemptionTimeoutNotifierRewardMultiplier = _redemptionTimeoutNotifierRewardMultiplier;\n\n        emit RedemptionParametersUpdated(\n            _redemptionDustThreshold,\n            _redemptionTreasuryFeeDivisor,\n            _redemptionTxMaxFee,\n            _redemptionTimeout,\n            _redemptionTimeoutSlashingAmount,\n            _redemptionTimeoutNotifierRewardMultiplier\n        );\n    }\n\n    /// @notice Updates parameters of moving funds.\n    /// @param _movingFundsTxMaxTotalFee New value of the moving funds transaction\n    ///        max total fee in satoshis. It is the maximum amount of the total\n    ///        BTC transaction fee that is acceptable in a single moving funds\n    ///        transaction. This is a _total_ max fee for the entire moving\n    ///        funds transaction.\n    /// @param _movingFundsDustThreshold New value of the moving funds dust\n    ///        threshold. It is the minimal satoshi amount that makes sense to\n    //         be transferred during the moving funds process. Moving funds\n    //         wallets having their BTC balance below that value can begin\n    //         closing immediately as transferring such a low value may not be\n    //         possible due to BTC network fees.\n    /// @param _movingFundsTimeout New value of the moving funds timeout in\n    ///        seconds. It is the time after which the moving funds process can\n    ///        be reported as timed out. It is counted from the moment when the\n    ///        wallet was requested to move their funds and switched to the\n    ///        MovingFunds state.\n    /// @param _movingFundsTimeoutSlashingAmount New value of the moving funds\n    ///        timeout slashing amount in T, it is the amount slashed from each\n    ///        wallet member for moving funds timeout\n    /// @param _movingFundsTimeoutNotifierRewardMultiplier New value of the\n    ///        moving funds timeout notifier reward multiplier as percentage,\n    ///        it determines the percentage of the notifier reward from the\n    ///        staking contact the notifier of a moving funds timeout receives.\n    ///        The value must be in the range [0, 100]\n    /// @param _movedFundsSweepTxMaxTotalFee New value of the moved funds sweep\n    ///        transaction max total fee in satoshis. It is the maximum amount\n    ///        of the total BTC transaction fee that is acceptable in a single\n    ///        moved funds sweep transaction. This is a _total_ max fee for the\n    ///        entire moved funds sweep transaction.\n    /// @param _movedFundsSweepTimeout New value of the moved funds sweep\n    ///        timeout in seconds. It is the time after which the moved funds\n    ///        sweep process can be reported as timed out. It is counted from\n    ///        the moment when the wallet was requested to sweep the received\n    ///        funds.\n    /// @param _movedFundsSweepTimeoutSlashingAmount New value of the moved\n    ///        funds sweep timeout slashing amount in T, it is the amount\n    ///        slashed from each wallet member for moved funds sweep timeout\n    /// @param _movedFundsSweepTimeoutNotifierRewardMultiplier New value of\n    ///        the moved funds sweep timeout notifier reward multiplier as\n    ///        percentage, it determines the percentage of the notifier reward\n    ///        from the staking contact the notifier of a moved funds sweep\n    ///        timeout receives. The value must be in the range [0, 100]\n    /// @dev Requirements:\n    ///      - Moving funds transaction max total fee must be greater than zero\n    ///      - Moving funds dust threshold must be greater than zero\n    ///      - Moving funds timeout must be greater than zero\n    ///      - Moving funds timeout notifier reward multiplier must be in the\n    ///        range [0, 100]\n    ///      - Moved funds sweep transaction max total fee must be greater than zero\n    ///      - Moved funds sweep timeout must be greater than zero\n    ///      - Moved funds sweep timeout notifier reward multiplier must be in the\n    ///        range [0, 100]\n    function updateMovingFundsParameters(\n        Storage storage self,\n        uint64 _movingFundsTxMaxTotalFee,\n        uint64 _movingFundsDustThreshold,\n        uint32 _movingFundsTimeout,\n        uint96 _movingFundsTimeoutSlashingAmount,\n        uint256 _movingFundsTimeoutNotifierRewardMultiplier,\n        uint64 _movedFundsSweepTxMaxTotalFee,\n        uint32 _movedFundsSweepTimeout,\n        uint96 _movedFundsSweepTimeoutSlashingAmount,\n        uint256 _movedFundsSweepTimeoutNotifierRewardMultiplier\n    ) internal {\n        require(\n            _movingFundsTxMaxTotalFee > 0,\n            \"Moving funds transaction max total fee must be greater than zero\"\n        );\n\n        require(\n            _movingFundsDustThreshold > 0,\n            \"Moving funds dust threshold must be greater than zero\"\n        );\n\n        require(\n            _movingFundsTimeout > 0,\n            \"Moving funds timeout must be greater than zero\"\n        );\n\n        require(\n            _movingFundsTimeoutNotifierRewardMultiplier <= 100,\n            \"Moving funds timeout notifier reward multiplier must be in the range [0, 100]\"\n        );\n\n        require(\n            _movedFundsSweepTxMaxTotalFee > 0,\n            \"Moved funds sweep transaction max total fee must be greater than zero\"\n        );\n\n        require(\n            _movedFundsSweepTimeout > 0,\n            \"Moved funds sweep timeout must be greater than zero\"\n        );\n\n        require(\n            _movedFundsSweepTimeoutNotifierRewardMultiplier <= 100,\n            \"Moved funds sweep timeout notifier reward multiplier must be in the range [0, 100]\"\n        );\n\n        self.movingFundsTxMaxTotalFee = _movingFundsTxMaxTotalFee;\n        self.movingFundsDustThreshold = _movingFundsDustThreshold;\n        self.movingFundsTimeout = _movingFundsTimeout;\n        self\n            .movingFundsTimeoutSlashingAmount = _movingFundsTimeoutSlashingAmount;\n        self\n            .movingFundsTimeoutNotifierRewardMultiplier = _movingFundsTimeoutNotifierRewardMultiplier;\n        self.movedFundsSweepTxMaxTotalFee = _movedFundsSweepTxMaxTotalFee;\n        self.movedFundsSweepTimeout = _movedFundsSweepTimeout;\n        self\n            .movedFundsSweepTimeoutSlashingAmount = _movedFundsSweepTimeoutSlashingAmount;\n        self\n            .movedFundsSweepTimeoutNotifierRewardMultiplier = _movedFundsSweepTimeoutNotifierRewardMultiplier;\n\n        emit MovingFundsParametersUpdated(\n            _movingFundsTxMaxTotalFee,\n            _movingFundsDustThreshold,\n            _movingFundsTimeout,\n            _movingFundsTimeoutSlashingAmount,\n            _movingFundsTimeoutNotifierRewardMultiplier,\n            _movedFundsSweepTxMaxTotalFee,\n            _movedFundsSweepTimeout,\n            _movedFundsSweepTimeoutSlashingAmount,\n            _movedFundsSweepTimeoutNotifierRewardMultiplier\n        );\n    }\n\n    /// @notice Updates parameters of wallets.\n    /// @param _walletCreationPeriod New value of the wallet creation period in\n    ///        seconds, determines how frequently a new wallet creation can be\n    ///        requested\n    /// @param _walletCreationMinBtcBalance New value of the wallet minimum BTC\n    ///        balance in satoshi, used to decide about wallet creation\n    /// @param _walletCreationMaxBtcBalance New value of the wallet maximum BTC\n    ///        balance in satoshi, used to decide about wallet creation\n    /// @param _walletClosureMinBtcBalance New value of the wallet minimum BTC\n    ///        balance in satoshi, used to decide about wallet closure\n    /// @param _walletMaxAge New value of the wallet maximum age in seconds,\n    ///        indicates the maximum age of a wallet in seconds, after which\n    ///        the wallet moving funds process can be requested\n    /// @param _walletMaxBtcTransfer New value of the wallet maximum BTC transfer\n    ///        in satoshi, determines the maximum amount that can be transferred\n    ///        to a single target wallet during the moving funds process\n    /// @param _walletClosingPeriod New value of the wallet closing period in\n    ///        seconds, determines the length of the wallet closing period,\n    //         i.e. the period when the wallet remains in the Closing state\n    //         and can be subject of deposit fraud challenges\n    /// @dev Requirements:\n    ///      - Wallet minimum BTC balance must be greater than zero\n    ///      - Wallet maximum BTC balance must be greater than the wallet\n    ///        minimum BTC balance\n    ///      - Wallet maximum BTC transfer must be greater than zero\n    ///      - Wallet closing period must be greater than zero\n    function updateWalletParameters(\n        Storage storage self,\n        uint32 _walletCreationPeriod,\n        uint64 _walletCreationMinBtcBalance,\n        uint64 _walletCreationMaxBtcBalance,\n        uint64 _walletClosureMinBtcBalance,\n        uint32 _walletMaxAge,\n        uint64 _walletMaxBtcTransfer,\n        uint32 _walletClosingPeriod\n    ) internal {\n        require(\n            _walletCreationMaxBtcBalance > _walletCreationMinBtcBalance,\n            \"Wallet creation maximum BTC balance must be greater than the creation minimum BTC balance\"\n        );\n        require(\n            _walletClosureMinBtcBalance > 0,\n            \"Wallet closure minimum BTC balance must be greater than zero\"\n        );\n        require(\n            _walletMaxBtcTransfer > 0,\n            \"Wallet maximum BTC transfer must be greater than zero\"\n        );\n        require(\n            _walletClosingPeriod > 0,\n            \"Wallet closing period must be greater than zero\"\n        );\n\n        self.walletCreationPeriod = _walletCreationPeriod;\n        self.walletCreationMinBtcBalance = _walletCreationMinBtcBalance;\n        self.walletCreationMaxBtcBalance = _walletCreationMaxBtcBalance;\n        self.walletClosureMinBtcBalance = _walletClosureMinBtcBalance;\n        self.walletMaxAge = _walletMaxAge;\n        self.walletMaxBtcTransfer = _walletMaxBtcTransfer;\n        self.walletClosingPeriod = _walletClosingPeriod;\n\n        emit WalletParametersUpdated(\n            _walletCreationPeriod,\n            _walletCreationMinBtcBalance,\n            _walletCreationMaxBtcBalance,\n            _walletClosureMinBtcBalance,\n            _walletMaxAge,\n            _walletMaxBtcTransfer,\n            _walletClosingPeriod\n        );\n    }\n\n    /// @notice Updates parameters related to frauds.\n    /// @param _fraudChallengeDepositAmount New value of the fraud challenge\n    ///        deposit amount in wei, it is the amount of ETH the party\n    ///        challenging the wallet for fraud needs to deposit\n    /// @param _fraudChallengeDefeatTimeout New value of the challenge defeat\n    ///        timeout in seconds, it is the amount of time the wallet has to\n    ///        defeat a fraud challenge. The value must be greater than zero\n    /// @param _fraudSlashingAmount New value of the fraud slashing amount in T,\n    ///        it is the amount slashed from each wallet member for committing\n    ///        a fraud\n    /// @param _fraudNotifierRewardMultiplier New value of the fraud notifier\n    ///        reward multiplier as percentage, it determines the percentage of\n    ///        the notifier reward from the staking contact the notifier of\n    ///        a fraud receives. The value must be in the range [0, 100]\n    /// @dev Requirements:\n    ///      - Fraud challenge defeat timeout must be greater than 0\n    ///      - Fraud notifier reward multiplier must be in the range [0, 100]\n    function updateFraudParameters(\n        Storage storage self,\n        uint256 _fraudChallengeDepositAmount,\n        uint256 _fraudChallengeDefeatTimeout,\n        uint96 _fraudSlashingAmount,\n        uint256 _fraudNotifierRewardMultiplier\n    ) internal {\n        require(\n            _fraudChallengeDefeatTimeout > 0,\n            \"Fraud challenge defeat timeout must be greater than zero\"\n        );\n\n        require(\n            _fraudNotifierRewardMultiplier <= 100,\n            \"Fraud notifier reward multiplier must be in the range [0, 100]\"\n        );\n\n        self.fraudChallengeDepositAmount = _fraudChallengeDepositAmount;\n        self.fraudChallengeDefeatTimeout = _fraudChallengeDefeatTimeout;\n        self.fraudSlashingAmount = _fraudSlashingAmount;\n        self.fraudNotifierRewardMultiplier = _fraudNotifierRewardMultiplier;\n\n        emit FraudParametersUpdated(\n            _fraudChallengeDepositAmount,\n            _fraudChallengeDefeatTimeout,\n            _fraudSlashingAmount,\n            _fraudNotifierRewardMultiplier\n        );\n    }\n}\n"
     },
     "@keep-network/bitcoin-spv-sol/contracts/BytesLib.sol": {
       "content": "pragma solidity ^0.8.4;\n\n/*\n\nhttps://github.com/GNSPS/solidity-bytes-utils/\n\nThis is free and unencumbered software released into the public domain.\n\nAnyone is free to copy, modify, publish, use, compile, sell, or\ndistribute this software, either in source code form or as a compiled\nbinary, for any purpose, commercial or non-commercial, and by any\nmeans.\n\nIn jurisdictions that recognize copyright laws, the author or authors\nof this software dedicate any and all copyright interest in the\nsoftware to the public domain. We make this dedication for the benefit\nof the public at large and to the detriment of our heirs and\nsuccessors. We intend this dedication to be an overt act of\nrelinquishment in perpetuity of all present and future rights to this\nsoftware under copyright law.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\nIN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR\nOTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,\nARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\nOTHER DEALINGS IN THE SOFTWARE.\n\nFor more information, please refer to <https://unlicense.org>\n*/\n\n\n/** @title BytesLib **/\n/** @author https://github.com/GNSPS **/\n\nlibrary BytesLib {\n    function concat(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bytes memory) {\n        bytes memory tempBytes;\n\n        assembly {\n            // Get a location of some free memory and store it in tempBytes as\n            // Solidity does for memory variables.\n            tempBytes := mload(0x40)\n\n            // Store the length of the first bytes array at the beginning of\n            // the memory for tempBytes.\n            let length := mload(_preBytes)\n            mstore(tempBytes, length)\n\n            // Maintain a memory counter for the current write location in the\n            // temp bytes array by adding the 32 bytes for the array length to\n            // the starting location.\n            let mc := add(tempBytes, 0x20)\n            // Stop copying when the memory counter reaches the length of the\n            // first bytes array.\n            let end := add(mc, length)\n\n            for {\n                // Initialize a copy counter to the start of the _preBytes data,\n                // 32 bytes into its memory.\n                let cc := add(_preBytes, 0x20)\n            } lt(mc, end) {\n                // Increase both counters by 32 bytes each iteration.\n                mc := add(mc, 0x20)\n                cc := add(cc, 0x20)\n            } {\n                // Write the _preBytes data into the tempBytes memory 32 bytes\n                // at a time.\n                mstore(mc, mload(cc))\n            }\n\n            // Add the length of _postBytes to the current length of tempBytes\n            // and store it as the new length in the first 32 bytes of the\n            // tempBytes memory.\n            length := mload(_postBytes)\n            mstore(tempBytes, add(length, mload(tempBytes)))\n\n            // Move the memory counter back from a multiple of 0x20 to the\n            // actual end of the _preBytes data.\n            mc := end\n            // Stop copying when the memory counter reaches the new combined\n            // length of the arrays.\n            end := add(mc, length)\n\n            for {\n                let cc := add(_postBytes, 0x20)\n            } lt(mc, end) {\n                mc := add(mc, 0x20)\n                cc := add(cc, 0x20)\n            } {\n                mstore(mc, mload(cc))\n            }\n\n            // Update the free-memory pointer by padding our last write location\n            // to 32 bytes: add 31 bytes to the end of tempBytes to move to the\n            // next 32 byte block, then round down to the nearest multiple of\n            // 32. If the sum of the length of the two arrays is zero then add\n            // one before rounding down to leave a blank 32 bytes (the length block with 0).\n            mstore(0x40, and(\n                add(add(end, iszero(add(length, mload(_preBytes)))), 31),\n                not(31) // Round down to the nearest 32 bytes.\n            ))\n        }\n\n        return tempBytes;\n    }\n\n    function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {\n        assembly {\n            // Read the first 32 bytes of _preBytes storage, which is the length\n            // of the array. (We don't need to use the offset into the slot\n            // because arrays use the entire slot.)\n            let fslot := sload(_preBytes.slot)\n            // Arrays of 31 bytes or less have an even value in their slot,\n            // while longer arrays have an odd value. The actual length is\n            // the slot divided by two for odd values, and the lowest order\n            // byte divided by two for even values.\n            // If the slot is even, bitwise and the slot with 255 and divide by\n            // two to get the length. If the slot is odd, bitwise and the slot\n            // with -1 and divide by two.\n            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)\n            let mlength := mload(_postBytes)\n            let newlength := add(slength, mlength)\n            // slength can contain both the length and contents of the array\n            // if length < 32 bytes so let's prepare for that\n            // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage\n            switch add(lt(slength, 32), lt(newlength, 32))\n            case 2 {\n                // Since the new array still fits in the slot, we just need to\n                // update the contents of the slot.\n                // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length\n                sstore(\n                    _preBytes.slot,\n                    // all the modifications to the slot are inside this\n                    // next block\n                    add(\n                        // we can just add to the slot contents because the\n                        // bytes we want to change are the LSBs\n                        fslot,\n                        add(\n                            mul(\n                                div(\n                                    // load the bytes from memory\n                                    mload(add(_postBytes, 0x20)),\n                                    // zero all bytes to the right\n                                    exp(0x100, sub(32, mlength))\n                        ),\n                        // and now shift left the number of bytes to\n                        // leave space for the length in the slot\n                        exp(0x100, sub(32, newlength))\n                        ),\n                        // increase length by the double of the memory\n                        // bytes length\n                        mul(mlength, 2)\n                        )\n                    )\n                )\n            }\n            case 1 {\n                // The stored value fits in the slot, but the combined value\n                // will exceed it.\n                // get the keccak hash to get the contents of the array\n                mstore(0x0, _preBytes.slot)\n                let sc := add(keccak256(0x0, 0x20), div(slength, 32))\n\n                // save new length\n                sstore(_preBytes.slot, add(mul(newlength, 2), 1))\n\n                // The contents of the _postBytes array start 32 bytes into\n                // the structure. Our first read should obtain the `submod`\n                // bytes that can fit into the unused space in the last word\n                // of the stored array. To get this, we read 32 bytes starting\n                // from `submod`, so the data we read overlaps with the array\n                // contents by `submod` bytes. Masking the lowest-order\n                // `submod` bytes allows us to add that value directly to the\n                // stored value.\n\n                let submod := sub(32, slength)\n                let mc := add(_postBytes, submod)\n                let end := add(_postBytes, mlength)\n                let mask := sub(exp(0x100, submod), 1)\n\n                sstore(\n                    sc,\n                    add(\n                        and(\n                            fslot,\n                            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00\n                    ),\n                    and(mload(mc), mask)\n                    )\n                )\n\n                for {\n                    mc := add(mc, 0x20)\n                    sc := add(sc, 1)\n                } lt(mc, end) {\n                    sc := add(sc, 1)\n                    mc := add(mc, 0x20)\n                } {\n                    sstore(sc, mload(mc))\n                }\n\n                mask := exp(0x100, sub(mc, end))\n\n                sstore(sc, mul(div(mload(mc), mask), mask))\n            }\n            default {\n                // get the keccak hash to get the contents of the array\n                mstore(0x0, _preBytes.slot)\n                // Start copying to the last used word of the stored array.\n                let sc := add(keccak256(0x0, 0x20), div(slength, 32))\n\n                // save new length\n                sstore(_preBytes.slot, add(mul(newlength, 2), 1))\n\n                // Copy over the first `submod` bytes of the new data as in\n                // case 1 above.\n                let slengthmod := mod(slength, 32)\n                let mlengthmod := mod(mlength, 32)\n                let submod := sub(32, slengthmod)\n                let mc := add(_postBytes, submod)\n                let end := add(_postBytes, mlength)\n                let mask := sub(exp(0x100, submod), 1)\n\n                sstore(sc, add(sload(sc), and(mload(mc), mask)))\n\n                for {\n                    sc := add(sc, 1)\n                    mc := add(mc, 0x20)\n                } lt(mc, end) {\n                    sc := add(sc, 1)\n                    mc := add(mc, 0x20)\n                } {\n                    sstore(sc, mload(mc))\n                }\n\n                mask := exp(0x100, sub(mc, end))\n\n                sstore(sc, mul(div(mload(mc), mask), mask))\n            }\n        }\n    }\n\n    function slice(bytes memory _bytes, uint _start, uint _length) internal  pure returns (bytes memory res) {\n        if (_length == 0) {\n            return hex\"\";\n        }\n        uint _end = _start + _length;\n        require(_end > _start && _bytes.length >= _end, \"Slice out of bounds\");\n\n        assembly {\n            // Alloc bytes array with additional 32 bytes afterspace and assign it's size\n            res := mload(0x40)\n            mstore(0x40, add(add(res, 64), _length))\n            mstore(res, _length)\n\n            // Compute distance between source and destination pointers\n            let diff := sub(res, add(_bytes, _start))\n\n            for {\n                let src := add(add(_bytes, 32), _start)\n                let end := add(src, _length)\n            } lt(src, end) {\n                src := add(src, 32)\n            } {\n                mstore(add(src, diff), mload(src))\n            }\n        }\n    }\n\n    /// @notice Take a slice of the byte array, overwriting the destination.\n    /// The length of the slice will equal the length of the destination array.\n    /// @dev Make sure the destination array has afterspace if required.\n    /// @param _bytes The source array\n    /// @param _dest The destination array.\n    /// @param _start The location to start in the source array.\n    function sliceInPlace(\n        bytes memory _bytes,\n        bytes memory _dest,\n        uint _start\n    ) internal pure {\n        uint _length = _dest.length;\n        uint _end = _start + _length;\n        require(_end > _start && _bytes.length >= _end, \"Slice out of bounds\");\n\n        assembly {\n            for {\n                let src := add(add(_bytes, 32), _start)\n                let res := add(_dest, 32)\n                let end := add(src, _length)\n            } lt(src, end) {\n                src := add(src, 32)\n                res := add(res, 32)\n            } {\n                mstore(res, mload(src))\n            }\n        }\n    }\n\n    // Static slice functions, no bounds checking\n    /// @notice take a 32-byte slice from the specified position\n    function slice32(bytes memory _bytes, uint _start) internal pure returns (bytes32 res) {\n        assembly {\n            res := mload(add(add(_bytes, 32), _start))\n        }\n    }\n\n    /// @notice take a 20-byte slice from the specified position\n    function slice20(bytes memory _bytes, uint _start) internal pure returns (bytes20) {\n        return bytes20(slice32(_bytes, _start));\n    }\n\n    /// @notice take a 8-byte slice from the specified position\n    function slice8(bytes memory _bytes, uint _start) internal pure returns (bytes8) {\n        return bytes8(slice32(_bytes, _start));\n    }\n\n    /// @notice take a 4-byte slice from the specified position\n    function slice4(bytes memory _bytes, uint _start) internal pure returns (bytes4) {\n        return bytes4(slice32(_bytes, _start));\n    }\n\n    /// @notice take a 3-byte slice from the specified position\n    function slice3(bytes memory _bytes, uint _start) internal pure returns (bytes3) {\n        return bytes3(slice32(_bytes, _start));\n    }\n\n    /// @notice take a 2-byte slice from the specified position\n    function slice2(bytes memory _bytes, uint _start) internal pure returns (bytes2) {\n        return bytes2(slice32(_bytes, _start));\n    }\n\n    function toAddress(bytes memory _bytes, uint _start) internal  pure returns (address) {\n        uint _totalLen = _start + 20;\n        require(_totalLen > _start && _bytes.length >= _totalLen, \"Address conversion out of bounds.\");\n        address tempAddress;\n\n        assembly {\n            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)\n        }\n\n        return tempAddress;\n    }\n\n    function toUint(bytes memory _bytes, uint _start) internal  pure returns (uint256) {\n        uint _totalLen = _start + 32;\n        require(_totalLen > _start && _bytes.length >= _totalLen, \"Uint conversion out of bounds.\");\n        uint256 tempUint;\n\n        assembly {\n            tempUint := mload(add(add(_bytes, 0x20), _start))\n        }\n\n        return tempUint;\n    }\n\n    function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {\n        bool success = true;\n\n        assembly {\n            let length := mload(_preBytes)\n\n            // if lengths don't match the arrays are not equal\n            switch eq(length, mload(_postBytes))\n            case 1 {\n                // cb is a circuit breaker in the for loop since there's\n                //  no said feature for inline assembly loops\n                // cb = 1 - don't breaker\n                // cb = 0 - break\n                let cb := 1\n\n                let mc := add(_preBytes, 0x20)\n                let end := add(mc, length)\n\n                for {\n                    let cc := add(_postBytes, 0x20)\n                    // the next line is the loop condition:\n                    // while(uint(mc < end) + cb == 2)\n                } eq(add(lt(mc, end), cb), 2) {\n                    mc := add(mc, 0x20)\n                    cc := add(cc, 0x20)\n                } {\n                    // if any of these checks fails then arrays are not equal\n                    if iszero(eq(mload(mc), mload(cc))) {\n                        // unsuccess:\n                        success := 0\n                        cb := 0\n                    }\n                }\n            }\n            default {\n                // unsuccess:\n                success := 0\n            }\n        }\n\n        return success;\n    }\n\n    function equalStorage(bytes storage _preBytes, bytes memory _postBytes) internal view returns (bool) {\n        bool success = true;\n\n        assembly {\n            // we know _preBytes_offset is 0\n            let fslot := sload(_preBytes.slot)\n            // Decode the length of the stored array like in concatStorage().\n            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)\n            let mlength := mload(_postBytes)\n\n            // if lengths don't match the arrays are not equal\n            switch eq(slength, mlength)\n            case 1 {\n                // slength can contain both the length and contents of the array\n                // if length < 32 bytes so let's prepare for that\n                // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage\n                if iszero(iszero(slength)) {\n                    switch lt(slength, 32)\n                    case 1 {\n                        // blank the last byte which is the length\n                        fslot := mul(div(fslot, 0x100), 0x100)\n\n                        if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {\n                            // unsuccess:\n                            success := 0\n                        }\n                    }\n                    default {\n                        // cb is a circuit breaker in the for loop since there's\n                        //  no said feature for inline assembly loops\n                        // cb = 1 - don't breaker\n                        // cb = 0 - break\n                        let cb := 1\n\n                        // get the keccak hash to get the contents of the array\n                        mstore(0x0, _preBytes.slot)\n                        let sc := keccak256(0x0, 0x20)\n\n                        let mc := add(_postBytes, 0x20)\n                        let end := add(mc, mlength)\n\n                        // the next line is the loop condition:\n                        // while(uint(mc < end) + cb == 2)\n                        for {} eq(add(lt(mc, end), cb), 2) {\n                            sc := add(sc, 1)\n                            mc := add(mc, 0x20)\n                        } {\n                            if iszero(eq(sload(sc), mload(mc))) {\n                                // unsuccess:\n                                success := 0\n                                cb := 0\n                            }\n                        }\n                    }\n                }\n            }\n            default {\n                // unsuccess:\n                success := 0\n            }\n        }\n\n        return success;\n    }\n\n    function toBytes32(bytes memory _source) pure internal returns (bytes32 result) {\n        if (_source.length == 0) {\n            return 0x0;\n        }\n\n        assembly {\n            result := mload(add(_source, 32))\n        }\n    }\n\n    function keccak256Slice(bytes memory _bytes, uint _start, uint _length) pure internal returns (bytes32 result) {\n        uint _end = _start + _length;\n        require(_end > _start && _bytes.length >= _end, \"Slice out of bounds\");\n\n        assembly {\n            result := keccak256(add(add(_bytes, 32), _start), _length)\n        }\n    }\n}\n"
@@ -154,14 +154,17 @@
     "contracts/bridge/Fraud.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 {BytesLib} from \"@keep-network/bitcoin-spv-sol/contracts/BytesLib.sol\";\nimport {BTCUtils} from \"@keep-network/bitcoin-spv-sol/contracts/BTCUtils.sol\";\nimport {CheckBitcoinSigs} from \"@keep-network/bitcoin-spv-sol/contracts/CheckBitcoinSigs.sol\";\n\nimport \"./BitcoinTx.sol\";\nimport \"./EcdsaLib.sol\";\nimport \"./BridgeState.sol\";\nimport \"./Wallets.sol\";\n\n/// @title Bridge fraud\n/// @notice The library handles the logic for challenging Bridge wallets that\n///         committed fraud.\n/// @dev Anyone can submit a fraud challenge indicating that a UTXO being under\n///      the wallet control was unlocked by the wallet but was not used\n///      according to the protocol rules. That means the wallet signed\n///      a transaction input pointing to that UTXO and there is a unique\n///      sighash and signature pair associated with that input.\n///\n///      In order to defeat the challenge, the same wallet public key and\n///      signature must be provided as were used to calculate the sighash during\n///      the challenge. The wallet provides the preimage which produces sighash\n///      used to generate the ECDSA signature that is the subject of the fraud\n///      claim. The fraud challenge defeat attempt will only succeed if the\n///      inputs in the preimage are considered honestly spent by the wallet.\n///      Therefore the transaction spending the UTXO must be proven in the\n///      Bridge before a challenge defeat is called.\nlibrary Fraud {\n    using Wallets for BridgeState.Storage;\n\n    using BytesLib for bytes;\n    using BTCUtils for bytes;\n    using BTCUtils for uint32;\n    using EcdsaLib for bytes;\n\n    struct FraudChallenge {\n        // The address of the party challenging the wallet.\n        address challenger;\n        // The amount of ETH the challenger deposited.\n        uint256 depositAmount;\n        // The timestamp the challenge was submitted at.\n        uint32 reportedAt;\n        // The flag indicating whether the challenge has been resolved.\n        bool resolved;\n    }\n\n    event FraudChallengeSubmitted(\n        bytes20 walletPubKeyHash,\n        bytes32 sighash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    );\n\n    event FraudChallengeDefeated(bytes20 walletPubKeyHash, bytes32 sighash);\n\n    event FraudChallengeDefeatTimedOut(\n        bytes20 walletPubKeyHash,\n        bytes32 sighash\n    );\n\n    /// @notice Submits a fraud challenge indicating that a UTXO being under\n    ///         wallet control was unlocked by the wallet but was not used\n    ///         according to the protocol rules. That means the wallet signed\n    ///         a transaction input pointing to that UTXO and there is a unique\n    ///         sighash and signature pair associated with that input. This\n    ///         function uses those parameters to create a fraud accusation that\n    ///         proves a given transaction input unlocking the given UTXO was\n    ///         actually signed by the wallet. This function cannot determine\n    ///         whether the transaction was actually broadcast and the input was\n    ///         consumed in a fraudulent way so it just opens a challenge period\n    ///         during which the wallet can defeat the challenge by submitting\n    ///         proof of a transaction that consumes the given input according\n    ///         to protocol rules. To prevent spurious allegations, the caller\n    ///         must deposit ETH that is returned back upon justified fraud\n    ///         challenge or confiscated otherwise\n    /// @param walletPublicKey The public key of the wallet in the uncompressed\n    ///        and unprefixed format (64 bytes)\n    /// @param sighash The hash that was used to produce the ECDSA signature\n    ///        that is the subject of the fraud claim. This hash is constructed\n    ///        by applying double SHA-256 over a serialized subset of the\n    ///        transaction. The exact subset used as hash preimage depends on\n    ///        the transaction input the signature is produced for. See BIP-143\n    ///        for reference\n    /// @param signature Bitcoin signature in the R/S/V format\n    /// @dev Requirements:\n    ///      - Wallet behind `walletPublicKey` must be in Live or MovingFunds\n    ///        or Closing state\n    ///      - The challenger must send appropriate amount of ETH used as\n    ///        fraud challenge deposit\n    ///      - The signature (represented by r, s and v) must be generated by\n    ///        the wallet behind `walletPublicKey` during signing of `sighash`\n    ///      - Wallet can be challenged for the given signature only once\n    function submitFraudChallenge(\n        BridgeState.Storage storage self,\n        bytes calldata walletPublicKey,\n        bytes32 sighash,\n        BitcoinTx.RSVSignature calldata signature\n    ) external {\n        require(\n            msg.value >= self.fraudChallengeDepositAmount,\n            \"The amount of ETH deposited is too low\"\n        );\n\n        require(\n            CheckBitcoinSigs.checkSig(\n                walletPublicKey,\n                sighash,\n                signature.v,\n                signature.r,\n                signature.s\n            ),\n            \"Signature verification failure\"\n        );\n\n        bytes memory compressedWalletPublicKey = EcdsaLib.compressPublicKey(\n            walletPublicKey.slice32(0),\n            walletPublicKey.slice32(32)\n        );\n        bytes20 walletPubKeyHash = compressedWalletPublicKey.hash160View();\n\n        Wallets.Wallet storage wallet = self.registeredWallets[\n            walletPubKeyHash\n        ];\n\n        require(\n            wallet.state == Wallets.WalletState.Live ||\n                wallet.state == Wallets.WalletState.MovingFunds ||\n                wallet.state == Wallets.WalletState.Closing,\n            \"Wallet must be in Live or MovingFunds or Closing state\"\n        );\n\n        uint256 challengeKey = uint256(\n            keccak256(abi.encodePacked(walletPublicKey, sighash))\n        );\n\n        FraudChallenge storage challenge = self.fraudChallenges[challengeKey];\n        require(challenge.reportedAt == 0, \"Fraud challenge already exists\");\n\n        challenge.challenger = msg.sender;\n        challenge.depositAmount = msg.value;\n        /* solhint-disable-next-line not-rely-on-time */\n        challenge.reportedAt = uint32(block.timestamp);\n        challenge.resolved = false;\n        // slither-disable-next-line reentrancy-events\n        emit FraudChallengeSubmitted(\n            walletPubKeyHash,\n            sighash,\n            signature.v,\n            signature.r,\n            signature.s\n        );\n    }\n\n    /// @notice Allows to defeat a pending fraud challenge against a wallet if\n    ///         the transaction that spends the UTXO follows the protocol rules.\n    ///         In order to defeat the challenge the same `walletPublicKey` and\n    ///         signature (represented by `r`, `s` and `v`) must be provided as\n    ///         were used to calculate the sighash during input signing.\n    ///         The fraud challenge defeat attempt will only succeed if the\n    ///         inputs in the preimage are considered honestly spent by the\n    ///         wallet. Therefore the transaction spending the UTXO must be\n    ///         proven in the Bridge before a challenge defeat is called.\n    ///         If successfully defeated, the fraud challenge is marked as\n    ///         resolved and the amount of ether deposited by the challenger is\n    ///         sent to the treasury.\n    /// @param walletPublicKey The public key of the wallet in the uncompressed\n    ///        and unprefixed format (64 bytes)\n    /// @param preimage The preimage which produces sighash used to generate the\n    ///        ECDSA signature that is the subject of the fraud claim. It is a\n    ///        serialized subset of the transaction. The exact subset used as\n    ///        the preimage depends on the transaction input the signature is\n    ///        produced for. See BIP-143 for reference\n    /// @param witness Flag indicating whether the preimage was produced for a\n    ///        witness input. True for witness, false for non-witness input.\n    /// @dev Requirements:\n    ///      - `walletPublicKey` and `sighash` calculated as `hash256(preimage)`\n    ///        must identify an open fraud challenge\n    ///      - the preimage must be a valid preimage of a transaction generated\n    ///        according to the protocol rules and already proved in the Bridge\n    ///      - before a defeat attempt is made the transaction that spends the\n    ///        given UTXO must be proven in the Bridge\n    function defeatFraudChallenge(\n        BridgeState.Storage storage self,\n        bytes calldata walletPublicKey,\n        bytes calldata preimage,\n        bool witness\n    ) external {\n        bytes32 sighash = preimage.hash256();\n\n        uint256 challengeKey = uint256(\n            keccak256(abi.encodePacked(walletPublicKey, sighash))\n        );\n\n        FraudChallenge storage challenge = self.fraudChallenges[challengeKey];\n\n        require(challenge.reportedAt > 0, \"Fraud challenge does not exist\");\n        require(\n            !challenge.resolved,\n            \"Fraud challenge has already been resolved\"\n        );\n\n        // Ensure SIGHASH_ALL type was used during signing, which is represented\n        // by type value `1`.\n        require(extractSighashType(preimage) == 1, \"Wrong sighash type\");\n\n        uint256 utxoKey = witness\n            ? extractUtxoKeyFromWitnessPreimage(preimage)\n            : extractUtxoKeyFromNonWitnessPreimage(preimage);\n\n        // Check that the UTXO key identifies a correctly spent UTXO.\n        require(\n            self.deposits[utxoKey].sweptAt > 0 || self.spentMainUTXOs[utxoKey],\n            \"Spent UTXO not found among correctly spent UTXOs\"\n        );\n\n        // Mark the challenge as resolved as it was successfully defeated\n        challenge.resolved = true;\n\n        // Send the ether deposited by the challenger to the treasury\n        /* solhint-disable avoid-low-level-calls */\n        // slither-disable-next-line low-level-calls,unchecked-lowlevel,arbitrary-send\n        self.treasury.call{gas: 100000, value: challenge.depositAmount}(\"\");\n        /* solhint-enable avoid-low-level-calls */\n\n        bytes memory compressedWalletPublicKey = EcdsaLib.compressPublicKey(\n            walletPublicKey.slice32(0),\n            walletPublicKey.slice32(32)\n        );\n        bytes20 walletPubKeyHash = compressedWalletPublicKey.hash160View();\n        // slither-disable-next-line reentrancy-events\n        emit FraudChallengeDefeated(walletPubKeyHash, sighash);\n    }\n\n    /// @notice Notifies about defeat timeout for the given fraud challenge.\n    ///         Can be called only if there was a fraud challenge identified by\n    ///         the provided `walletPublicKey` and `sighash` and it was not\n    ///         defeated on time. The amount of time that needs to pass after a\n    ///         fraud challenge is reported is indicated by the\n    ///         `challengeDefeatTimeout`. After a successful fraud challenge\n    ///         defeat timeout notification the fraud challenge is marked as\n    ///         resolved, the stake of each operator is slashed, the ether\n    ///         deposited is returned to the challenger and the challenger is\n    ///         rewarded.\n    /// @param walletPublicKey The public key of the wallet in the uncompressed\n    ///        and unprefixed format (64 bytes)\n    /// @param walletMembersIDs Identifiers of the wallet signing group members\n    /// @param sighash The hash that was used to produce the ECDSA signature\n    ///        that is the subject of the fraud claim. This hash is constructed\n    ///        by applying double SHA-256 over a serialized subset of the\n    ///        transaction. The exact subset used as hash preimage depends on\n    ///        the transaction input the signature is produced for. See BIP-143\n    ///        for reference\n    /// @dev Requirements:\n    ///      - The wallet must be in the Live or MovingFunds or Closing or\n    ///        Terminated state\n    ///      - The `walletPublicKey` and `sighash` must identify an open fraud\n    ///        challenge\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract\n    ///      - The amount of time indicated by `challengeDefeatTimeout` must pass\n    ///        after the challenge was reported\n    function notifyFraudChallengeDefeatTimeout(\n        BridgeState.Storage storage self,\n        bytes calldata walletPublicKey,\n        uint32[] calldata walletMembersIDs,\n        bytes32 sighash\n    ) external {\n        uint256 challengeKey = uint256(\n            keccak256(abi.encodePacked(walletPublicKey, sighash))\n        );\n\n        FraudChallenge storage challenge = self.fraudChallenges[challengeKey];\n\n        require(challenge.reportedAt > 0, \"Fraud challenge does not exist\");\n\n        require(\n            !challenge.resolved,\n            \"Fraud challenge has already been resolved\"\n        );\n\n        require(\n            /* solhint-disable-next-line not-rely-on-time */\n            block.timestamp >=\n                challenge.reportedAt + self.fraudChallengeDefeatTimeout,\n            \"Fraud challenge defeat period did not time out yet\"\n        );\n\n        challenge.resolved = true;\n        // Return the ether deposited by the challenger\n        /* solhint-disable avoid-low-level-calls */\n        // slither-disable-next-line low-level-calls,unchecked-lowlevel\n        challenge.challenger.call{gas: 100000, value: challenge.depositAmount}(\n            \"\"\n        );\n        /* solhint-enable avoid-low-level-calls */\n\n        bytes memory compressedWalletPublicKey = EcdsaLib.compressPublicKey(\n            walletPublicKey.slice32(0),\n            walletPublicKey.slice32(32)\n        );\n        bytes20 walletPubKeyHash = compressedWalletPublicKey.hash160View();\n\n        Wallets.Wallet storage wallet = self.registeredWallets[\n            walletPubKeyHash\n        ];\n\n        Wallets.WalletState walletState = wallet.state;\n\n        if (\n            walletState == Wallets.WalletState.Live ||\n            walletState == Wallets.WalletState.MovingFunds ||\n            walletState == Wallets.WalletState.Closing\n        ) {\n            self.terminateWallet(walletPubKeyHash);\n\n            self.ecdsaWalletRegistry.seize(\n                self.fraudSlashingAmount,\n                self.fraudNotifierRewardMultiplier,\n                challenge.challenger,\n                wallet.ecdsaWalletID,\n                walletMembersIDs\n            );\n        } else if (walletState == Wallets.WalletState.Terminated) {\n            // This is a special case when the wallet was already terminated\n            // due to a previous deliberate protocol violation. In that\n            // case, this function should be still callable for other fraud\n            // challenges timeouts in order to let the challenger unlock its\n            // ETH deposit back. However, the wallet termination logic is\n            // not called and the challenger is not rewarded.\n        } else {\n            revert(\n                \"Wallet must be in Live or MovingFunds or Closing or Terminated state\"\n            );\n        }\n\n        // slither-disable-next-line reentrancy-events\n        emit FraudChallengeDefeatTimedOut(walletPubKeyHash, sighash);\n    }\n\n    /// @notice Extracts the UTXO keys from the given preimage used during\n    ///         signing of a witness input.\n    /// @param preimage The preimage which produces sighash used to generate the\n    ///        ECDSA signature that is the subject of the fraud claim. It is a\n    ///        serialized subset of the transaction. The exact subset used as\n    ///        the preimage depends on the transaction input the signature is\n    ///        produced for. See BIP-143 for reference\n    /// @return utxoKey UTXO key that identifies spent input.\n    function extractUtxoKeyFromWitnessPreimage(bytes calldata preimage)\n        internal\n        pure\n        returns (uint256 utxoKey)\n    {\n        // The expected structure of the preimage created during signing of a\n        // witness input:\n        // - transaction version (4 bytes)\n        // - hash of previous outpoints of all inputs (32 bytes)\n        // - hash of sequences of all inputs (32 bytes)\n        // - outpoint (hash + index) of the input being signed (36 bytes)\n        // - the unlocking script of the input (variable length)\n        // - value of the outpoint (8 bytes)\n        // - sequence of the input being signed (4 bytes)\n        // - hash of all outputs (32 bytes)\n        // - transaction locktime (4 bytes)\n        // - sighash type (4 bytes)\n\n        // See Bitcoin's BIP-143 for reference:\n        // https://github.com/bitcoin/bips/blob/master/bip-0143.mediawiki.\n\n        // The outpoint (hash and index) is located at the constant offset of\n        // 68 (4 + 32 + 32).\n        bytes32 outpointTxHash = preimage.extractInputTxIdLeAt(68);\n        uint32 outpointIndex = BTCUtils.reverseUint32(\n            uint32(preimage.extractTxIndexLeAt(68))\n        );\n\n        return\n            uint256(keccak256(abi.encodePacked(outpointTxHash, outpointIndex)));\n    }\n\n    /// @notice Extracts the UTXO key from the given preimage used during\n    ///         signing of a non-witness input.\n    /// @param preimage The preimage which produces sighash used to generate the\n    ///        ECDSA signature that is the subject of the fraud claim. It is a\n    ///        serialized subset of the transaction. The exact subset used as\n    ///        the preimage depends on the transaction input the signature is\n    ///        produced for. See BIP-143 for reference\n    /// @return utxoKey UTXO key that identifies spent input.\n    function extractUtxoKeyFromNonWitnessPreimage(bytes calldata preimage)\n        internal\n        pure\n        returns (uint256 utxoKey)\n    {\n        // The expected structure of the preimage created during signing of a\n        // non-witness input:\n        // - transaction version (4 bytes)\n        // - number of inputs written as compactSize uint (1 byte, 3 bytes,\n        //   5 bytes or 9 bytes)\n        // - for each input\n        //   - outpoint (hash and index) (36 bytes)\n        //   - unlocking script for the input being signed (variable length)\n        //     or `00` for all other inputs (1 byte)\n        //   - input sequence (4 bytes)\n        // - number of outputs written as compactSize uint (1 byte, 3 bytes,\n        //   5 bytes or 9 bytes)\n        // - outputs (variable length)\n        // - transaction locktime (4 bytes)\n        // - sighash type (4 bytes)\n\n        // See example for reference:\n        // https://en.bitcoin.it/wiki/OP_CHECKSIG#Code_samples_and_raw_dumps.\n\n        // The input data begins at the constant offset of 4 (the first 4 bytes\n        // are for the transaction version).\n        (uint256 inputsCompactSizeUintLength, uint256 inputsCount) = preimage\n            .parseVarIntAt(4);\n\n        // To determine the first input starting index, we must jump 4 bytes\n        // over the transaction version length and the compactSize uint which\n        // prepends the input vector. One byte must be added because\n        // `BtcUtils.parseVarInt` does not include compactSize uint tag in the\n        // 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 = 4 + 1 + inputsCompactSizeUintLength;\n\n        for (uint256 i = 0; i < inputsCount; i++) {\n            uint256 inputLength = preimage.determineInputLengthAt(\n                inputStartingIndex\n            );\n\n            (, uint256 scriptSigLength) = preimage.extractScriptSigLenAt(\n                inputStartingIndex\n            );\n\n            if (scriptSigLength > 0) {\n                // The input this preimage was generated for was found.\n                // All the other inputs in the preimage are marked with a null\n                // scriptSig (\"00\") which has length of 1.\n                bytes32 outpointTxHash = preimage.extractInputTxIdLeAt(\n                    inputStartingIndex\n                );\n                uint32 outpointIndex = BTCUtils.reverseUint32(\n                    uint32(preimage.extractTxIndexLeAt(inputStartingIndex))\n                );\n\n                utxoKey = uint256(\n                    keccak256(abi.encodePacked(outpointTxHash, outpointIndex))\n                );\n\n                break;\n            }\n\n            inputStartingIndex += inputLength;\n        }\n\n        return utxoKey;\n    }\n\n    /// @notice Extracts the sighash type from the given preimage.\n    /// @param preimage Serialized subset of the transaction. See BIP-143 for\n    ///        reference\n    /// @dev Sighash type is stored as the last 4 bytes in the preimage (little\n    ///      endian).\n    /// @return sighashType Sighash type as a 32-bit integer.\n    function extractSighashType(bytes calldata preimage)\n        internal\n        pure\n        returns (uint32 sighashType)\n    {\n        bytes4 sighashTypeBytes = preimage.slice4(preimage.length - 4);\n        uint32 sighashTypeLE = uint32(sighashTypeBytes);\n        return sighashTypeLE.reverseUint32();\n    }\n}\n"
     },
+    "contracts/bridge/MovingFunds.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 \"./Redemption.sol\";\nimport \"./Wallets.sol\";\n\n/// @title Moving Bridge wallet funds\n/// @notice The library handles the logic for moving Bitcoin between Bridge\n///         wallets.\n/// @dev A wallet that failed a heartbeat, did not process requested redemption\n///      on time, or qualifies to be closed, begins the procedure of moving\n///      funds to other wallets in the Bridge. The wallet needs to commit to\n///      which other Live wallets it is moving the funds to and then, provide an\n///      SPV proof of moving funds to the previously committed wallets.\n///      Once the proof is submitted, all target wallets are supposed to\n///      sweep the received UTXOs with their own main UTXOs in order to\n///      update their BTC balances.\nlibrary MovingFunds {\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 temporary information needed during the processing\n    ///         of the moving funds Bitcoin transaction outputs. This structure\n    ///         is an internal one and should not be exported outside of the\n    ///         moving funds transaction processing code.\n    /// @dev Allows to mitigate \"stack too deep\" errors on EVM.\n    struct MovingFundsTxOutputsProcessingInfo {\n        // 32-byte hash of the moving funds Bitcoin transaction.\n        bytes32 movingFundsTxHash;\n        // Output vector of the moving funds Bitcoin transaction. It is\n        // assumed the vector's structure is valid so it must be validated\n        // using e.g. `BTCUtils.validateVout` 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 movingFundsTxOutputVector;\n    }\n\n    /// @notice Represents moved funds sweep request state.\n    enum MovedFundsSweepRequestState {\n        /// @dev The request is unknown to the Bridge.\n        Unknown,\n        /// @dev Request is pending and can become either processed or timed out.\n        Pending,\n        /// @dev Request was processed by the target wallet.\n        Processed,\n        /// @dev Request was not processed in the given time window and\n        ///      the timeout was reported.\n        TimedOut\n    }\n\n    /// @notice Represents a moved funds sweep request. The request is\n    ///         registered in `submitMovingFundsProof` where we know funds\n    ///         have been moved to the target wallet and the only step left is\n    ///         to have the target wallet sweep them.\n    struct MovedFundsSweepRequest {\n        // 20-byte public key hash of the wallet supposed to sweep the UTXO\n        // representing the received funds with their own main UTXO\n        bytes20 walletPubKeyHash;\n        // Value of the received funds.\n        uint64 value;\n        // UNIX timestamp the request was created at.\n        uint32 createdAt;\n        // The current state of the request.\n        MovedFundsSweepRequestState state;\n    }\n\n    event MovingFundsCommitmentSubmitted(\n        bytes20 walletPubKeyHash,\n        bytes20[] targetWallets,\n        address submitter\n    );\n\n    event MovingFundsCompleted(\n        bytes20 walletPubKeyHash,\n        bytes32 movingFundsTxHash\n    );\n\n    event MovingFundsTimedOut(bytes20 walletPubKeyHash);\n\n    event MovingFundsBelowDustReported(bytes20 walletPubKeyHash);\n\n    event MovedFundsSwept(bytes20 walletPubKeyHash, bytes32 sweepTxHash);\n\n    event MovedFundsSweepTimedOut(\n        bytes20 walletPubKeyHash,\n        bytes32 movingFundsTxHash,\n        uint32 movingFundsTxOutputIndex\n    );\n\n    /// @notice Submits the moving funds target wallets commitment.\n    ///         Once all requirements are met, that function registers the\n    ///         target wallets commitment and opens the way for moving funds\n    ///         proof submission.\n    /// @param walletPubKeyHash 20-byte public key hash of the source wallet\n    /// @param walletMainUtxo Data of the source wallet's main UTXO, as\n    ///        currently known on the Ethereum chain\n    /// @param walletMembersIDs Identifiers of the source wallet signing group\n    ///        members\n    /// @param walletMemberIndex Position of the caller in the source wallet\n    ///        signing group members list\n    /// @param targetWallets List of 20-byte public key hashes of the target\n    ///        wallets that the source wallet commits to move the funds to\n    /// @dev Requirements:\n    ///      - The source wallet must be in the MovingFunds state\n    ///      - The source wallet must not have pending redemption requests\n    ///      - The source wallet must not have pending moved funds sweep requests\n    ///      - The source wallet must not have submitted its commitment already\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given source wallet in the ECDSA registry. Those IDs are\n    ///        not directly stored in the contract for gas efficiency purposes\n    ///        but they can be read from appropriate `DkgResultSubmitted`\n    ///        and `DkgResultApproved` events.\n    ///      - The `walletMemberIndex` must be in range [1, walletMembersIDs.length]\n    ///      - The caller must be the member of the source wallet signing group\n    ///        at the position indicated by `walletMemberIndex` parameter\n    ///      - The `walletMainUtxo` components must point to the recent main\n    ///        UTXO of the source wallet, as currently known on the Ethereum\n    ///        chain.\n    ///      - Source wallet BTC balance must be greater than zero\n    ///      - At least one Live wallet must exist in the system\n    ///      - Submitted target wallets count must match the expected count\n    ///        `N = min(liveWalletsCount, ceil(walletBtcBalance / walletMaxBtcTransfer))`\n    ///        where `N > 0`\n    ///      - Each target wallet must be not equal to the source wallet\n    ///      - Each target wallet must follow the expected order i.e. all\n    ///        target wallets 20-byte public key hashes represented as numbers\n    ///        must form a strictly increasing sequence without duplicates.\n    ///      - Each target wallet must be in Live state\n    function submitMovingFundsCommitment(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata walletMainUtxo,\n        uint32[] calldata walletMembersIDs,\n        uint256 walletMemberIndex,\n        bytes20[] calldata targetWallets\n    ) external {\n        Wallets.Wallet storage wallet = self.registeredWallets[\n            walletPubKeyHash\n        ];\n\n        require(\n            wallet.state == Wallets.WalletState.MovingFunds,\n            \"Source wallet must be in MovingFunds state\"\n        );\n\n        require(\n            wallet.pendingRedemptionsValue == 0,\n            \"Source wallet must handle all pending redemptions first\"\n        );\n\n        require(\n            wallet.pendingMovedFundsSweepRequestsCount == 0,\n            \"Source wallet must handle all pending moved funds sweep requests first\"\n        );\n\n        require(\n            wallet.movingFundsTargetWalletsCommitmentHash == bytes32(0),\n            \"Target wallets commitment already submitted\"\n        );\n\n        require(\n            self.ecdsaWalletRegistry.isWalletMember(\n                wallet.ecdsaWalletID,\n                walletMembersIDs,\n                msg.sender,\n                walletMemberIndex\n            ),\n            \"Caller is not a member of the source wallet\"\n        );\n\n        uint64 walletBtcBalance = self.getWalletBtcBalance(\n            walletPubKeyHash,\n            walletMainUtxo\n        );\n\n        require(walletBtcBalance > 0, \"Wallet BTC balance is zero\");\n\n        uint256 expectedTargetWalletsCount = Math.min(\n            self.liveWalletsCount,\n            Math.ceilDiv(walletBtcBalance, self.walletMaxBtcTransfer)\n        );\n\n        // This requirement fails only when `liveWalletsCount` is zero. In\n        // that case, the system cannot accept the commitment and must provide\n        // new wallets first.\n        //\n        // TODO: Expose separate function to reset the moving funds timeout\n        //       if no Live wallets exist in the system.\n        require(expectedTargetWalletsCount > 0, \"No target wallets available\");\n\n        require(\n            targetWallets.length == expectedTargetWalletsCount,\n            \"Submitted target wallets count is other than expected\"\n        );\n\n        uint160 lastProcessedTargetWallet = 0;\n\n        for (uint256 i = 0; i < targetWallets.length; i++) {\n            bytes20 targetWallet = targetWallets[i];\n\n            require(\n                targetWallet != walletPubKeyHash,\n                \"Submitted target wallet cannot be equal to the source wallet\"\n            );\n\n            require(\n                uint160(targetWallet) > lastProcessedTargetWallet,\n                \"Submitted target wallet breaks the expected order\"\n            );\n\n            require(\n                self.registeredWallets[targetWallet].state ==\n                    Wallets.WalletState.Live,\n                \"Submitted target wallet must be in Live state\"\n            );\n\n            lastProcessedTargetWallet = uint160(targetWallet);\n        }\n\n        wallet.movingFundsTargetWalletsCommitmentHash = keccak256(\n            abi.encodePacked(targetWallets)\n        );\n\n        emit MovingFundsCommitmentSubmitted(\n            walletPubKeyHash,\n            targetWallets,\n            msg.sender\n        );\n    }\n\n    /// @notice Used by the wallet to prove the BTC moving funds transaction\n    ///         and to make the necessary state changes. Moving funds is only\n    ///         accepted if it satisfies SPV proof.\n    ///\n    ///         The function validates the moving funds transaction structure\n    ///         by checking if it actually spends the main UTXO of the declared\n    ///         wallet and locks the value on the pre-committed target wallets\n    ///         using a reasonable transaction fee. If all preconditions are\n    ///         met, this functions closes the source wallet.\n    ///\n    ///         It is possible to prove the given moving funds transaction only\n    ///         one time.\n    /// @param movingFundsTx Bitcoin moving funds transaction data\n    /// @param movingFundsProof Bitcoin moving funds proof data\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    ///        HASH160 over the compressed ECDSA public key) of the wallet\n    ///        which performed the moving funds transaction\n    /// @dev Requirements:\n    ///      - `movingFundsTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash.\n    ///      - The `movingFundsTx` should represent a Bitcoin transaction with\n    ///        exactly 1 input that refers to the wallet's main UTXO. That\n    ///        transaction should have 1..n outputs corresponding to the\n    ///        pre-committed target wallets. Outputs must be ordered in the\n    ///        same way as their corresponding target wallets are ordered\n    ///        within the target wallets commitment.\n    ///      - `movingFundsProof` components must match the expected structure.\n    ///        See `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant.\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        Additionally, the recent main UTXO on Ethereum must be set.\n    ///      - `walletPubKeyHash` must be connected with the main UTXO used\n    ///        as transaction single input.\n    ///      - The wallet that `walletPubKeyHash` points to must be in the\n    ///        MovingFunds state.\n    ///      - The target wallets commitment must be submitted by the wallet\n    ///        that `walletPubKeyHash` points to.\n    ///      - The total Bitcoin transaction fee must be lesser or equal\n    ///        to `movingFundsTxMaxTotalFee` governable parameter.\n    function submitMovingFundsProof(\n        BridgeState.Storage storage self,\n        BitcoinTx.Info calldata movingFundsTx,\n        BitcoinTx.Proof calldata movingFundsProof,\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 movingFundsTxHash = self.validateProof(\n            movingFundsTx,\n            movingFundsProof\n        );\n\n        // Process the moving funds transaction input. Specifically, check if\n        // it refers to the expected wallet's main UTXO.\n        OutboundTx.processWalletOutboundTxInput(\n            self,\n            movingFundsTx.inputVector,\n            mainUtxo,\n            walletPubKeyHash\n        );\n\n        (\n            bytes32 targetWalletsHash,\n            uint256 outputsTotalValue\n        ) = processMovingFundsTxOutputs(\n                self,\n                MovingFundsTxOutputsProcessingInfo(\n                    movingFundsTxHash,\n                    movingFundsTx.outputVector\n                )\n            );\n\n        require(\n            mainUtxo.txOutputValue - outputsTotalValue <=\n                self.movingFundsTxMaxTotalFee,\n            \"Transaction fee is too high\"\n        );\n\n        self.notifyWalletFundsMoved(walletPubKeyHash, targetWalletsHash);\n        // slither-disable-next-line reentrancy-events\n        emit MovingFundsCompleted(walletPubKeyHash, movingFundsTxHash);\n    }\n\n    /// @notice Processes the moving funds Bitcoin transaction output vector\n    ///         and extracts information required for further processing.\n    /// @param processInfo Processing info containing the moving funds tx\n    ///        hash and output vector.\n    /// @return targetWalletsHash keccak256 hash over the list of actual\n    ///         target wallets used in the transaction.\n    /// @return outputsTotalValue Sum of all outputs values.\n    /// @dev Requirements:\n    ///      - The `movingFundsTxOutputVector` must be parseable, i.e. must\n    ///        be validated by the caller as stated in their parameter doc.\n    ///      - Each output must refer to a 20-byte public key hash.\n    ///      - The total outputs value must be evenly divided over all outputs.\n    function processMovingFundsTxOutputs(\n        BridgeState.Storage storage self,\n        MovingFundsTxOutputsProcessingInfo memory processInfo\n    ) internal returns (bytes32 targetWalletsHash, uint256 outputsTotalValue) {\n        // Determining the total number of Bitcoin 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        ) = processInfo.movingFundsTxOutputVector.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        bytes20[] memory targetWallets = new bytes20[](outputsCount);\n        uint64[] memory outputsValues = new uint64[](outputsCount);\n\n        // Outputs processing loop. Note that the `outputIndex` must be\n        // `uint32` to build proper `movedFundsSweepRequests` keys.\n        for (\n            uint32 outputIndex = 0;\n            outputIndex < outputsCount;\n            outputIndex++\n        ) {\n            uint256 outputLength = processInfo\n                .movingFundsTxOutputVector\n                .determineOutputLengthAt(outputStartingIndex);\n\n            bytes memory output = processInfo.movingFundsTxOutputVector.slice(\n                outputStartingIndex,\n                outputLength\n            );\n\n            bytes20 targetWalletPubKeyHash = self.extractPubKeyHash(output);\n\n            // Add the wallet public key hash to the list that will be used\n            // to build the result list hash. There is no need to check if\n            // given output is a change here because the actual target wallet\n            // list must be exactly the same as the pre-committed target wallet\n            // list which is guaranteed to be valid.\n            targetWallets[outputIndex] = targetWalletPubKeyHash;\n\n            // Extract the value from given output.\n            outputsValues[outputIndex] = output.extractValue();\n            outputsTotalValue += outputsValues[outputIndex];\n\n            // Register a moved funds sweep request that must be handled\n            // by the target wallet. The target wallet must sweep the\n            // received funds with their own main UTXO in order to update\n            // their BTC balance. Worth noting there is no need to check\n            // if the sweep request already exists in the system because\n            // the moving funds wallet is moved to the Closing state after\n            // submitting the moving funds proof so there is no possibility\n            // to submit the proof again and register the sweep request twice.\n            self.movedFundsSweepRequests[\n                uint256(\n                    keccak256(\n                        abi.encodePacked(\n                            processInfo.movingFundsTxHash,\n                            outputIndex\n                        )\n                    )\n                )\n            ] = MovedFundsSweepRequest(\n                targetWalletPubKeyHash,\n                outputsValues[outputIndex],\n                /* solhint-disable-next-line not-rely-on-time */\n                uint32(block.timestamp),\n                MovedFundsSweepRequestState.Pending\n            );\n            // We added a new moved funds sweep request for the target wallet\n            // so we must increment their request counter.\n            self\n                .registeredWallets[targetWalletPubKeyHash]\n                .pendingMovedFundsSweepRequestsCount++;\n\n            // Make the `outputStartingIndex` pointing to the next output by\n            // increasing it by current output's length.\n            outputStartingIndex += outputLength;\n        }\n\n        // Compute the indivisible remainder that remains after dividing the\n        // outputs total value over all outputs evenly.\n        uint256 outputsTotalValueRemainder = outputsTotalValue % outputsCount;\n        // Compute the minimum allowed output value by dividing the outputs\n        // total value (reduced by the remainder) by the number of outputs.\n        uint256 minOutputValue = (outputsTotalValue -\n            outputsTotalValueRemainder) / outputsCount;\n        // Maximum possible value is the minimum value with the remainder included.\n        uint256 maxOutputValue = minOutputValue + outputsTotalValueRemainder;\n\n        for (uint256 i = 0; i < outputsCount; i++) {\n            require(\n                minOutputValue <= outputsValues[i] &&\n                    outputsValues[i] <= maxOutputValue,\n                \"Transaction amount is not distributed evenly\"\n            );\n        }\n\n        targetWalletsHash = keccak256(abi.encodePacked(targetWallets));\n\n        return (targetWalletsHash, outputsTotalValue);\n    }\n\n    /// @notice Notifies about a timed out moving funds process. Terminates\n    ///         the wallet and slashes signing group members as a result.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param walletMembersIDs Identifiers of the wallet signing group members\n    /// @dev Requirements:\n    ///      - The wallet must be in the MovingFunds state\n    ///      - The moving funds timeout must be actually exceeded\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract\n    function notifyMovingFundsTimeout(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        uint32[] calldata walletMembersIDs\n    ) external {\n        Wallets.Wallet storage wallet = self.registeredWallets[\n            walletPubKeyHash\n        ];\n\n        require(\n            wallet.state == Wallets.WalletState.MovingFunds,\n            \"ECDSA wallet must be in MovingFunds state\"\n        );\n\n        require(\n            /* solhint-disable-next-line not-rely-on-time */\n            block.timestamp >\n                wallet.movingFundsRequestedAt + self.movingFundsTimeout,\n            \"Moving funds has not timed out yet\"\n        );\n\n        self.terminateWallet(walletPubKeyHash);\n\n        self.ecdsaWalletRegistry.seize(\n            self.movingFundsTimeoutSlashingAmount,\n            self.movingFundsTimeoutNotifierRewardMultiplier,\n            msg.sender,\n            wallet.ecdsaWalletID,\n            walletMembersIDs\n        );\n\n        // slither-disable-next-line reentrancy-events\n        emit MovingFundsTimedOut(walletPubKeyHash);\n    }\n\n    /// @notice Notifies about a moving funds wallet whose BTC balance is\n    ///         below the moving funds dust threshold. Ends the moving funds\n    ///         process and begins wallet closing immediately.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known\n    ///        on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - The wallet must be in the MovingFunds state\n    ///      - The `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        If the wallet has no main UTXO, this parameter can be empty as it\n    ///        is ignored.\n    ///      - The wallet BTC balance must be below the moving funds threshold\n    function notifyMovingFundsBelowDust(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata mainUtxo\n    ) external {\n        Wallets.Wallet storage wallet = self.registeredWallets[\n            walletPubKeyHash\n        ];\n\n        require(\n            wallet.state == Wallets.WalletState.MovingFunds,\n            \"ECDSA wallet must be in MovingFunds state\"\n        );\n\n        uint64 walletBtcBalance = self.getWalletBtcBalance(\n            walletPubKeyHash,\n            mainUtxo\n        );\n\n        require(\n            walletBtcBalance < self.movingFundsDustThreshold,\n            \"Wallet BTC balance must be below the moving funds dust threshold\"\n        );\n\n        self.beginWalletClosing(walletPubKeyHash);\n\n        // slither-disable-next-line reentrancy-events\n        emit MovingFundsBelowDustReported(walletPubKeyHash);\n    }\n\n    /// @notice Used by the wallet to prove the BTC moved funds sweep\n    ///         transaction and to make the necessary state changes. Moved\n    ///         funds sweep is only accepted if it satisfies SPV proof.\n    ///\n    ///         The function validates the sweep transaction structure by\n    ///         checking if it actually spends the moved funds UTXO and the\n    ///         sweeping wallet's main UTXO (optionally), and if it locks the\n    ///         value on the sweeping wallet's 20-byte public key hash using a\n    ///         reasonable transaction fee. If all preconditions are\n    ///         met, this function updates the sweeping wallet main UTXO, thus\n    ///         their BTC balance.\n    ///\n    ///         It is possible to prove the given sweep transaction only\n    ///         one time.\n    /// @param sweepTx Bitcoin sweep funds transaction data\n    /// @param sweepProof Bitcoin sweep funds proof data\n    /// @param mainUtxo Data of the sweeping wallet's main UTXO, as currently\n    ///        known on the Ethereum chain\n    /// @dev Requirements:\n    ///      - `sweepTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash.\n    ///      - The `sweepTx` should represent a Bitcoin transaction with\n    ///        the first input pointing to a wallet's sweep Pending request and,\n    ///        optionally, the second input pointing to the wallet's main UTXO,\n    ///        if the sweeping wallet has a main UTXO set. There should be only\n    ///        one output locking funds on the sweeping wallet 20-byte public\n    ///        key hash.\n    ///      - `sweepProof` components must match the expected structure.\n    ///        See `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant.\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the sweeping wallet, as currently known on the Ethereum chain.\n    ///        If there is no main UTXO, this parameter is ignored.\n    ///      - The sweeping wallet must be in the Live or MovingFunds state.\n    ///      - The total Bitcoin transaction fee must be lesser or equal\n    ///        to `movedFundsSweepTxMaxTotalFee` governable parameter.\n    function submitMovedFundsSweepProof(\n        BridgeState.Storage storage self,\n        BitcoinTx.Info calldata sweepTx,\n        BitcoinTx.Proof calldata sweepProof,\n        BitcoinTx.UTXO calldata mainUtxo\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        (\n            bytes20 walletPubKeyHash,\n            uint64 sweepTxOutputValue\n        ) = processMovedFundsSweepTxOutput(self, sweepTx.outputVector);\n\n        (\n            Wallets.Wallet storage wallet,\n            BitcoinTx.UTXO memory resolvedMainUtxo\n        ) = resolveMovedFundsSweepingWallet(self, walletPubKeyHash, mainUtxo);\n\n        uint256 sweepTxInputsTotalValue = processMovedFundsSweepTxInputs(\n            self,\n            sweepTx.inputVector,\n            resolvedMainUtxo,\n            walletPubKeyHash\n        );\n\n        require(\n            sweepTxInputsTotalValue - sweepTxOutputValue <=\n                self.movedFundsSweepTxMaxTotalFee,\n            \"Transaction fee is too high\"\n        );\n\n        // Use the sweep transaction output as the new sweeping wallet's main UTXO.\n        // Transaction output index is always 0 as sweep transaction always\n        // 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 MovedFundsSwept(walletPubKeyHash, sweepTxHash);\n    }\n\n    /// @notice Processes the Bitcoin moved funds sweep transaction output vector\n    ///         by 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 moved funds sweep transaction output\n    ///        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 moved funds sweep transaction output value.\n    /// @dev Requirements:\n    ///      - Output vector must contain only one output\n    ///      - The single output must be of P2PKH or P2WPKH type and lock the\n    ///        funds on a 20-byte public key hash\n    function processMovedFundsSweepTxOutput(\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 performed as\n        // part of the `BitcoinTx.validateProof` call.\n        // See `BitcoinTx.outputVector` docs for more details.\n        (, uint256 outputsCount) = sweepTxOutputVector.parseVarInt();\n        require(\n            outputsCount == 1,\n            \"Moved funds 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 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 resolveMovedFundsSweepingWallet(\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 moved funds sweep transaction input vector.\n    ///         It extracts the first input and tries to match it with one of\n    ///         the moved funds sweep requests targeting the sweeping wallet.\n    ///         If the sweep request is an existing Pending request, this\n    ///         function marks it as Processed. If the sweeping wallet has a\n    ///         main UTXO, this function extracts the second input, makes sure\n    ///         it refers to the wallet main UTXO, and marks that main UTXO as\n    ///         correctly spent.\n    /// @param sweepTxInputVector Bitcoin moved funds sweep transaction input vector.\n    ///        This function assumes vector's structure is valid so it must be\n    ///        validated using e.g. `BTCUtils.validateVin` function before\n    ///        it is passed here\n    /// @param mainUtxo Data of the sweeping wallet's main UTXO. If no main UTXO\n    ///        exists for the given the wallet, this parameter's fields should\n    ///        be zeroed to bypass the main UTXO validation\n    /// @param walletPubKeyHash 20-byte public key hash of the sweeping wallet\n    /// @return inputsTotalValue Total inputs value sum.\n    /// @dev Requirements:\n    ///      - The input vector must consist of one mandatory and one optional\n    ///        input.\n    ///      - The mandatory input must be the first input in the vector\n    ///      - The mandatory input must point to a Pending moved funds sweep\n    ///        request that is targeted to the sweeping wallet\n    ///      - The optional output must be the second input in the vector\n    ///      - The optional input is required if the sweeping wallet has a\n    ///        main UTXO (i.e. the `mainUtxo` is not zeroed). In that case,\n    ///        that input must point the the sweeping wallet main UTXO.\n    function processMovedFundsSweepTxInputs(\n        BridgeState.Storage storage self,\n        bytes memory sweepTxInputVector,\n        BitcoinTx.UTXO memory mainUtxo,\n        bytes20 walletPubKeyHash\n    ) internal returns (uint256 inputsTotalValue) {\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 performed as\n        // part of the `BitcoinTx.validateProof` call.\n        // See `BitcoinTx.inputVector` docs for more details.\n        (\n            uint256 inputsCompactSizeUintLength,\n            uint256 inputsCount\n        ) = sweepTxInputVector.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        // We always expect the first input to be the swept UTXO. Additionally,\n        // if the sweeping wallet has a main UTXO, that main UTXO should be\n        // pointed by the second input.\n        require(\n            inputsCount == (mainUtxo.txHash != bytes32(0) ? 2 : 1),\n            \"Moved funds sweep transaction must have a proper inputs count\"\n        );\n\n        // Parse the first input and extract its outpoint tx hash and index.\n        (\n            bytes32 firstInputOutpointTxHash,\n            uint32 firstInputOutpointIndex,\n            uint256 firstInputLength\n        ) = parseMovedFundsSweepTxInputAt(\n                sweepTxInputVector,\n                inputStartingIndex\n            );\n\n        // Build the request key and fetch the corresponding moved funds sweep\n        // request from contract storage.\n        MovedFundsSweepRequest storage sweepRequest = self\n            .movedFundsSweepRequests[\n                uint256(\n                    keccak256(\n                        abi.encodePacked(\n                            firstInputOutpointTxHash,\n                            firstInputOutpointIndex\n                        )\n                    )\n                )\n            ];\n\n        require(\n            sweepRequest.state == MovedFundsSweepRequestState.Pending,\n            \"Sweep request must be in Pending state\"\n        );\n        // We must check if the wallet extracted from the moved funds sweep\n        // transaction output is truly the owner of the sweep request connected\n        // with the swept UTXO. This is needed to prevent a case when a wallet\n        // handles its own sweep request but locks the funds on another\n        // wallet public key hash.\n        require(\n            sweepRequest.walletPubKeyHash == walletPubKeyHash,\n            \"Sweep request belongs to another wallet\"\n        );\n        // If the validation passed, the sweep request must be marked as\n        // processed and its value should be counted into the total inputs\n        // value sum.\n        sweepRequest.state = MovedFundsSweepRequestState.Processed;\n        inputsTotalValue += sweepRequest.value;\n\n        self\n            .registeredWallets[walletPubKeyHash]\n            .pendingMovedFundsSweepRequestsCount--;\n\n        // If the main UTXO for the sweeping wallet exists, it must be processed.\n        if (mainUtxo.txHash != bytes32(0)) {\n            // The second input is supposed to point to that sweeping wallet\n            // main UTXO. We need to parse that input.\n            (\n                bytes32 secondInputOutpointTxHash,\n                uint32 secondInputOutpointIndex,\n\n            ) = parseMovedFundsSweepTxInputAt(\n                    sweepTxInputVector,\n                    inputStartingIndex + firstInputLength\n                );\n            // Make sure the second input refers to the sweeping wallet main UTXO.\n            require(\n                mainUtxo.txHash == secondInputOutpointTxHash &&\n                    mainUtxo.txOutputIndex == secondInputOutpointIndex,\n                \"Second input must point to the wallet's main UTXO\"\n            );\n\n            // If the validation passed, count the main UTXO value into the\n            // total inputs value sum.\n            inputsTotalValue += mainUtxo.txOutputValue;\n\n            // Main UTXO used as an input, mark it as spent. This is needed\n            // to defend against fraud challenges referring to this main UTXO.\n            self.spentMainUTXOs[\n                uint256(\n                    keccak256(\n                        abi.encodePacked(\n                            secondInputOutpointTxHash,\n                            secondInputOutpointIndex\n                        )\n                    )\n                )\n            ] = true;\n        }\n\n        return inputsTotalValue;\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 parseMovedFundsSweepTxInputAt(\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 Notifies about a timed out moved funds sweep process. If the\n    ///         wallet is not terminated yet, that function terminates\n    ///         the wallet and slashes signing group members as a result.\n    ///         Marks the given sweep request as TimedOut.\n    /// @param movingFundsTxHash 32-byte hash of the moving funds transaction\n    ///        that caused the sweep request to be created\n    /// @param movingFundsTxOutputIndex Index of the moving funds transaction\n    ///        output that is subject of the sweep request.\n    /// @param walletMembersIDs Identifiers of the wallet signing group members\n    /// @dev Requirements:\n    ///      - The moved funds sweep request must be in the Pending state\n    ///      - The moved funds sweep timeout must be actually exceeded\n    ///      - The wallet must be either in the Live or MovingFunds or\n    ///        Terminated state\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract\n    function notifyMovedFundsSweepTimeout(\n        BridgeState.Storage storage self,\n        bytes32 movingFundsTxHash,\n        uint32 movingFundsTxOutputIndex,\n        uint32[] calldata walletMembersIDs\n    ) external {\n        MovedFundsSweepRequest storage sweepRequest = self\n            .movedFundsSweepRequests[\n                uint256(\n                    keccak256(\n                        abi.encodePacked(\n                            movingFundsTxHash,\n                            movingFundsTxOutputIndex\n                        )\n                    )\n                )\n            ];\n\n        require(\n            sweepRequest.state == MovedFundsSweepRequestState.Pending,\n            \"Sweep request must be in Pending state\"\n        );\n\n        require(\n            /* solhint-disable-next-line not-rely-on-time */\n            block.timestamp >\n                sweepRequest.createdAt + self.movedFundsSweepTimeout,\n            \"Sweep request has not timed out yet\"\n        );\n\n        bytes20 walletPubKeyHash = sweepRequest.walletPubKeyHash;\n        Wallets.Wallet storage wallet = self.registeredWallets[\n            walletPubKeyHash\n        ];\n        Wallets.WalletState walletState = wallet.state;\n\n        require(\n            walletState == Wallets.WalletState.Live ||\n                walletState == Wallets.WalletState.MovingFunds ||\n                walletState == Wallets.WalletState.Terminated,\n            \"ECDSA wallet must be in Live or MovingFunds or Terminated state\"\n        );\n\n        sweepRequest.state = MovedFundsSweepRequestState.TimedOut;\n        wallet.pendingMovedFundsSweepRequestsCount--;\n\n        if (\n            walletState == Wallets.WalletState.Live ||\n            walletState == Wallets.WalletState.MovingFunds\n        ) {\n            self.terminateWallet(walletPubKeyHash);\n\n            self.ecdsaWalletRegistry.seize(\n                self.movedFundsSweepTimeoutSlashingAmount,\n                self.movedFundsSweepTimeoutNotifierRewardMultiplier,\n                msg.sender,\n                wallet.ecdsaWalletID,\n                walletMembersIDs\n            );\n        }\n\n        // slither-disable-next-line reentrancy-events\n        emit MovedFundsSweepTimedOut(\n            walletPubKeyHash,\n            movingFundsTxHash,\n            movingFundsTxOutputIndex\n        );\n    }\n}\n"
+    },
     "@keep-network/bitcoin-spv-sol/contracts/CheckBitcoinSigs.sol": {
       "content": "pragma solidity ^0.8.4;\n\n/** @title CheckBitcoinSigs */\n/** @author Summa (https://summa.one) */\n\nimport {BytesLib} from \"./BytesLib.sol\";\nimport {BTCUtils} from \"./BTCUtils.sol\";\n\n\nlibrary CheckBitcoinSigs {\n\n    using BytesLib for bytes;\n    using BTCUtils for bytes;\n\n    /// @notice          Derives an Ethereum Account address from a pubkey\n    /// @dev             The address is the last 20 bytes of the keccak256 of the address\n    /// @param _pubkey   The public key X & Y. Unprefixed, as a 64-byte array\n    /// @return          The account address\n    function accountFromPubkey(bytes memory _pubkey) internal pure returns (address) {\n        require(_pubkey.length == 64, \"Pubkey must be 64-byte raw, uncompressed key.\");\n\n        // keccak hash of uncompressed unprefixed pubkey\n        bytes32 _digest = keccak256(_pubkey);\n        return address(uint160(uint256(_digest)));\n    }\n\n    /// @notice          Calculates the p2wpkh output script of a pubkey\n    /// @dev             Compresses keys to 33 bytes as required by Bitcoin\n    /// @param _pubkey   The public key, compressed or uncompressed\n    /// @return          The p2wkph output script\n    function p2wpkhFromPubkey(bytes memory _pubkey) internal view returns (bytes memory) {\n        bytes memory _compressedPubkey;\n        uint8 _prefix;\n\n        if (_pubkey.length == 64) {\n            _prefix = uint8(_pubkey[_pubkey.length - 1]) % 2 == 1 ? 3 : 2;\n            _compressedPubkey = abi.encodePacked(_prefix, _pubkey.slice32(0));\n        } else if (_pubkey.length == 65) {\n            _prefix = uint8(_pubkey[_pubkey.length - 1]) % 2 == 1 ? 3 : 2;\n            _compressedPubkey = abi.encodePacked(_prefix, _pubkey.slice32(1));\n        } else {\n            _compressedPubkey = _pubkey;\n        }\n\n        require(_compressedPubkey.length == 33, \"Witness PKH requires compressed keys\");\n\n        bytes20 _pubkeyHash = _compressedPubkey.hash160View();\n        return abi.encodePacked(hex\"0014\", _pubkeyHash);\n    }\n\n    /// @notice          checks a signed message's validity under a pubkey\n    /// @dev             does this using ecrecover because Ethereum has no soul\n    /// @param _pubkey   the public key to check (64 bytes)\n    /// @param _digest   the message digest signed\n    /// @param _v        the signature recovery value\n    /// @param _r        the signature r value\n    /// @param _s        the signature s value\n    /// @return          true if signature is valid, else false\n    function checkSig(\n        bytes memory _pubkey,\n        bytes32 _digest,\n        uint8 _v,\n        bytes32 _r,\n        bytes32 _s\n    ) internal pure returns (bool) {\n        require(_pubkey.length == 64, \"Requires uncompressed unprefixed pubkey\");\n        address _expected = accountFromPubkey(_pubkey);\n        address _actual = ecrecover(_digest, _v, _r, _s);\n        return _actual == _expected;\n    }\n\n    /// @notice                     checks a signed message against a bitcoin p2wpkh output script\n    /// @dev                        does this my verifying the p2wpkh matches an ethereum account\n    /// @param _p2wpkhOutputScript  the bitcoin output script\n    /// @param _pubkey              the uncompressed, unprefixed public key to check\n    /// @param _digest              the message digest signed\n    /// @param _v                   the signature recovery value\n    /// @param _r                   the signature r value\n    /// @param _s                   the signature s value\n    /// @return                     true if signature is valid, else false\n    function checkBitcoinSig(\n        bytes memory _p2wpkhOutputScript,\n        bytes memory _pubkey,\n        bytes32 _digest,\n        uint8 _v,\n        bytes32 _r,\n        bytes32 _s\n    ) internal view returns (bool) {\n        require(_pubkey.length == 64, \"Requires uncompressed unprefixed pubkey\");\n\n        bool _isExpectedSigner = keccak256(p2wpkhFromPubkey(_pubkey)) == keccak256(_p2wpkhOutputScript);  // is it the expected signer?\n        if (!_isExpectedSigner) {return false;}\n\n        bool _sigResult = checkSig(_pubkey, _digest, _v, _r, _s);\n        return _sigResult;\n    }\n\n    /// @notice             checks if a message is the sha256 preimage of a digest\n    /// @dev                this is NOT the hash256!  this step is necessary for ECDSA security!\n    /// @param _digest      the digest\n    /// @param _candidate   the purported preimage\n    /// @return             true if the preimage matches the digest, else false\n    function isSha256Preimage(\n        bytes memory _candidate,\n        bytes32 _digest\n    ) internal pure returns (bool) {\n        return sha256(_candidate) == _digest;\n    }\n\n    /// @notice             checks if a message is the keccak256 preimage of a digest\n    /// @dev                this step is necessary for ECDSA security!\n    /// @param _digest      the digest\n    /// @param _candidate   the purported preimage\n    /// @return             true if the preimage matches the digest, else false\n    function isKeccak256Preimage(\n        bytes memory _candidate,\n        bytes32 _digest\n    ) internal pure returns (bool) {\n        return keccak256(_candidate) == _digest;\n    }\n\n    /// @notice                 calculates the signature hash of a Bitcoin transaction with the provided details\n    /// @dev                    documented in bip143. many values are hardcoded here\n    /// @param _outpoint        the bitcoin UTXO id (32-byte txid + 4-byte output index)\n    /// @param _inputPKH        the input pubkeyhash (hash160(sender_pubkey))\n    /// @param _inputValue      the value of the input in satoshi\n    /// @param _outputValue     the value of the output in satoshi\n    /// @param _outputScript    the length-prefixed output script\n    /// @return                 the double-sha256 (hash256) signature hash as defined by bip143\n    function wpkhSpendSighash(\n        bytes memory _outpoint,  // 36-byte UTXO id\n        bytes20 _inputPKH,       // 20-byte hash160\n        bytes8 _inputValue,      // 8-byte LE\n        bytes8 _outputValue,     // 8-byte LE\n        bytes memory _outputScript    // lenght-prefixed output script\n    ) internal view returns (bytes32) {\n        // Fixes elements to easily make a 1-in 1-out sighash digest\n        // Does not support timelocks\n        // bytes memory _scriptCode = abi.encodePacked(\n        //     hex\"1976a914\",  // length, dup, hash160, pkh_length\n        //     _inputPKH,\n        //     hex\"88ac\");  // equal, checksig\n\n        bytes32 _hashOutputs = abi.encodePacked(\n            _outputValue,  // 8-byte LE\n            _outputScript).hash256View();\n\n        bytes memory _sighashPreimage = abi.encodePacked(\n            hex\"01000000\",  // version\n            _outpoint.hash256View(),  // hashPrevouts\n            hex\"8cb9012517c817fead650287d61bdd9c68803b6bf9c64133dcab3e65b5a50cb9\",  // hashSequence(00000000)\n            _outpoint,  // outpoint\n            // p2wpkh script code\n            hex\"1976a914\",  // length, dup, hash160, pkh_length\n            _inputPKH,\n            hex\"88ac\",  // equal, checksig\n            // end script code\n            _inputValue,  // value of the input in 8-byte LE\n            hex\"00000000\",  // input nSequence\n            _hashOutputs,  // hash of the single output\n            hex\"00000000\",  // nLockTime\n            hex\"01000000\"  // SIGHASH_ALL\n        );\n        return _sighashPreimage.hash256View();\n    }\n\n    /// @notice                 calculates the signature hash of a Bitcoin transaction with the provided details\n    /// @dev                    documented in bip143. many values are hardcoded here\n    /// @param _outpoint        the bitcoin UTXO id (32-byte txid + 4-byte output index)\n    /// @param _inputPKH        the input pubkeyhash (hash160(sender_pubkey))\n    /// @param _inputValue      the value of the input in satoshi\n    /// @param _outputValue     the value of the output in satoshi\n    /// @param _outputPKH       the output pubkeyhash (hash160(recipient_pubkey))\n    /// @return                 the double-sha256 (hash256) signature hash as defined by bip143\n    function wpkhToWpkhSighash(\n        bytes memory _outpoint,  // 36-byte UTXO id\n        bytes20 _inputPKH,  // 20-byte hash160\n        bytes8 _inputValue,  // 8-byte LE\n        bytes8 _outputValue,  // 8-byte LE\n        bytes20 _outputPKH  // 20-byte hash160\n    ) internal view returns (bytes32) {\n        return wpkhSpendSighash(\n            _outpoint,\n            _inputPKH,\n            _inputValue,\n            _outputValue,\n            abi.encodePacked(\n              hex\"160014\",  // wpkh tag\n              _outputPKH)\n            );\n    }\n\n    /// @notice                 Preserved for API compatibility with older version\n    /// @dev                    documented in bip143. many values are hardcoded here\n    /// @param _outpoint        the bitcoin UTXO id (32-byte txid + 4-byte output index)\n    /// @param _inputPKH        the input pubkeyhash (hash160(sender_pubkey))\n    /// @param _inputValue      the value of the input in satoshi\n    /// @param _outputValue     the value of the output in satoshi\n    /// @param _outputPKH       the output pubkeyhash (hash160(recipient_pubkey))\n    /// @return                 the double-sha256 (hash256) signature hash as defined by bip143\n    function oneInputOneOutputSighash(\n        bytes memory _outpoint,  // 36-byte UTXO id\n        bytes20 _inputPKH,  // 20-byte hash160\n        bytes8 _inputValue,  // 8-byte LE\n        bytes8 _outputValue,  // 8-byte LE\n        bytes20 _outputPKH  // 20-byte hash160\n    ) internal view returns (bytes32) {\n        return wpkhToWpkhSighash(_outpoint, _inputPKH, _inputValue, _outputValue, _outputPKH);\n    }\n\n}\n"
     },
     "contracts/test/BridgeStub.sol": {
-      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.9;\n\nimport \"../bridge/BitcoinTx.sol\";\nimport \"../bridge/Bridge.sol\";\nimport \"../bridge/Wallets.sol\";\n\ncontract BridgeStub is Bridge {\n    constructor(\n        address _bank,\n        address _relay,\n        address _treasury,\n        address _walletRegistry,\n        uint256 _txProofDifficultyFactor\n    )\n        Bridge(\n            _bank,\n            _relay,\n            _treasury,\n            _walletRegistry,\n            _txProofDifficultyFactor\n        )\n    {}\n\n    function setSweptDeposits(BitcoinTx.UTXO[] calldata utxos) external {\n        for (uint256 i = 0; i < utxos.length; i++) {\n            uint256 utxoKey = uint256(\n                keccak256(\n                    abi.encodePacked(utxos[i].txHash, utxos[i].txOutputIndex)\n                )\n            );\n            self.deposits[utxoKey].sweptAt = 1641650400;\n        }\n    }\n\n    function setSpentMainUtxos(BitcoinTx.UTXO[] calldata utxos) external {\n        for (uint256 i = 0; i < utxos.length; i++) {\n            uint256 utxoKey = uint256(\n                keccak256(\n                    abi.encodePacked(utxos[i].txHash, utxos[i].txOutputIndex)\n                )\n            );\n            self.spentMainUTXOs[utxoKey] = true;\n        }\n    }\n\n    function setActiveWallet(bytes20 activeWalletPubKeyHash) external {\n        self.activeWalletPubKeyHash = activeWalletPubKeyHash;\n    }\n\n    function setWalletMainUtxo(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata utxo\n    ) external {\n        self.registeredWallets[walletPubKeyHash].mainUtxoHash = keccak256(\n            abi.encodePacked(\n                utxo.txHash,\n                utxo.txOutputIndex,\n                utxo.txOutputValue\n            )\n        );\n    }\n\n    function setWallet(bytes20 walletPubKeyHash, Wallets.Wallet calldata wallet)\n        external\n    {\n        self.registeredWallets[walletPubKeyHash] = wallet;\n\n        if (wallet.state == Wallets.WalletState.Live) {\n            self.liveWalletsCount++;\n        }\n    }\n\n    function setDepositDustThreshold(uint64 _depositDustThreshold) external {\n        self.depositDustThreshold = _depositDustThreshold;\n    }\n\n    function setDepositTxMaxFee(uint64 _depositTxMaxFee) external {\n        self.depositTxMaxFee = _depositTxMaxFee;\n    }\n\n    function setRedemptionDustThreshold(uint64 _redemptionDustThreshold)\n        external\n    {\n        self.redemptionDustThreshold = _redemptionDustThreshold;\n    }\n\n    function setRedemptionTreasuryFeeDivisor(\n        uint64 _redemptionTreasuryFeeDivisor\n    ) external {\n        self.redemptionTreasuryFeeDivisor = _redemptionTreasuryFeeDivisor;\n    }\n\n    function setMovingFundsTxMaxTotalFee(uint64 _movingFundsTxMaxTotalFee)\n        external\n    {\n        self.movingFundsTxMaxTotalFee = _movingFundsTxMaxTotalFee;\n    }\n}\n"
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.9;\n\nimport \"../bridge/BitcoinTx.sol\";\nimport \"../bridge/Bridge.sol\";\nimport \"../bridge/MovingFunds.sol\";\nimport \"../bridge/Wallets.sol\";\n\ncontract BridgeStub is Bridge {\n    constructor(\n        address _bank,\n        address _relay,\n        address _treasury,\n        address _walletRegistry,\n        uint256 _txProofDifficultyFactor\n    )\n        Bridge(\n            _bank,\n            _relay,\n            _treasury,\n            _walletRegistry,\n            _txProofDifficultyFactor\n        )\n    {}\n\n    function setSweptDeposits(BitcoinTx.UTXO[] calldata utxos) external {\n        for (uint256 i = 0; i < utxos.length; i++) {\n            uint256 utxoKey = uint256(\n                keccak256(\n                    abi.encodePacked(utxos[i].txHash, utxos[i].txOutputIndex)\n                )\n            );\n            self.deposits[utxoKey].sweptAt = 1641650400;\n        }\n    }\n\n    function setSpentMainUtxos(BitcoinTx.UTXO[] calldata utxos) external {\n        for (uint256 i = 0; i < utxos.length; i++) {\n            uint256 utxoKey = uint256(\n                keccak256(\n                    abi.encodePacked(utxos[i].txHash, utxos[i].txOutputIndex)\n                )\n            );\n            self.spentMainUTXOs[utxoKey] = true;\n        }\n    }\n\n    function setActiveWallet(bytes20 activeWalletPubKeyHash) external {\n        self.activeWalletPubKeyHash = activeWalletPubKeyHash;\n    }\n\n    function setWalletMainUtxo(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata utxo\n    ) external {\n        self.registeredWallets[walletPubKeyHash].mainUtxoHash = keccak256(\n            abi.encodePacked(\n                utxo.txHash,\n                utxo.txOutputIndex,\n                utxo.txOutputValue\n            )\n        );\n    }\n\n    function setWallet(bytes20 walletPubKeyHash, Wallets.Wallet calldata wallet)\n        external\n    {\n        self.registeredWallets[walletPubKeyHash] = wallet;\n\n        if (wallet.state == Wallets.WalletState.Live) {\n            self.liveWalletsCount++;\n        }\n    }\n\n    function setDepositDustThreshold(uint64 _depositDustThreshold) external {\n        self.depositDustThreshold = _depositDustThreshold;\n    }\n\n    function setDepositTxMaxFee(uint64 _depositTxMaxFee) external {\n        self.depositTxMaxFee = _depositTxMaxFee;\n    }\n\n    function setRedemptionDustThreshold(uint64 _redemptionDustThreshold)\n        external\n    {\n        self.redemptionDustThreshold = _redemptionDustThreshold;\n    }\n\n    function setRedemptionTreasuryFeeDivisor(\n        uint64 _redemptionTreasuryFeeDivisor\n    ) external {\n        self.redemptionTreasuryFeeDivisor = _redemptionTreasuryFeeDivisor;\n    }\n\n    function setMovingFundsTxMaxTotalFee(uint64 _movingFundsTxMaxTotalFee)\n        external\n    {\n        self.movingFundsTxMaxTotalFee = _movingFundsTxMaxTotalFee;\n    }\n\n    function setPendingMovedFundsSweepRequest(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata utxo\n    ) external {\n        uint256 requestKey = uint256(\n            keccak256(abi.encodePacked(utxo.txHash, utxo.txOutputIndex))\n        );\n\n        self.movedFundsSweepRequests[requestKey] = MovingFunds\n            .MovedFundsSweepRequest(\n                walletPubKeyHash,\n                utxo.txOutputValue,\n                /* solhint-disable-next-line not-rely-on-time */\n                uint32(block.timestamp),\n                MovingFunds.MovedFundsSweepRequestState.Pending\n            );\n\n        self\n            .registeredWallets[walletPubKeyHash]\n            .pendingMovedFundsSweepRequestsCount++;\n    }\n\n    function processPendingMovedFundsSweepRequest(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata utxo\n    ) external {\n        uint256 requestKey = uint256(\n            keccak256(abi.encodePacked(utxo.txHash, utxo.txOutputIndex))\n        );\n\n        MovingFunds.MovedFundsSweepRequest storage request = self\n            .movedFundsSweepRequests[requestKey];\n\n        require(\n            request.state == MovingFunds.MovedFundsSweepRequestState.Pending,\n            \"Stub sweep request must be in Pending state\"\n        );\n\n        request.state = MovingFunds.MovedFundsSweepRequestState.Processed;\n\n        self\n            .registeredWallets[walletPubKeyHash]\n            .pendingMovedFundsSweepRequestsCount--;\n    }\n\n    function timeoutPendingMovedFundsSweepRequest(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata utxo\n    ) external {\n        uint256 requestKey = uint256(\n            keccak256(abi.encodePacked(utxo.txHash, utxo.txOutputIndex))\n        );\n\n        MovingFunds.MovedFundsSweepRequest storage request = self\n            .movedFundsSweepRequests[requestKey];\n\n        require(\n            request.state == MovingFunds.MovedFundsSweepRequestState.Pending,\n            \"Stub sweep request must be in Pending state\"\n        );\n\n        request.state = MovingFunds.MovedFundsSweepRequestState.TimedOut;\n\n        self\n            .registeredWallets[walletPubKeyHash]\n            .pendingMovedFundsSweepRequestsCount--;\n    }\n\n    function setMovedFundsSweepTxMaxTotalFee(\n        uint64 _movedFundsSweepTxMaxTotalFee\n    ) external {\n        self.movedFundsSweepTxMaxTotalFee = _movedFundsSweepTxMaxTotalFee;\n    }\n}\n"
     },
     "contracts/bridge/Bridge.sol": {
-      "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\nimport \"@keep-network/random-beacon/contracts/Governable.sol\";\n\nimport {IWalletOwner as EcdsaWalletOwner} from \"@keep-network/ecdsa/contracts/api/IWalletOwner.sol\";\n\nimport \"./IRelay.sol\";\nimport \"./BridgeState.sol\";\nimport \"./Deposit.sol\";\nimport \"./Sweep.sol\";\nimport \"./Redemption.sol\";\nimport \"./BitcoinTx.sol\";\nimport \"./EcdsaLib.sol\";\nimport \"./Wallets.sol\";\nimport \"./Fraud.sol\";\nimport \"./MovingFunds.sol\";\n\nimport \"../bank/Bank.sol\";\n\n/// @title Bitcoin Bridge\n/// @notice Bridge manages BTC deposit and redemption flow and is increasing and\n///         decreasing balances in the Bank as a result of BTC deposit and\n///         redemption operations performed by depositors and redeemers.\n///\n///         Depositors send BTC funds to the most recently created off-chain\n///         ECDSA wallet of the bridge using pay-to-script-hash (P2SH) or\n///         pay-to-witness-script-hash (P2WSH) containing hashed information\n///         about the depositor’s Ethereum address. Then, the depositor reveals\n///         their Ethereum address along with their deposit blinding factor,\n///         refund public key hash and refund locktime to the Bridge on Ethereum\n///         chain. The off-chain ECDSA wallet listens for these sorts of\n///         messages and when it gets one, it checks the Bitcoin network to make\n///         sure the deposit lines up. If it does, the off-chain ECDSA wallet\n///         may decide to pick the deposit transaction for sweeping, and when\n///         the sweep operation is confirmed on the Bitcoin network, the ECDSA\n///         wallet informs the Bridge about the sweep increasing appropriate\n///         balances in the Bank.\n/// @dev Bridge is an upgradeable component of the Bank. The order of\n///      functionalities in this contract is: deposit, sweep, redemption,\n///      moving funds, wallet lifecycle, frauds, parameters.\n///\n/// TODO: Revisit all events and look which parameters should be indexed.\n/// TODO: Align the convention around `param` and `dev` endings. They should\n///       not have a punctuation mark.\ncontract Bridge is Governable, EcdsaWalletOwner {\n    using BridgeState for BridgeState.Storage;\n    using Deposit for BridgeState.Storage;\n    using Sweep for BridgeState.Storage;\n    using Redemption for BridgeState.Storage;\n    using MovingFunds for BridgeState.Storage;\n    using Wallets for BridgeState.Storage;\n    using Fraud for BridgeState.Storage;\n\n    BridgeState.Storage internal self;\n\n    event DepositRevealed(\n        bytes32 fundingTxHash,\n        uint32 fundingOutputIndex,\n        address depositor,\n        uint64 amount,\n        bytes8 blindingFactor,\n        bytes20 walletPubKeyHash,\n        bytes20 refundPubKeyHash,\n        bytes4 refundLocktime,\n        address vault\n    );\n\n    event DepositsSwept(bytes20 walletPubKeyHash, bytes32 sweepTxHash);\n\n    event RedemptionRequested(\n        bytes20 walletPubKeyHash,\n        bytes redeemerOutputScript,\n        address redeemer,\n        uint64 requestedAmount,\n        uint64 treasuryFee,\n        uint64 txMaxFee\n    );\n\n    event RedemptionsCompleted(\n        bytes20 walletPubKeyHash,\n        bytes32 redemptionTxHash\n    );\n\n    event RedemptionTimedOut(\n        bytes20 walletPubKeyHash,\n        bytes redeemerOutputScript\n    );\n\n    event WalletMovingFunds(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event MovingFundsCommitmentSubmitted(\n        bytes20 walletPubKeyHash,\n        bytes20[] targetWallets,\n        address submitter\n    );\n\n    event MovingFundsCompleted(\n        bytes20 walletPubKeyHash,\n        bytes32 movingFundsTxHash\n    );\n\n    event MovingFundsTimedOut(bytes20 walletPubKeyHash);\n\n    event MovingFundsBelowDustReported(bytes20 walletPubKeyHash);\n\n    event NewWalletRequested();\n\n    event NewWalletRegistered(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletClosing(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletClosed(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletTerminated(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event FraudChallengeSubmitted(\n        bytes20 walletPubKeyHash,\n        bytes32 sighash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    );\n\n    event FraudChallengeDefeated(bytes20 walletPubKeyHash, bytes32 sighash);\n\n    event FraudChallengeDefeatTimedOut(\n        bytes20 walletPubKeyHash,\n        bytes32 sighash\n    );\n\n    event VaultStatusUpdated(address indexed vault, bool isTrusted);\n\n    event DepositParametersUpdated(\n        uint64 depositDustThreshold,\n        uint64 depositTreasuryFeeDivisor,\n        uint64 depositTxMaxFee\n    );\n\n    event RedemptionParametersUpdated(\n        uint64 redemptionDustThreshold,\n        uint64 redemptionTreasuryFeeDivisor,\n        uint64 redemptionTxMaxFee,\n        uint256 redemptionTimeout,\n        uint96 redemptionTimeoutSlashingAmount,\n        uint256 redemptionTimeoutNotifierRewardMultiplier\n    );\n\n    event MovingFundsParametersUpdated(\n        uint64 movingFundsTxMaxTotalFee,\n        uint64 movingFundsDustThreshold,\n        uint32 movingFundsTimeout,\n        uint96 movingFundsTimeoutSlashingAmount,\n        uint256 movingFundsTimeoutNotifierRewardMultiplier\n    );\n\n    event WalletParametersUpdated(\n        uint32 walletCreationPeriod,\n        uint64 walletCreationMinBtcBalance,\n        uint64 walletCreationMaxBtcBalance,\n        uint64 walletClosureMinBtcBalance,\n        uint32 walletMaxAge,\n        uint64 walletMaxBtcTransfer,\n        uint32 walletClosingPeriod\n    );\n\n    event FraudParametersUpdated(\n        uint256 fraudChallengeDepositAmount,\n        uint256 fraudChallengeDefeatTimeout,\n        uint96 fraudSlashingAmount,\n        uint256 fraudNotifierRewardMultiplier\n    );\n\n    constructor(\n        address _bank,\n        address _relay,\n        address _treasury,\n        address _ecdsaWalletRegistry,\n        uint256 _txProofDifficultyFactor\n    ) {\n        require(_bank != address(0), \"Bank address cannot be zero\");\n        self.bank = Bank(_bank);\n\n        require(_relay != address(0), \"Relay address cannot be zero\");\n        self.relay = IRelay(_relay);\n\n        require(\n            _ecdsaWalletRegistry != address(0),\n            \"ECDSA Wallet Registry address cannot be zero\"\n        );\n        self.ecdsaWalletRegistry = EcdsaWalletRegistry(_ecdsaWalletRegistry);\n\n        require(_treasury != address(0), \"Treasury address cannot be zero\");\n        self.treasury = _treasury;\n\n        self.txProofDifficultyFactor = _txProofDifficultyFactor;\n\n        // TODO: Revisit initial values.\n        self.depositDustThreshold = 1000000; // 1000000 satoshi = 0.01 BTC\n        self.depositTxMaxFee = 10000; // 10000 satoshi\n        self.depositTreasuryFeeDivisor = 2000; // 1/2000 == 5bps == 0.05% == 0.0005\n        self.redemptionDustThreshold = 1000000; // 1000000 satoshi = 0.01 BTC\n        self.redemptionTreasuryFeeDivisor = 2000; // 1/2000 == 5bps == 0.05% == 0.0005\n        self.redemptionTxMaxFee = 10000; // 10000 satoshi\n        self.redemptionTimeout = 172800; // 48 hours\n        self.redemptionTimeoutSlashingAmount = 10000 * 1e18; // 10000 T\n        self.redemptionTimeoutNotifierRewardMultiplier = 100; // 100%\n        self.movingFundsTxMaxTotalFee = 10000; // 10000 satoshi\n        self.movingFundsDustThreshold = 20000; // 20000 satoshi\n        self.movingFundsTimeout = 7 days;\n        self.movingFundsTimeoutSlashingAmount = 10000 * 1e18; // 10000 T\n        self.movingFundsTimeoutNotifierRewardMultiplier = 100; //100%\n        self.fraudChallengeDepositAmount = 2 ether;\n        self.fraudChallengeDefeatTimeout = 7 days;\n        self.fraudSlashingAmount = 10000 * 1e18; // 10000 T\n        self.fraudNotifierRewardMultiplier = 100; // 100%\n        self.walletCreationPeriod = 1 weeks;\n        self.walletCreationMinBtcBalance = 1e8; // 1 BTC\n        self.walletCreationMaxBtcBalance = 100e8; // 100 BTC\n        self.walletClosureMinBtcBalance = 5 * 1e7; // 0.5 BTC\n        self.walletMaxAge = 26 weeks; // ~6 months\n        self.walletMaxBtcTransfer = 10e8; // 10 BTC\n        self.walletClosingPeriod = 40 days;\n\n        _transferGovernance(msg.sender);\n    }\n\n    /// @notice Used by the depositor to reveal information about their P2(W)SH\n    ///         Bitcoin deposit to the Bridge on Ethereum chain. The off-chain\n    ///         wallet listens for revealed deposit events and may decide to\n    ///         include the revealed deposit in the next executed sweep.\n    ///         Information about the Bitcoin deposit can be revealed before or\n    ///         after the Bitcoin transaction with P2(W)SH deposit is mined on\n    ///         the Bitcoin chain. Worth noting, the gas cost of this function\n    ///         scales with the number of P2(W)SH transaction inputs and\n    ///         outputs. The deposit may be routed to one of the trusted vaults.\n    ///         When a deposit is routed to a vault, vault gets notified when\n    ///         the deposit gets swept and it may execute the appropriate action.\n    /// @param fundingTx Bitcoin funding transaction data, see `BitcoinTx.Info`\n    /// @param reveal Deposit reveal data, see `RevealInfo struct\n    /// @dev Requirements:\n    ///      - `reveal.walletPubKeyHash` must identify a `Live` wallet\n    ///      - `reveal.vault` must be 0x0 or point to a trusted vault\n    ///      - `reveal.fundingOutputIndex` must point to the actual P2(W)SH\n    ///        output of the BTC deposit transaction\n    ///      - `reveal.depositor` must be the Ethereum address used in the\n    ///        P2(W)SH BTC deposit transaction,\n    ///      - `reveal.blindingFactor` must be the blinding factor used in the\n    ///        P2(W)SH BTC deposit transaction,\n    ///      - `reveal.walletPubKeyHash` must be the wallet pub key hash used in\n    ///        the P2(W)SH BTC deposit transaction,\n    ///      - `reveal.refundPubKeyHash` must be the refund pub key hash used in\n    ///        the P2(W)SH BTC deposit transaction,\n    ///      - `reveal.refundLocktime` must be the refund locktime used in the\n    ///        P2(W)SH BTC deposit transaction,\n    ///      - BTC deposit for the given `fundingTxHash`, `fundingOutputIndex`\n    ///        can be revealed only one time.\n    ///\n    ///      If any of these requirements is not met, the wallet _must_ refuse\n    ///      to sweep the deposit and the depositor has to wait until the\n    ///      deposit script unlocks to receive their BTC back.\n    function revealDeposit(\n        BitcoinTx.Info calldata fundingTx,\n        Deposit.DepositRevealInfo calldata reveal\n    ) external {\n        self.revealDeposit(fundingTx, reveal);\n    }\n\n    /// @notice Used by the wallet to prove the BTC deposit sweep transaction\n    ///         and to update Bank balances accordingly. Sweep is only accepted\n    ///         if it satisfies SPV proof.\n    ///\n    ///         The function is performing Bank balance updates by first\n    ///         computing the Bitcoin fee for the sweep transaction. The fee is\n    ///         divided evenly between all swept deposits. Each depositor\n    ///         receives a balance in the bank equal to the amount inferred\n    ///         during the reveal transaction, minus their fee share.\n    ///\n    ///         It is possible to prove the given sweep only one time.\n    /// @param sweepTx Bitcoin sweep transaction data\n    /// @param sweepProof Bitcoin sweep proof data\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain. If no main UTXO exists for the given wallet,\n    ///        this parameter is ignored\n    /// @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    ///      - `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 submitSweepProof(\n        BitcoinTx.Info calldata sweepTx,\n        BitcoinTx.Proof calldata sweepProof,\n        BitcoinTx.UTXO calldata mainUtxo\n    ) external {\n        self.submitSweepProof(sweepTx, sweepProof, mainUtxo);\n    }\n\n    /// @notice Requests redemption of the given amount from the specified\n    ///         wallet to the redeemer Bitcoin output script.\n    /// @param walletPubKeyHash The 20-byte wallet public key hash (computed\n    ///        using Bitcoin HASH160 over the compressed ECDSA public key)\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain\n    /// @param redeemerOutputScript The redeemer's length-prefixed output\n    ///        script (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock\n    ///        redeemed BTC\n    /// @param amount Requested amount in satoshi. This is also the TBTC amount\n    ///        that is taken from redeemer's balance in the Bank upon request.\n    ///        Once the request is handled, the actual amount of BTC locked\n    ///        on the redeemer output script will be always lower than this value\n    ///        since the treasury and Bitcoin transaction fees must be incurred.\n    ///        The minimal amount satisfying the request can be computed as:\n    ///        `amount - (amount / redemptionTreasuryFeeDivisor) - redemptionTxMaxFee`.\n    ///        Fees values are taken at the moment of request creation.\n    /// @dev Requirements:\n    ///      - Wallet behind `walletPubKeyHash` must be live\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///      - `redeemerOutputScript` must be a proper Bitcoin script\n    ///      - `redeemerOutputScript` cannot have wallet PKH as payload\n    ///      - `amount` must be above or equal the `redemptionDustThreshold`\n    ///      - Given `walletPubKeyHash` and `redeemerOutputScript` pair can be\n    ///        used for only one pending request at the same time\n    ///      - Wallet must have enough Bitcoin balance to proceed the request\n    ///      - Redeemer must make an allowance in the Bank that the Bridge\n    ///        contract can spend the given `amount`.\n    function requestRedemption(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata mainUtxo,\n        bytes calldata redeemerOutputScript,\n        uint64 amount\n    ) external {\n        self.requestRedemption(\n            walletPubKeyHash,\n            mainUtxo,\n            redeemerOutputScript,\n            amount\n        );\n    }\n\n    /// @notice Used by the wallet to prove the BTC redemption transaction\n    ///         and to make the necessary bookkeeping. Redemption is only\n    ///         accepted if it satisfies SPV proof.\n    ///\n    ///         The function is performing Bank balance updates by burning\n    ///         the total redeemed Bitcoin amount from Bridge balance and\n    ///         transferring the treasury fee sum to the treasury address.\n    ///\n    ///         It is possible to prove the given redemption only one time.\n    /// @param redemptionTx Bitcoin redemption transaction data\n    /// @param redemptionProof Bitcoin redemption proof data\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    ///        HASH160 over the compressed ECDSA public key) of the wallet which\n    ///        performed the redemption transaction\n    /// @dev Requirements:\n    ///      - `redemptionTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash.\n    ///      - The `redemptionTx` should represent a Bitcoin transaction with\n    ///        exactly 1 input that refers to the wallet's main UTXO. That\n    ///        transaction should have 1..n outputs handling existing pending\n    ///        redemption requests or pointing to reported timed out requests.\n    ///        There can be also 1 optional output representing the\n    ///        change and pointing back to the 20-byte wallet public key hash.\n    ///        The change should be always present if the redeemed value sum\n    ///        is lower than the total wallet's BTC balance.\n    ///      - `redemptionProof` components must match the expected structure.\n    ///        See `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant.\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        Additionally, the recent main UTXO on Ethereum must be set.\n    ///      - `walletPubKeyHash` must be connected with the main UTXO used\n    ///        as transaction single input.\n    ///      Other remarks:\n    ///      - Putting the change output as the first transaction output can\n    ///        save some gas because the output processing loop begins each\n    ///        iteration by checking whether the given output is the change\n    ///        thus uses some gas for making the comparison. Once the change\n    ///        is identified, that check is omitted in further iterations.\n    function submitRedemptionProof(\n        BitcoinTx.Info calldata redemptionTx,\n        BitcoinTx.Proof calldata redemptionProof,\n        BitcoinTx.UTXO calldata mainUtxo,\n        bytes20 walletPubKeyHash\n    ) external {\n        self.submitRedemptionProof(\n            redemptionTx,\n            redemptionProof,\n            mainUtxo,\n            walletPubKeyHash\n        );\n    }\n\n    /// @notice Notifies that there is a pending redemption request associated\n    ///         with the given wallet, that has timed out. The redemption\n    ///         request is identified by the key built as\n    ///         `keccak256(walletPubKeyHash | redeemerOutputScript)`.\n    ///         The results of calling this function:\n    ///         - the pending redemptions value for the wallet will be decreased\n    ///           by the requested amount (minus treasury fee),\n    ///         - the tokens taken from the redeemer on redemption request will\n    ///           be returned to the redeemer,\n    ///         - the request will be moved from pending redemptions to\n    ///           timed-out redemptions,\n    ///         - if the state of the wallet is `Live` or `MovingFunds`, the\n    ///           wallet operators will be slashed and the notifier will be\n    ///           rewarded,\n    ///         - if the state of wallet is `Live`, the wallet will be closed or\n    ///           marked as `MovingFunds` (depending on the presence or absence\n    ///           of the wallet's main UTXO) and the wallet will no longer be\n    ///           marked as the active wallet (if it was marked as such).\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param walletMembersIDs Identifiers of the wallet signing group members\n    /// @param redeemerOutputScript  The redeemer's length-prefixed output\n    ///        script (P2PKH, P2WPKH, P2SH or P2WSH)\n    /// @dev Requirements:\n    ///      - The wallet must be in the Live or MovingFunds or Terminated state\n    ///      - The redemption request identified by `walletPubKeyHash` and\n    ///        `redeemerOutputScript` must exist\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract\n    ///      - The amount of time defined by `redemptionTimeout` must have\n    ///        passed since the redemption was requested (the request must be\n    ///        timed-out)\n    function notifyRedemptionTimeout(\n        bytes20 walletPubKeyHash,\n        uint32[] calldata walletMembersIDs,\n        bytes calldata redeemerOutputScript\n    ) external {\n        self.notifyRedemptionTimeout(\n            walletPubKeyHash,\n            walletMembersIDs,\n            redeemerOutputScript\n        );\n    }\n\n    /// @notice Submits the moving funds target wallets commitment.\n    ///         Once all requirements are met, that function registers the\n    ///         target wallets commitment and opens the way for moving funds\n    ///         proof submission.\n    /// @param walletPubKeyHash 20-byte public key hash of the source wallet\n    /// @param walletMainUtxo Data of the source wallet's main UTXO, as\n    ///        currently known on the Ethereum chain\n    /// @param walletMembersIDs Identifiers of the source wallet signing group\n    ///        members\n    /// @param walletMemberIndex Position of the caller in the source wallet\n    ///        signing group members list\n    /// @param targetWallets List of 20-byte public key hashes of the target\n    ///        wallets that the source wallet commits to move the funds to\n    /// @dev Requirements:\n    ///      - The source wallet must be in the MovingFunds state\n    ///      - The source wallet must not have pending redemption requests\n    ///      - The source wallet must not have submitted its commitment already\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given source wallet in the ECDSA registry. Those IDs are\n    ///        not directly stored in the contract for gas efficiency purposes\n    ///        but they can be read from appropriate `DkgResultSubmitted`\n    ///        and `DkgResultApproved` events.\n    ///      - The `walletMemberIndex` must be in range [1, walletMembersIDs.length]\n    ///      - The caller must be the member of the source wallet signing group\n    ///        at the position indicated by `walletMemberIndex` parameter\n    ///      - The `walletMainUtxo` components must point to the recent main\n    ///        UTXO of the source wallet, as currently known on the Ethereum\n    ///        chain.\n    ///      - Source wallet BTC balance must be greater than zero\n    ///      - At least one Live wallet must exist in the system\n    ///      - Submitted target wallets count must match the expected count\n    ///        `N = min(liveWalletsCount, ceil(walletBtcBalance / walletMaxBtcTransfer))`\n    ///        where `N > 0`\n    ///      - Each target wallet must be not equal to the source wallet\n    ///      - Each target wallet must follow the expected order i.e. all\n    ///        target wallets 20-byte public key hashes represented as numbers\n    ///        must form a strictly increasing sequence without duplicates.\n    ///      - Each target wallet must be in Live state\n    function submitMovingFundsCommitment(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata walletMainUtxo,\n        uint32[] calldata walletMembersIDs,\n        uint256 walletMemberIndex,\n        bytes20[] calldata targetWallets\n    ) external {\n        self.submitMovingFundsCommitment(\n            walletPubKeyHash,\n            walletMainUtxo,\n            walletMembersIDs,\n            walletMemberIndex,\n            targetWallets\n        );\n    }\n\n    /// @notice Used by the wallet to prove the BTC moving funds transaction\n    ///         and to make the necessary state changes. Moving funds is only\n    ///         accepted if it satisfies SPV proof.\n    ///\n    ///         The function validates the moving funds transaction structure\n    ///         by checking if it actually spends the main UTXO of the declared\n    ///         wallet and locks the value on the pre-committed target wallets\n    ///         using a reasonable transaction fee. If all preconditions are\n    ///         met, this functions closes the source wallet.\n    ///\n    ///         It is possible to prove the given moving funds transaction only\n    ///         one time.\n    /// @param movingFundsTx Bitcoin moving funds transaction data\n    /// @param movingFundsProof Bitcoin moving funds proof data\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    ///        HASH160 over the compressed ECDSA public key) of the wallet\n    ///        which performed the moving funds transaction\n    /// @dev Requirements:\n    ///      - `movingFundsTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash.\n    ///      - The `movingFundsTx` should represent a Bitcoin transaction with\n    ///        exactly 1 input that refers to the wallet's main UTXO. That\n    ///        transaction should have 1..n outputs corresponding to the\n    ///        pre-committed target wallets. Outputs must be ordered in the\n    ///        same way as their corresponding target wallets are ordered\n    ///        within the target wallets commitment.\n    ///      - `movingFundsProof` components must match the expected structure.\n    ///        See `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant.\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        Additionally, the recent main UTXO on Ethereum must be set.\n    ///      - `walletPubKeyHash` must be connected with the main UTXO used\n    ///        as transaction single input.\n    ///      - The wallet that `walletPubKeyHash` points to must be in the\n    ///        MovingFunds state.\n    ///      - The target wallets commitment must be submitted by the wallet\n    ///        that `walletPubKeyHash` points to.\n    ///      - The total Bitcoin transaction fee must be lesser or equal\n    ///        to `movingFundsTxMaxTotalFee` governable parameter.\n    function submitMovingFundsProof(\n        BitcoinTx.Info calldata movingFundsTx,\n        BitcoinTx.Proof calldata movingFundsProof,\n        BitcoinTx.UTXO calldata mainUtxo,\n        bytes20 walletPubKeyHash\n    ) external {\n        self.submitMovingFundsProof(\n            movingFundsTx,\n            movingFundsProof,\n            mainUtxo,\n            walletPubKeyHash\n        );\n    }\n\n    /// @notice Notifies about a timed out moving funds process. Terminates\n    ///         the wallet and slashes signing group members as a result.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param walletMembersIDs Identifiers of the wallet signing group members\n    /// @dev Requirements:\n    ///      - The wallet must be in the MovingFunds state\n    ///      - The moving funds timeout must be actually exceeded\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract\n    function notifyMovingFundsTimeout(\n        bytes20 walletPubKeyHash,\n        uint32[] calldata walletMembersIDs\n    ) external {\n        self.notifyMovingFundsTimeout(walletPubKeyHash, walletMembersIDs);\n    }\n\n    /// @notice Notifies about a moving funds wallet whose BTC balance is\n    ///         below the moving funds dust threshold. Ends the moving funds\n    ///         process and begins wallet closing immediately.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known\n    ///        on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - The wallet must be in the MovingFunds state\n    ///      - The `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        If the wallet has no main UTXO, this parameter can be empty as it\n    ///        is ignored.\n    ///      - The wallet BTC balance must be below the moving funds threshold\n    function notifyMovingFundsBelowDust(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata mainUtxo\n    ) external {\n        self.notifyMovingFundsBelowDust(walletPubKeyHash, mainUtxo);\n    }\n\n    /// @notice Requests creation of a new wallet. This function just\n    ///         forms a request and the creation process is performed\n    ///         asynchronously. Once a wallet is created, the ECDSA Wallet\n    ///         Registry will notify this contract by calling the\n    ///         `__ecdsaWalletCreatedCallback` function.\n    /// @param activeWalletMainUtxo Data of the active wallet's main UTXO, as\n    ///        currently known on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - `activeWalletMainUtxo` components must point to the recent main\n    ///        UTXO of the given active wallet, as currently known on the\n    ///        Ethereum chain. If there is no active wallet at the moment, or\n    ///        the active wallet has no main UTXO, this parameter can be\n    ///        empty as it is ignored.\n    ///      - Wallet creation must not be in progress\n    ///      - If the active wallet is set, one of the following\n    ///        conditions must be true:\n    ///        - The active wallet BTC balance is above the minimum threshold\n    ///          and the active wallet is old enough, i.e. the creation period\n    ///          was elapsed since its creation time\n    ///        - The active wallet BTC balance is above the maximum threshold\n    function requestNewWallet(BitcoinTx.UTXO calldata activeWalletMainUtxo)\n        external\n    {\n        self.requestNewWallet(activeWalletMainUtxo);\n    }\n\n    /// @notice A callback function that is called by the ECDSA Wallet Registry\n    ///         once a new ECDSA wallet is created.\n    /// @param ecdsaWalletID Wallet's unique identifier.\n    /// @param publicKeyX Wallet's public key's X coordinate.\n    /// @param publicKeyY Wallet's public key's Y coordinate.\n    /// @dev Requirements:\n    ///      - The only caller authorized to call this function is `registry`\n    ///      - Given wallet data must not belong to an already registered wallet\n    function __ecdsaWalletCreatedCallback(\n        bytes32 ecdsaWalletID,\n        bytes32 publicKeyX,\n        bytes32 publicKeyY\n    ) external override {\n        self.registerNewWallet(ecdsaWalletID, publicKeyX, publicKeyY);\n    }\n\n    /// @notice A callback function that is called by the ECDSA Wallet Registry\n    ///         once a wallet heartbeat failure is detected.\n    /// @param publicKeyX Wallet's public key's X coordinate\n    /// @param publicKeyY Wallet's public key's Y coordinate\n    /// @dev Requirements:\n    ///      - The only caller authorized to call this function is `registry`\n    ///      - Wallet must be in Live state\n    function __ecdsaWalletHeartbeatFailedCallback(\n        bytes32,\n        bytes32 publicKeyX,\n        bytes32 publicKeyY\n    ) external override {\n        self.notifyWalletHeartbeatFailed(publicKeyX, publicKeyY);\n    }\n\n    /// @notice Notifies that the wallet is either old enough or has too few\n    ///         satoshi left and qualifies to be closed.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param walletMainUtxo Data of the wallet's main UTXO, as currently\n    ///        known on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - Wallet must not be set as the current active wallet\n    ///      - Wallet must exceed the wallet maximum age OR the wallet BTC\n    ///        balance must be lesser than the minimum threshold. If the latter\n    ///        case is true, the `walletMainUtxo` components must point to the\n    ///        recent main UTXO of the given wallet, as currently known on the\n    ///        Ethereum chain. If the wallet has no main UTXO, this parameter\n    ///        can be empty as it is ignored since the wallet balance is\n    ///        assumed to be zero.\n    ///      - Wallet must be in Live state\n    function notifyCloseableWallet(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata walletMainUtxo\n    ) external {\n        self.notifyCloseableWallet(walletPubKeyHash, walletMainUtxo);\n    }\n\n    /// @notice Notifies about the end of the closing period for the given wallet.\n    ///         Closes the wallet ultimately and notifies the ECDSA registry\n    ///         about this fact.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @dev Requirements:\n    ///      - The wallet must be in the Closing state\n    ///      - The wallet closing period must have elapsed\n    function notifyWalletClosingPeriodElapsed(bytes20 walletPubKeyHash)\n        external\n    {\n        self.notifyWalletClosingPeriodElapsed(walletPubKeyHash);\n    }\n\n    /// @notice Submits a fraud challenge indicating that a UTXO being under\n    ///         wallet control was unlocked by the wallet but was not used\n    ///         according to the protocol rules. That means the wallet signed\n    ///         a transaction input pointing to that UTXO and there is a unique\n    ///         sighash and signature pair associated with that input. This\n    ///         function uses those parameters to create a fraud accusation that\n    ///         proves a given transaction input unlocking the given UTXO was\n    ///         actually signed by the wallet. This function cannot determine\n    ///         whether the transaction was actually broadcast and the input was\n    ///         consumed in a fraudulent way so it just opens a challenge period\n    ///         during which the wallet can defeat the challenge by submitting\n    ///         proof of a transaction that consumes the given input according\n    ///         to protocol rules. To prevent spurious allegations, the caller\n    ///         must deposit ETH that is returned back upon justified fraud\n    ///         challenge or confiscated otherwise.\n    ///@param walletPublicKey The public key of the wallet in the uncompressed\n    ///       and unprefixed format (64 bytes)\n    /// @param sighash The hash that was used to produce the ECDSA signature\n    ///        that is the subject of the fraud claim. This hash is constructed\n    ///        by applying double SHA-256 over a serialized subset of the\n    ///        transaction. The exact subset used as hash preimage depends on\n    ///        the transaction input the signature is produced for. See BIP-143\n    ///        for reference\n    /// @param signature Bitcoin signature in the R/S/V format\n    /// @dev Requirements:\n    ///      - Wallet behind `walletPublicKey` must be in Live or MovingFunds\n    ///        or Closing state\n    ///      - The challenger must send appropriate amount of ETH used as\n    ///        fraud challenge deposit\n    ///      - The signature (represented by r, s and v) must be generated by\n    ///        the wallet behind `walletPubKey` during signing of `sighash`\n    ///      - Wallet can be challenged for the given signature only once\n    function submitFraudChallenge(\n        bytes calldata walletPublicKey,\n        bytes32 sighash,\n        BitcoinTx.RSVSignature calldata signature\n    ) external payable {\n        self.submitFraudChallenge(walletPublicKey, sighash, signature);\n    }\n\n    /// @notice Allows to defeat a pending fraud challenge against a wallet if\n    ///         the transaction that spends the UTXO follows the protocol rules.\n    ///         In order to defeat the challenge the same `walletPublicKey` and\n    ///         signature (represented by `r`, `s` and `v`) must be provided as\n    ///         were used to calculate the sighash during input signing.\n    ///         The fraud challenge defeat attempt will only succeed if the\n    ///         inputs in the preimage are considered honestly spent by the\n    ///         wallet. Therefore the transaction spending the UTXO must be\n    ///         proven in the Bridge before a challenge defeat is called.\n    ///         If successfully defeated, the fraud challenge is marked as\n    ///         resolved and the amount of ether deposited by the challenger is\n    ///         sent to the treasury.\n    /// @param walletPublicKey The public key of the wallet in the uncompressed\n    ///        and unprefixed format (64 bytes)\n    /// @param preimage The preimage which produces sighash used to generate the\n    ///        ECDSA signature that is the subject of the fraud claim. It is a\n    ///        serialized subset of the transaction. The exact subset used as\n    ///        the preimage depends on the transaction input the signature is\n    ///        produced for. See BIP-143 for reference\n    /// @param witness Flag indicating whether the preimage was produced for a\n    ///        witness input. True for witness, false for non-witness input\n    /// @dev Requirements:\n    ///      - `walletPublicKey` and `sighash` calculated as `hash256(preimage)`\n    ///        must identify an open fraud challenge\n    ///      - the preimage must be a valid preimage of a transaction generated\n    ///        according to the protocol rules and already proved in the Bridge\n    ///      - before a defeat attempt is made the transaction that spends the\n    ///        given UTXO must be proven in the Bridge\n    function defeatFraudChallenge(\n        bytes calldata walletPublicKey,\n        bytes calldata preimage,\n        bool witness\n    ) external {\n        self.defeatFraudChallenge(walletPublicKey, preimage, witness);\n    }\n\n    /// @notice Notifies about defeat timeout for the given fraud challenge.\n    ///         Can be called only if there was a fraud challenge identified by\n    ///         the provided `walletPublicKey` and `sighash` and it was not\n    ///         defeated on time. The amount of time that needs to pass after\n    ///         a fraud challenge is reported is indicated by the\n    ///         `challengeDefeatTimeout`. After a successful fraud challenge\n    ///         defeat timeout notification the fraud challenge is marked as\n    ///         resolved, the stake of each operator is slashed, the ether\n    ///         deposited is returned to the challenger and the challenger is\n    ///         rewarded.\n    /// @param walletPublicKey The public key of the wallet in the uncompressed\n    ///        and unprefixed format (64 bytes)\n    /// @param walletMembersIDs Identifiers of the wallet signing group members\n    /// @param sighash The hash that was used to produce the ECDSA signature\n    ///        that is the subject of the fraud claim. This hash is constructed\n    ///        by applying double SHA-256 over a serialized subset of the\n    ///        transaction. The exact subset used as hash preimage depends on\n    ///        the transaction input the signature is produced for. See BIP-143\n    ///        for reference\n    /// @dev Requirements:\n    ///      - The wallet must be in the Live or MovingFunds or Closing or\n    ///        Terminated state\n    ///      - The `walletPublicKey` and `sighash` must identify an open fraud\n    ///        challenge\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract\n    ///      - The amount of time indicated by `challengeDefeatTimeout` must pass\n    ///        after the challenge was reported\n    function notifyFraudChallengeDefeatTimeout(\n        bytes calldata walletPublicKey,\n        uint32[] calldata walletMembersIDs,\n        bytes32 sighash\n    ) external {\n        self.notifyFraudChallengeDefeatTimeout(\n            walletPublicKey,\n            walletMembersIDs,\n            sighash\n        );\n    }\n\n    /// @notice Allows the Governance to mark the given vault address as trusted\n    ///         or no longer trusted. Vaults are not trusted by default.\n    ///         Trusted vault must meet the following criteria:\n    ///         - `IVault.receiveBalanceIncrease` must have a known, low gas\n    ///           cost.\n    ///         - `IVault.receiveBalanceIncrease` must never revert.\n    /// @dev Without restricting reveal only to trusted vaults, malicious\n    ///      vaults not meeting the criteria would be able to nuke sweep proof\n    ///      transactions executed by ECDSA wallet with  deposits routed to\n    ///      them.\n    /// @param vault The address of the vault\n    /// @param isTrusted flag indicating whether the vault is trusted or not\n    /// @dev Can only be called by the Governance.\n    function setVaultStatus(address vault, bool isTrusted)\n        external\n        onlyGovernance\n    {\n        self.isVaultTrusted[vault] = isTrusted;\n        emit VaultStatusUpdated(vault, isTrusted);\n    }\n\n    /// @notice Updates parameters of deposits.\n    /// @param depositDustThreshold New value of the deposit dust threshold in\n    ///        satoshis. It is the minimal amount that can be requested to\n    ////       deposit. Value of this parameter must take into account the value\n    ///        of `depositTreasuryFeeDivisor` and `depositTxMaxFee` parameters\n    ///        in order to make requests that can incur the treasury and\n    ///        transaction fee and still satisfy the depositor\n    /// @param depositTreasuryFeeDivisor New value of the treasury fee divisor.\n    ///        It is the divisor used to compute the treasury fee taken from\n    ///        each deposit and transferred to the treasury upon sweep proof\n    ///        submission. That fee is computed as follows:\n    ///        `treasuryFee = depositedAmount / depositTreasuryFeeDivisor`\n    ///        For example, if the treasury fee needs to be 2% of each deposit,\n    ///        the `depositTreasuryFeeDivisor` should be set to `50`\n    ///        because `1/50 = 0.02 = 2%`\n    /// @param depositTxMaxFee New value of the deposit tx max fee in satoshis.\n    ///        It is the maximum amount of BTC transaction fee that can\n    ///        be incurred by each swept deposit being part of the given sweep\n    ///        transaction. If the maximum BTC transaction fee is exceeded,\n    ///        such transaction is considered a fraud\n    /// @dev Requirements:\n    ///      - Deposit dust threshold must be greater than zero\n    ///      - Deposit treasury fee divisor must be greater than zero\n    ///      - Deposit transaction max fee must be greater than zero\n    function updateDepositParameters(\n        uint64 depositDustThreshold,\n        uint64 depositTreasuryFeeDivisor,\n        uint64 depositTxMaxFee\n    ) external onlyGovernance {\n        self.updateDepositParameters(\n            depositDustThreshold,\n            depositTreasuryFeeDivisor,\n            depositTxMaxFee\n        );\n    }\n\n    /// @notice Updates parameters of redemptions.\n    /// @param redemptionDustThreshold New value of the redemption dust\n    ///        threshold in satoshis. It is the minimal amount that can be\n    ///        requested for redemption. Value of this parameter must take into\n    ///        account the value of `redemptionTreasuryFeeDivisor` and\n    ///        `redemptionTxMaxFee` parameters in order to make requests that\n    ///        can incur the treasury and transaction fee and still satisfy the\n    ///        redeemer.\n    /// @param redemptionTreasuryFeeDivisor New value of the redemption\n    ///        treasury fee divisor. It is the divisor used to compute the\n    ///        treasury fee taken from each redemption request and transferred\n    ///        to the treasury upon successful request finalization. That fee is\n    ///        computed as follows:\n    ///        `treasuryFee = requestedAmount / redemptionTreasuryFeeDivisor`\n    ///        For example, if the treasury fee needs to be 2% of each\n    ///        redemption request, the `redemptionTreasuryFeeDivisor` should\n    ///        be set to `50` because `1/50 = 0.02 = 2%`.\n    /// @param redemptionTxMaxFee New value of the redemption transaction max\n    ///        fee in satoshis. It is the maximum amount of BTC transaction fee\n    ///        that can be incurred by each redemption request being part of the\n    ///        given redemption transaction. If the maximum BTC transaction fee\n    ///        is exceeded, such transaction is considered a fraud.\n    ///        This is a per-redemption output max fee for the redemption\n    ///        transaction.\n    /// @param redemptionTimeout New value of the redemption timeout in seconds.\n    ///        It is the time after which the redemption request can be reported\n    ///        as timed out. It is counted from the moment when the redemption\n    ///        request was created via `requestRedemption` call. Reported  timed\n    ///        out requests are cancelled and locked TBTC is returned to the\n    ///        redeemer in full amount.\n    /// @param redemptionTimeoutSlashingAmount New value of the redemption\n    ///        timeout slashing amount in T, it is the amount slashed from each\n    ///        wallet member for redemption timeout\n    /// @param redemptionTimeoutNotifierRewardMultiplier New value of the\n    ///        redemption timeout notifier reward multiplier as percentage,\n    ///        it determines the percentage of the notifier reward from the\n    ///        staking contact the notifier of a redemption timeout receives.\n    ///        The value must be in the range [0, 100]\n    /// @dev Requirements:\n    ///      - Redemption dust threshold must be greater than zero\n    ///      - Redemption treasury fee divisor must be greater than zero\n    ///      - Redemption transaction max fee must be greater than zero\n    ///      - Redemption timeout must be greater than zero\n    ///      - Redemption timeout notifier reward multiplier must be in the\n    ///        range [0, 100]\n    function updateRedemptionParameters(\n        uint64 redemptionDustThreshold,\n        uint64 redemptionTreasuryFeeDivisor,\n        uint64 redemptionTxMaxFee,\n        uint256 redemptionTimeout,\n        uint96 redemptionTimeoutSlashingAmount,\n        uint256 redemptionTimeoutNotifierRewardMultiplier\n    ) external onlyGovernance {\n        self.updateRedemptionParameters(\n            redemptionDustThreshold,\n            redemptionTreasuryFeeDivisor,\n            redemptionTxMaxFee,\n            redemptionTimeout,\n            redemptionTimeoutSlashingAmount,\n            redemptionTimeoutNotifierRewardMultiplier\n        );\n    }\n\n    /// @notice Updates parameters of moving funds.\n    /// @param movingFundsTxMaxTotalFee New value of the moving funds transaction\n    ///        max total fee in satoshis. It is the maximum amount of the total\n    ///        BTC transaction fee that is acceptable in a single moving funds\n    ///        transaction. This is a _total_ max fee for the entire moving\n    ///        funds transaction.\n    /// @param movingFundsDustThreshold New value of the moving funds dust\n    ///        threshold. It is the minimal satoshi amount that makes sense to\n    //         be transferred during the moving funds process. Moving funds\n    //         wallets having their BTC balance below that value can begin\n    //         closing immediately as transferring such a low value may not be\n    //         possible due to BTC network fees.\n    /// @param movingFundsTimeout New value of the moving funds timeout in\n    ///        seconds. It is the time after which the moving funds process can\n    ///        be reported as timed out. It is counted from the moment when the\n    ///        wallet was requested to move their funds and switched to the\n    ///        MovingFunds state.\n    /// @param movingFundsTimeoutSlashingAmount New value of the moving funds\n    ///        timeout slashing amount in T, it is the amount slashed from each\n    ///        wallet member for moving funds timeout\n    /// @param movingFundsTimeoutNotifierRewardMultiplier New value of the\n    ///        moving funds timeout notifier reward multiplier as percentage,\n    ///        it determines the percentage of the notifier reward from the\n    ///        staking contact the notifier of a moving funds timeout receives.\n    ///        The value must be in the range [0, 100]\n    /// @dev Requirements:\n    ///      - Moving funds transaction max total fee must be greater than zero\n    ///      - Moving funds dust threshold must be greater than zero\n    ///      - Moving funds timeout must be greater than zero\n    ///      - Moving funds timeout notifier reward multiplier must be in the\n    ///        range [0, 100]\n    function updateMovingFundsParameters(\n        uint64 movingFundsTxMaxTotalFee,\n        uint64 movingFundsDustThreshold,\n        uint32 movingFundsTimeout,\n        uint96 movingFundsTimeoutSlashingAmount,\n        uint256 movingFundsTimeoutNotifierRewardMultiplier\n    ) external onlyGovernance {\n        self.updateMovingFundsParameters(\n            movingFundsTxMaxTotalFee,\n            movingFundsDustThreshold,\n            movingFundsTimeout,\n            movingFundsTimeoutSlashingAmount,\n            movingFundsTimeoutNotifierRewardMultiplier\n        );\n    }\n\n    /// @notice Updates parameters of wallets.\n    /// @param walletCreationPeriod New value of the wallet creation period in\n    ///        seconds, determines how frequently a new wallet creation can be\n    ///        requested\n    /// @param walletCreationMinBtcBalance New value of the wallet minimum BTC\n    ///        balance in satoshi, used to decide about wallet creation\n    /// @param walletCreationMaxBtcBalance New value of the wallet maximum BTC\n    ///        balance in satoshi, used to decide about wallet creation\n    /// @param walletClosureMinBtcBalance New value of the wallet minimum BTC\n    ///        balance in satoshi, used to decide about wallet closure\n    /// @param walletMaxAge New value of the wallet maximum age in seconds,\n    ///        indicates the maximum age of a wallet in seconds, after which\n    ///        the wallet moving funds process can be requested\n    /// @param walletMaxBtcTransfer New value of the wallet maximum BTC transfer\n    ///        in satoshi, determines the maximum amount that can be transferred\n    //         to a single target wallet during the moving funds process\n    /// @param walletClosingPeriod New value of the wallet closing period in\n    ///        seconds, determines the length of the wallet closing period,\n    //         i.e. the period when the wallet remains in the Closing state\n    //         and can be subject of deposit fraud challenges\n    /// @dev Requirements:\n    ///      - Wallet minimum BTC balance must be greater than zero\n    ///      - Wallet maximum BTC balance must be greater than the wallet\n    ///        minimum BTC balance\n    ///      - Wallet maximum BTC transfer must be greater than zero\n    ///      - Wallet closing period must be greater than zero\n    function updateWalletParameters(\n        uint32 walletCreationPeriod,\n        uint64 walletCreationMinBtcBalance,\n        uint64 walletCreationMaxBtcBalance,\n        uint64 walletClosureMinBtcBalance,\n        uint32 walletMaxAge,\n        uint64 walletMaxBtcTransfer,\n        uint32 walletClosingPeriod\n    ) external onlyGovernance {\n        self.updateWalletParameters(\n            walletCreationPeriod,\n            walletCreationMinBtcBalance,\n            walletCreationMaxBtcBalance,\n            walletClosureMinBtcBalance,\n            walletMaxAge,\n            walletMaxBtcTransfer,\n            walletClosingPeriod\n        );\n    }\n\n    /// @notice Updates parameters related to frauds.\n    /// @param fraudChallengeDepositAmount New value of the fraud challenge\n    ///        deposit amount in wei, it is the amount of ETH the party\n    ///        challenging the wallet for fraud needs to deposit\n    /// @param fraudChallengeDefeatTimeout New value of the challenge defeat\n    ///        timeout in seconds, it is the amount of time the wallet has to\n    ///        defeat a fraud challenge. The value must be greater than zero\n    /// @param fraudSlashingAmount New value of the fraud slashing amount in T,\n    ///        it is the amount slashed from each wallet member for committing\n    ///        a fraud\n    /// @param fraudNotifierRewardMultiplier New value of the fraud notifier\n    ///        reward multiplier as percentage, it determines the percentage of\n    ///        the notifier reward from the staking contact the notifier of\n    ///        a fraud receives. The value must be in the range [0, 100]\n    /// @dev Requirements:\n    ///      - Fraud challenge defeat timeout must be greater than 0\n    ///      - Fraud notifier reward multiplier must be in the range [0, 100]\n    function updateFraudParameters(\n        uint256 fraudChallengeDepositAmount,\n        uint256 fraudChallengeDefeatTimeout,\n        uint96 fraudSlashingAmount,\n        uint256 fraudNotifierRewardMultiplier\n    ) external onlyGovernance {\n        self.updateFraudParameters(\n            fraudChallengeDepositAmount,\n            fraudChallengeDefeatTimeout,\n            fraudSlashingAmount,\n            fraudNotifierRewardMultiplier\n        );\n    }\n\n    /// @notice Collection of all revealed deposits indexed by\n    ///         keccak256(fundingTxHash | fundingOutputIndex).\n    ///         The fundingTxHash is bytes32 (ordered as in Bitcoin internally)\n    ///         and fundingOutputIndex an uint32. This mapping may contain valid\n    ///         and invalid deposits and the wallet is responsible for\n    ///         validating them before attempting to execute a sweep.\n    function deposits(uint256 depositKey)\n        external\n        view\n        returns (Deposit.DepositRequest memory)\n    {\n        return self.deposits[depositKey];\n    }\n\n    /// @notice Collection of all pending redemption requests indexed by\n    ///         redemption key built as\n    ///         keccak256(walletPubKeyHash | redeemerOutputScript). The\n    ///         walletPubKeyHash is the 20-byte wallet's public key hash\n    ///         (computed using Bitcoin HASH160 over the compressed ECDSA\n    ///         public key) and redeemerOutputScript is a Bitcoin script\n    ///         (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock\n    ///         redeemed BTC as requested by the redeemer. Requests are added\n    ///         to this mapping by the `requestRedemption` method (duplicates\n    ///         not allowed) and are removed by one of the following methods:\n    ///         - `submitRedemptionProof` in case the request was handled\n    ///           successfully\n    ///         - `notifyRedemptionTimeout` in case the request was reported\n    ///           to be timed out\n    function pendingRedemptions(uint256 redemptionKey)\n        external\n        view\n        returns (Redemption.RedemptionRequest memory)\n    {\n        return self.pendingRedemptions[redemptionKey];\n    }\n\n    /// @notice Collection of all timed out redemptions requests indexed by\n    ///         redemption key built as\n    ///         keccak256(walletPubKeyHash | redeemerOutputScript). The\n    ///         walletPubKeyHash is the 20-byte wallet's public key hash\n    ///         (computed using Bitcoin HASH160 over the compressed ECDSA\n    ///         public key) and redeemerOutputScript is the Bitcoin script\n    ///         (P2PKH, P2WPKH, P2SH or P2WSH) that is involved in the timed\n    ///         out request. Timed out requests are stored in this mapping to\n    ///         avoid slashing the wallets multiple times for the same timeout.\n    ///         Only one method can add to this mapping:\n    ///         - `notifyRedemptionTimeout` which puts the redemption key\n    ///           to this mapping basing on a timed out request stored\n    ///           previously in `pendingRedemptions` mapping.\n    function timedOutRedemptions(uint256 redemptionKey)\n        external\n        view\n        returns (Redemption.RedemptionRequest memory)\n    {\n        return self.timedOutRedemptions[redemptionKey];\n    }\n\n    /// @notice Collection of main UTXOs that are honestly spent indexed by\n    ///         keccak256(fundingTxHash | fundingOutputIndex). The fundingTxHash\n    ///         is bytes32 (ordered as in Bitcoin internally) and\n    ///         fundingOutputIndex an uint32. A main UTXO is considered honestly\n    ///         spent if it was used as an input of a transaction that have been\n    ///         proven in the Bridge.\n    function spentMainUTXOs(uint256 utxoKey) external view returns (bool) {\n        return self.spentMainUTXOs[utxoKey];\n    }\n\n    /// @notice Gets details about a registered wallet.\n    /// @param walletPubKeyHash The 20-byte wallet public key hash (computed\n    ///        using Bitcoin HASH160 over the compressed ECDSA public key)\n    /// @return Wallet details.\n    function wallets(bytes20 walletPubKeyHash)\n        external\n        view\n        returns (Wallets.Wallet memory)\n    {\n        return self.registeredWallets[walletPubKeyHash];\n    }\n\n    /// @notice Gets the public key hash of the active wallet.\n    /// @return The 20-byte public key hash (computed using Bitcoin HASH160\n    ///         over the compressed ECDSA public key) of the active wallet.\n    ///         Returns bytes20(0) if there is no active wallet at the moment.\n    function activeWalletPubKeyHash() external view returns (bytes20) {\n        return self.activeWalletPubKeyHash;\n    }\n\n    /// @notice Gets the live wallets count.\n    /// @return The current count of wallets being in the Live state.\n    function liveWalletsCount() external view returns (uint32) {\n        return self.liveWalletsCount;\n    }\n\n    /// @notice Returns the fraud challenge identified by the given key built\n    ///         as keccak256(walletPublicKey|sighash).\n    function fraudChallenges(uint256 challengeKey)\n        external\n        view\n        returns (Fraud.FraudChallenge memory)\n    {\n        return self.fraudChallenges[challengeKey];\n    }\n\n    /// @notice Indicates if the vault with the given address is trusted or not.\n    ///         Depositors can route their revealed deposits only to trusted\n    ///         vaults and have trusted vaults notified about new deposits as\n    ///         soon as these deposits get swept. Vaults not trusted by the\n    ///         Bridge can still be used by Bank balance owners on their own\n    ///         responsibility - anyone can approve their Bank balance to any\n    ///         address.\n    function isVaultTrusted(address vault) external view returns (bool) {\n        return self.isVaultTrusted[vault];\n    }\n\n    /// @notice Returns the current values of Bridge deposit parameters.\n    /// @return depositDustThreshold The minimal amount that can be requested\n    ///         to deposit. Value of this parameter must take into account the\n    ///         value of `depositTreasuryFeeDivisor` and `depositTxMaxFee`\n    ///         parameters in order to make requests that can incur the\n    ///         treasury and transaction fee and still satisfy the depositor.\n    /// @return depositTreasuryFeeDivisor Divisor used to compute the treasury\n    ///         fee taken from each deposit and transferred to the treasury upon\n    ///         sweep proof submission. That fee is computed as follows:\n    ///         `treasuryFee = depositedAmount / depositTreasuryFeeDivisor`\n    ///         For example, if the treasury fee needs to be 2% of each deposit,\n    ///         the `depositTreasuryFeeDivisor` should be set to `50`\n    ///         because `1/50 = 0.02 = 2%`.\n    /// @return depositTxMaxFee Maximum amount of BTC transaction fee that can\n    ///         be incurred by each swept deposit being part of the given sweep\n    ///         transaction. If the maximum BTC transaction fee is exceeded,\n    ///         such transaction is considered a fraud.\n    function depositParameters()\n        external\n        view\n        returns (\n            uint64 depositDustThreshold,\n            uint64 depositTreasuryFeeDivisor,\n            uint64 depositTxMaxFee\n        )\n    {\n        depositDustThreshold = self.depositDustThreshold;\n        depositTreasuryFeeDivisor = self.depositTreasuryFeeDivisor;\n        depositTxMaxFee = self.depositTxMaxFee;\n    }\n\n    /// @notice Returns the current values of Bridge redemption parameters.\n    /// @return redemptionDustThreshold The minimal amount that can be requested\n    ///         for redemption. Value of this parameter must take into account\n    ///         the value of `redemptionTreasuryFeeDivisor` and `redemptionTxMaxFee`\n    ///         parameters in order to make requests that can incur the\n    ///         treasury and transaction fee and still satisfy the redeemer.\n    /// @return redemptionTreasuryFeeDivisor Divisor used to compute the treasury\n    ///         fee taken from each redemption request and transferred to the\n    ///         treasury upon successful request finalization. That fee is\n    ///         computed as follows:\n    ///         `treasuryFee = requestedAmount / redemptionTreasuryFeeDivisor`\n    ///         For example, if the treasury fee needs to be 2% of each\n    ///         redemption request, the `redemptionTreasuryFeeDivisor` should\n    ///         be set to `50` because `1/50 = 0.02 = 2%`.\n    /// @return redemptionTxMaxFee Maximum amount of BTC transaction fee that\n    ///         can be incurred by each redemption request being part of the\n    ///         given redemption transaction. If the maximum BTC transaction\n    ///         fee is exceeded, such transaction is considered a fraud.\n    ///         This is a per-redemption output max fee for the redemption\n    ///         transaction.\n    /// @return redemptionTimeout Time after which the redemption request can be\n    ///         reported as timed out. It is counted from the moment when the\n    ///         redemption request was created via `requestRedemption` call.\n    ///         Reported  timed out requests are cancelled and locked TBTC is\n    ///         returned to the redeemer in full amount.\n    /// @return redemptionTimeoutSlashingAmount The amount of stake slashed\n    ///         from each member of a wallet for a redemption timeout.\n    /// @return redemptionTimeoutNotifierRewardMultiplier The percentage of the\n    ///         notifier reward from the staking contract the notifier of a\n    ///         redemption timeout receives. The value is in the range [0, 100].\n    function redemptionParameters()\n        external\n        view\n        returns (\n            uint64 redemptionDustThreshold,\n            uint64 redemptionTreasuryFeeDivisor,\n            uint64 redemptionTxMaxFee,\n            uint256 redemptionTimeout,\n            uint96 redemptionTimeoutSlashingAmount,\n            uint256 redemptionTimeoutNotifierRewardMultiplier\n        )\n    {\n        redemptionDustThreshold = self.redemptionDustThreshold;\n        redemptionTreasuryFeeDivisor = self.redemptionTreasuryFeeDivisor;\n        redemptionTxMaxFee = self.redemptionTxMaxFee;\n        redemptionTimeout = self.redemptionTimeout;\n        redemptionTimeoutSlashingAmount = self.redemptionTimeoutSlashingAmount;\n        redemptionTimeoutNotifierRewardMultiplier = self\n            .redemptionTimeoutNotifierRewardMultiplier;\n    }\n\n    /// @notice Returns the current values of Bridge moving funds between\n    ///         wallets parameters.\n    /// @return movingFundsTxMaxTotalFee Maximum amount of the total BTC\n    ///         transaction fee that is acceptable in a single moving funds\n    ///         transaction. This is a _total_ max fee for the entire moving\n    ///         funds transaction.\n    /// @return movingFundsDustThreshold The minimal satoshi amount that makes\n    ///         sense to be transferred during the moving funds process. Moving\n    ///         funds wallets having their BTC balance below that value can\n    ///         begin closing immediately as transferring such a low value may\n    ///         not be possible due to BTC network fees.\n    /// @return movingFundsTimeout Time after which the moving funds process\n    ///         can be reported as timed out. It is counted from the moment\n    ///         when the wallet was requested to move their funds and switched\n    ///         to the MovingFunds state. Value in seconds.\n    /// @return movingFundsTimeoutSlashingAmount The amount of stake slashed\n    ///         from each member of a wallet for a moving funds timeout.\n    /// @return movingFundsTimeoutNotifierRewardMultiplier The percentage of the\n    ///         notifier reward from the staking contract the notifier of a\n    ///         moving funds timeout receives. The value is in the range [0, 100].\n    function movingFundsParameters()\n        external\n        view\n        returns (\n            uint64 movingFundsTxMaxTotalFee,\n            uint64 movingFundsDustThreshold,\n            uint32 movingFundsTimeout,\n            uint96 movingFundsTimeoutSlashingAmount,\n            uint256 movingFundsTimeoutNotifierRewardMultiplier\n        )\n    {\n        movingFundsTxMaxTotalFee = self.movingFundsTxMaxTotalFee;\n        movingFundsDustThreshold = self.movingFundsDustThreshold;\n        movingFundsTimeout = self.movingFundsTimeout;\n        movingFundsTimeoutSlashingAmount = self\n            .movingFundsTimeoutSlashingAmount;\n        movingFundsTimeoutNotifierRewardMultiplier = self\n            .movingFundsTimeoutNotifierRewardMultiplier;\n    }\n\n    /// @return walletCreationPeriod Determines how frequently a new wallet\n    ///         creation can be requested. Value in seconds.\n    /// @return walletCreationMinBtcBalance The minimum BTC threshold in satoshi\n    ///         that is used to decide about wallet creation.\n    /// @return walletCreationMaxBtcBalance The maximum BTC threshold in satoshi\n    ///         that is used to decide about wallet creation.\n    /// @return walletClosureMinBtcBalance The minimum BTC threshold in satoshi\n    ///         that is used to decide about wallet closure.\n    /// @return walletMaxAge The maximum age of a wallet in seconds, after which\n    ///         the wallet moving funds process can be requested.\n    /// @return walletMaxBtcTransfer The maximum BTC amount in satoshi than\n    ///         can be transferred to a single target wallet during the moving\n    ///         funds process.\n    /// @return walletClosingPeriod Determines the length of the wallet closing\n    ///         period, i.e. the period when the wallet remains in the Closing\n    ///         state and can be subject of deposit fraud challenges. Value\n    ///         in seconds.\n    function walletParameters()\n        external\n        view\n        returns (\n            uint32 walletCreationPeriod,\n            uint64 walletCreationMinBtcBalance,\n            uint64 walletCreationMaxBtcBalance,\n            uint64 walletClosureMinBtcBalance,\n            uint32 walletMaxAge,\n            uint64 walletMaxBtcTransfer,\n            uint32 walletClosingPeriod\n        )\n    {\n        walletCreationPeriod = self.walletCreationPeriod;\n        walletCreationMinBtcBalance = self.walletCreationMinBtcBalance;\n        walletCreationMaxBtcBalance = self.walletCreationMaxBtcBalance;\n        walletClosureMinBtcBalance = self.walletClosureMinBtcBalance;\n        walletMaxAge = self.walletMaxAge;\n        walletMaxBtcTransfer = self.walletMaxBtcTransfer;\n        walletClosingPeriod = self.walletClosingPeriod;\n    }\n\n    /// @notice Returns the current values of Bridge fraud parameters.\n    /// @return fraudChallengeDepositAmount The amount of ETH in wei the party\n    ///         challenging the wallet for fraud needs to deposit.\n    /// @return fraudChallengeDefeatTimeout The amount of time the wallet has to\n    ///         defeat a fraud challenge.\n    /// @return fraudSlashingAmount The amount slashed from each wallet member\n    ///         for committing a fraud.\n    /// @return fraudNotifierRewardMultiplier The percentage of the notifier\n    ///         reward from the staking contract the notifier of a fraud\n    ///         receives. The value is in the range [0, 100].\n    function fraudParameters()\n        external\n        view\n        returns (\n            uint256 fraudChallengeDepositAmount,\n            uint256 fraudChallengeDefeatTimeout,\n            uint96 fraudSlashingAmount,\n            uint256 fraudNotifierRewardMultiplier\n        )\n    {\n        fraudChallengeDepositAmount = self.fraudChallengeDepositAmount;\n        fraudChallengeDefeatTimeout = self.fraudChallengeDefeatTimeout;\n        fraudSlashingAmount = self.fraudSlashingAmount;\n        fraudNotifierRewardMultiplier = self.fraudNotifierRewardMultiplier;\n    }\n\n    /// @notice Returns the addresses of contracts Bridge is interacting with.\n    /// @return bank Address of the Bank the Bridge belongs to.\n    /// @return relay Address of the Bitcoin relay providing the current Bitcoin\n    ///         network difficulty.\n    /// @return ecdsaWalletRegistry Address of the ECDSA Wallet Registry.\n    function contractReferences()\n        external\n        view\n        returns (\n            Bank bank,\n            IRelay relay,\n            EcdsaWalletRegistry ecdsaWalletRegistry\n        )\n    {\n        bank = self.bank;\n        relay = self.relay;\n        ecdsaWalletRegistry = self.ecdsaWalletRegistry;\n    }\n\n    /// @notice Address where the deposit treasury fees will be sent to.\n    ///         Treasury takes part in the operators rewarding process.\n    function treasury() external view returns (address) {\n        return self.treasury;\n    }\n\n    /// @notice The number of confirmations on the Bitcoin chain required to\n    ///         successfully evaluate an SPV proof.\n    function txProofDifficultyFactor() external view returns (uint256) {\n        return self.txProofDifficultyFactor;\n    }\n}\n"
+      "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\nimport \"@keep-network/random-beacon/contracts/Governable.sol\";\n\nimport {IWalletOwner as EcdsaWalletOwner} from \"@keep-network/ecdsa/contracts/api/IWalletOwner.sol\";\n\nimport \"./IRelay.sol\";\nimport \"./BridgeState.sol\";\nimport \"./Deposit.sol\";\nimport \"./DepositSweep.sol\";\nimport \"./Redemption.sol\";\nimport \"./BitcoinTx.sol\";\nimport \"./EcdsaLib.sol\";\nimport \"./Wallets.sol\";\nimport \"./Fraud.sol\";\nimport \"./MovingFunds.sol\";\n\nimport \"../bank/Bank.sol\";\n\n/// @title Bitcoin Bridge\n/// @notice Bridge manages BTC deposit and redemption flow and is increasing and\n///         decreasing balances in the Bank as a result of BTC deposit and\n///         redemption operations performed by depositors and redeemers.\n///\n///         Depositors send BTC funds to the most recently created off-chain\n///         ECDSA wallet of the bridge using pay-to-script-hash (P2SH) or\n///         pay-to-witness-script-hash (P2WSH) containing hashed information\n///         about the depositor’s Ethereum address. Then, the depositor reveals\n///         their Ethereum address along with their deposit blinding factor,\n///         refund public key hash and refund locktime to the Bridge on Ethereum\n///         chain. The off-chain ECDSA wallet listens for these sorts of\n///         messages and when it gets one, it checks the Bitcoin network to make\n///         sure the deposit lines up. If it does, the off-chain ECDSA wallet\n///         may decide to pick the deposit transaction for sweeping, and when\n///         the sweep operation is confirmed on the Bitcoin network, the ECDSA\n///         wallet informs the Bridge about the sweep increasing appropriate\n///         balances in the Bank.\n/// @dev Bridge is an upgradeable component of the Bank. The order of\n///      functionalities in this contract is: deposit, sweep, redemption,\n///      moving funds, wallet lifecycle, frauds, parameters.\n///\n/// TODO: Revisit all events and look which parameters should be indexed.\n/// TODO: Align the convention around `param` and `dev` endings. They should\n///       not have a punctuation mark.\ncontract Bridge is Governable, EcdsaWalletOwner {\n    using BridgeState for BridgeState.Storage;\n    using Deposit for BridgeState.Storage;\n    using DepositSweep for BridgeState.Storage;\n    using Redemption for BridgeState.Storage;\n    using MovingFunds for BridgeState.Storage;\n    using Wallets for BridgeState.Storage;\n    using Fraud for BridgeState.Storage;\n\n    BridgeState.Storage internal self;\n\n    event DepositRevealed(\n        bytes32 fundingTxHash,\n        uint32 fundingOutputIndex,\n        address depositor,\n        uint64 amount,\n        bytes8 blindingFactor,\n        bytes20 walletPubKeyHash,\n        bytes20 refundPubKeyHash,\n        bytes4 refundLocktime,\n        address vault\n    );\n\n    event DepositsSwept(bytes20 walletPubKeyHash, bytes32 sweepTxHash);\n\n    event RedemptionRequested(\n        bytes20 walletPubKeyHash,\n        bytes redeemerOutputScript,\n        address redeemer,\n        uint64 requestedAmount,\n        uint64 treasuryFee,\n        uint64 txMaxFee\n    );\n\n    event RedemptionsCompleted(\n        bytes20 walletPubKeyHash,\n        bytes32 redemptionTxHash\n    );\n\n    event RedemptionTimedOut(\n        bytes20 walletPubKeyHash,\n        bytes redeemerOutputScript\n    );\n\n    event WalletMovingFunds(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event MovingFundsCommitmentSubmitted(\n        bytes20 walletPubKeyHash,\n        bytes20[] targetWallets,\n        address submitter\n    );\n\n    event MovingFundsCompleted(\n        bytes20 walletPubKeyHash,\n        bytes32 movingFundsTxHash\n    );\n\n    event MovingFundsTimedOut(bytes20 walletPubKeyHash);\n\n    event MovingFundsBelowDustReported(bytes20 walletPubKeyHash);\n\n    event MovedFundsSwept(bytes20 walletPubKeyHash, bytes32 sweepTxHash);\n\n    event MovedFundsSweepTimedOut(\n        bytes20 walletPubKeyHash,\n        bytes32 movingFundsTxHash,\n        uint32 movingFundsTxOutputIndex\n    );\n\n    event NewWalletRequested();\n\n    event NewWalletRegistered(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletClosing(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletClosed(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event WalletTerminated(\n        bytes32 indexed ecdsaWalletID,\n        bytes20 indexed walletPubKeyHash\n    );\n\n    event FraudChallengeSubmitted(\n        bytes20 walletPubKeyHash,\n        bytes32 sighash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    );\n\n    event FraudChallengeDefeated(bytes20 walletPubKeyHash, bytes32 sighash);\n\n    event FraudChallengeDefeatTimedOut(\n        bytes20 walletPubKeyHash,\n        bytes32 sighash\n    );\n\n    event VaultStatusUpdated(address indexed vault, bool isTrusted);\n\n    event DepositParametersUpdated(\n        uint64 depositDustThreshold,\n        uint64 depositTreasuryFeeDivisor,\n        uint64 depositTxMaxFee\n    );\n\n    event RedemptionParametersUpdated(\n        uint64 redemptionDustThreshold,\n        uint64 redemptionTreasuryFeeDivisor,\n        uint64 redemptionTxMaxFee,\n        uint256 redemptionTimeout,\n        uint96 redemptionTimeoutSlashingAmount,\n        uint256 redemptionTimeoutNotifierRewardMultiplier\n    );\n\n    event MovingFundsParametersUpdated(\n        uint64 movingFundsTxMaxTotalFee,\n        uint64 movingFundsDustThreshold,\n        uint32 movingFundsTimeout,\n        uint96 movingFundsTimeoutSlashingAmount,\n        uint256 movingFundsTimeoutNotifierRewardMultiplier,\n        uint64 movedFundsSweepTxMaxTotalFee,\n        uint32 movedFundsSweepTimeout,\n        uint96 movedFundsSweepTimeoutSlashingAmount,\n        uint256 movedFundsSweepTimeoutNotifierRewardMultiplier\n    );\n\n    event WalletParametersUpdated(\n        uint32 walletCreationPeriod,\n        uint64 walletCreationMinBtcBalance,\n        uint64 walletCreationMaxBtcBalance,\n        uint64 walletClosureMinBtcBalance,\n        uint32 walletMaxAge,\n        uint64 walletMaxBtcTransfer,\n        uint32 walletClosingPeriod\n    );\n\n    event FraudParametersUpdated(\n        uint256 fraudChallengeDepositAmount,\n        uint256 fraudChallengeDefeatTimeout,\n        uint96 fraudSlashingAmount,\n        uint256 fraudNotifierRewardMultiplier\n    );\n\n    constructor(\n        address _bank,\n        address _relay,\n        address _treasury,\n        address _ecdsaWalletRegistry,\n        uint256 _txProofDifficultyFactor\n    ) {\n        require(_bank != address(0), \"Bank address cannot be zero\");\n        self.bank = Bank(_bank);\n\n        require(_relay != address(0), \"Relay address cannot be zero\");\n        self.relay = IRelay(_relay);\n\n        require(\n            _ecdsaWalletRegistry != address(0),\n            \"ECDSA Wallet Registry address cannot be zero\"\n        );\n        self.ecdsaWalletRegistry = EcdsaWalletRegistry(_ecdsaWalletRegistry);\n\n        require(_treasury != address(0), \"Treasury address cannot be zero\");\n        self.treasury = _treasury;\n\n        self.txProofDifficultyFactor = _txProofDifficultyFactor;\n\n        // TODO: Revisit initial values.\n        self.depositDustThreshold = 1000000; // 1000000 satoshi = 0.01 BTC\n        self.depositTxMaxFee = 10000; // 10000 satoshi\n        self.depositTreasuryFeeDivisor = 2000; // 1/2000 == 5bps == 0.05% == 0.0005\n        self.redemptionDustThreshold = 1000000; // 1000000 satoshi = 0.01 BTC\n        self.redemptionTreasuryFeeDivisor = 2000; // 1/2000 == 5bps == 0.05% == 0.0005\n        self.redemptionTxMaxFee = 10000; // 10000 satoshi\n        self.redemptionTimeout = 172800; // 48 hours\n        self.redemptionTimeoutSlashingAmount = 10000 * 1e18; // 10000 T\n        self.redemptionTimeoutNotifierRewardMultiplier = 100; // 100%\n        self.movingFundsTxMaxTotalFee = 10000; // 10000 satoshi\n        self.movingFundsDustThreshold = 20000; // 20000 satoshi\n        self.movingFundsTimeout = 7 days;\n        self.movingFundsTimeoutSlashingAmount = 10000 * 1e18; // 10000 T\n        self.movingFundsTimeoutNotifierRewardMultiplier = 100; //100%\n        self.movedFundsSweepTxMaxTotalFee = 10000; // 10000 satoshi\n        self.movedFundsSweepTimeout = 7 days;\n        self.movedFundsSweepTimeoutSlashingAmount = 10000 * 1e18; // 10000 T\n        self.movedFundsSweepTimeoutNotifierRewardMultiplier = 100; //100%\n        self.fraudChallengeDepositAmount = 2 ether;\n        self.fraudChallengeDefeatTimeout = 7 days;\n        self.fraudSlashingAmount = 10000 * 1e18; // 10000 T\n        self.fraudNotifierRewardMultiplier = 100; // 100%\n        self.walletCreationPeriod = 1 weeks;\n        self.walletCreationMinBtcBalance = 1e8; // 1 BTC\n        self.walletCreationMaxBtcBalance = 100e8; // 100 BTC\n        self.walletClosureMinBtcBalance = 5 * 1e7; // 0.5 BTC\n        self.walletMaxAge = 26 weeks; // ~6 months\n        self.walletMaxBtcTransfer = 10e8; // 10 BTC\n        self.walletClosingPeriod = 40 days;\n\n        _transferGovernance(msg.sender);\n    }\n\n    /// @notice Used by the depositor to reveal information about their P2(W)SH\n    ///         Bitcoin deposit to the Bridge on Ethereum chain. The off-chain\n    ///         wallet listens for revealed deposit events and may decide to\n    ///         include the revealed deposit in the next executed sweep.\n    ///         Information about the Bitcoin deposit can be revealed before or\n    ///         after the Bitcoin transaction with P2(W)SH deposit is mined on\n    ///         the Bitcoin chain. Worth noting, the gas cost of this function\n    ///         scales with the number of P2(W)SH transaction inputs and\n    ///         outputs. The deposit may be routed to one of the trusted vaults.\n    ///         When a deposit is routed to a vault, vault gets notified when\n    ///         the deposit gets swept and it may execute the appropriate action.\n    /// @param fundingTx Bitcoin funding transaction data, see `BitcoinTx.Info`\n    /// @param reveal Deposit reveal data, see `RevealInfo struct\n    /// @dev Requirements:\n    ///      - `reveal.walletPubKeyHash` must identify a `Live` wallet\n    ///      - `reveal.vault` must be 0x0 or point to a trusted vault\n    ///      - `reveal.fundingOutputIndex` must point to the actual P2(W)SH\n    ///        output of the BTC deposit transaction\n    ///      - `reveal.depositor` must be the Ethereum address used in the\n    ///        P2(W)SH BTC deposit transaction,\n    ///      - `reveal.blindingFactor` must be the blinding factor used in the\n    ///        P2(W)SH BTC deposit transaction,\n    ///      - `reveal.walletPubKeyHash` must be the wallet pub key hash used in\n    ///        the P2(W)SH BTC deposit transaction,\n    ///      - `reveal.refundPubKeyHash` must be the refund pub key hash used in\n    ///        the P2(W)SH BTC deposit transaction,\n    ///      - `reveal.refundLocktime` must be the refund locktime used in the\n    ///        P2(W)SH BTC deposit transaction,\n    ///      - BTC deposit for the given `fundingTxHash`, `fundingOutputIndex`\n    ///        can be revealed only one time.\n    ///\n    ///      If any of these requirements is not met, the wallet _must_ refuse\n    ///      to sweep the deposit and the depositor has to wait until the\n    ///      deposit script unlocks to receive their BTC back.\n    function revealDeposit(\n        BitcoinTx.Info calldata fundingTx,\n        Deposit.DepositRevealInfo calldata reveal\n    ) external {\n        self.revealDeposit(fundingTx, reveal);\n    }\n\n    /// @notice Used by the wallet to prove the BTC deposit sweep transaction\n    ///         and to update Bank balances accordingly. Sweep is only accepted\n    ///         if it satisfies SPV proof.\n    ///\n    ///         The function is performing Bank balance updates by first\n    ///         computing the Bitcoin fee for the sweep transaction. The fee is\n    ///         divided evenly between all swept deposits. Each depositor\n    ///         receives a balance in the bank equal to the amount inferred\n    ///         during the reveal transaction, minus their fee share.\n    ///\n    ///         It is possible to prove the given sweep only one time.\n    /// @param sweepTx Bitcoin sweep transaction data\n    /// @param sweepProof Bitcoin sweep proof data\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain. If no main UTXO exists for the given wallet,\n    ///        this parameter is ignored\n    /// @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    ///      - `sweepProof` components must match the expected structure. See\n    ///        `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant.\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        If there is no main UTXO, this parameter is ignored.\n    function submitDepositSweepProof(\n        BitcoinTx.Info calldata sweepTx,\n        BitcoinTx.Proof calldata sweepProof,\n        BitcoinTx.UTXO calldata mainUtxo\n    ) external {\n        self.submitDepositSweepProof(sweepTx, sweepProof, mainUtxo);\n    }\n\n    /// @notice Requests redemption of the given amount from the specified\n    ///         wallet to the redeemer Bitcoin output script.\n    /// @param walletPubKeyHash The 20-byte wallet public key hash (computed\n    ///        using Bitcoin HASH160 over the compressed ECDSA public key)\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain\n    /// @param redeemerOutputScript The redeemer's length-prefixed output\n    ///        script (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock\n    ///        redeemed BTC\n    /// @param amount Requested amount in satoshi. This is also the TBTC amount\n    ///        that is taken from redeemer's balance in the Bank upon request.\n    ///        Once the request is handled, the actual amount of BTC locked\n    ///        on the redeemer output script will be always lower than this value\n    ///        since the treasury and Bitcoin transaction fees must be incurred.\n    ///        The minimal amount satisfying the request can be computed as:\n    ///        `amount - (amount / redemptionTreasuryFeeDivisor) - redemptionTxMaxFee`.\n    ///        Fees values are taken at the moment of request creation.\n    /// @dev Requirements:\n    ///      - Wallet behind `walletPubKeyHash` must be live\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///      - `redeemerOutputScript` must be a proper Bitcoin script\n    ///      - `redeemerOutputScript` cannot have wallet PKH as payload\n    ///      - `amount` must be above or equal the `redemptionDustThreshold`\n    ///      - Given `walletPubKeyHash` and `redeemerOutputScript` pair can be\n    ///        used for only one pending request at the same time\n    ///      - Wallet must have enough Bitcoin balance to proceed the request\n    ///      - Redeemer must make an allowance in the Bank that the Bridge\n    ///        contract can spend the given `amount`.\n    function requestRedemption(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata mainUtxo,\n        bytes calldata redeemerOutputScript,\n        uint64 amount\n    ) external {\n        self.requestRedemption(\n            walletPubKeyHash,\n            mainUtxo,\n            redeemerOutputScript,\n            amount\n        );\n    }\n\n    /// @notice Used by the wallet to prove the BTC redemption transaction\n    ///         and to make the necessary bookkeeping. Redemption is only\n    ///         accepted if it satisfies SPV proof.\n    ///\n    ///         The function is performing Bank balance updates by burning\n    ///         the total redeemed Bitcoin amount from Bridge balance and\n    ///         transferring the treasury fee sum to the treasury address.\n    ///\n    ///         It is possible to prove the given redemption only one time.\n    /// @param redemptionTx Bitcoin redemption transaction data\n    /// @param redemptionProof Bitcoin redemption proof data\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    ///        HASH160 over the compressed ECDSA public key) of the wallet which\n    ///        performed the redemption transaction\n    /// @dev Requirements:\n    ///      - `redemptionTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash.\n    ///      - The `redemptionTx` should represent a Bitcoin transaction with\n    ///        exactly 1 input that refers to the wallet's main UTXO. That\n    ///        transaction should have 1..n outputs handling existing pending\n    ///        redemption requests or pointing to reported timed out requests.\n    ///        There can be also 1 optional output representing the\n    ///        change and pointing back to the 20-byte wallet public key hash.\n    ///        The change should be always present if the redeemed value sum\n    ///        is lower than the total wallet's BTC balance.\n    ///      - `redemptionProof` components must match the expected structure.\n    ///        See `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant.\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        Additionally, the recent main UTXO on Ethereum must be set.\n    ///      - `walletPubKeyHash` must be connected with the main UTXO used\n    ///        as transaction single input.\n    ///      Other remarks:\n    ///      - Putting the change output as the first transaction output can\n    ///        save some gas because the output processing loop begins each\n    ///        iteration by checking whether the given output is the change\n    ///        thus uses some gas for making the comparison. Once the change\n    ///        is identified, that check is omitted in further iterations.\n    function submitRedemptionProof(\n        BitcoinTx.Info calldata redemptionTx,\n        BitcoinTx.Proof calldata redemptionProof,\n        BitcoinTx.UTXO calldata mainUtxo,\n        bytes20 walletPubKeyHash\n    ) external {\n        self.submitRedemptionProof(\n            redemptionTx,\n            redemptionProof,\n            mainUtxo,\n            walletPubKeyHash\n        );\n    }\n\n    /// @notice Notifies that there is a pending redemption request associated\n    ///         with the given wallet, that has timed out. The redemption\n    ///         request is identified by the key built as\n    ///         `keccak256(walletPubKeyHash | redeemerOutputScript)`.\n    ///         The results of calling this function:\n    ///         - the pending redemptions value for the wallet will be decreased\n    ///           by the requested amount (minus treasury fee),\n    ///         - the tokens taken from the redeemer on redemption request will\n    ///           be returned to the redeemer,\n    ///         - the request will be moved from pending redemptions to\n    ///           timed-out redemptions,\n    ///         - if the state of the wallet is `Live` or `MovingFunds`, the\n    ///           wallet operators will be slashed and the notifier will be\n    ///           rewarded,\n    ///         - if the state of wallet is `Live`, the wallet will be closed or\n    ///           marked as `MovingFunds` (depending on the presence or absence\n    ///           of the wallet's main UTXO) and the wallet will no longer be\n    ///           marked as the active wallet (if it was marked as such).\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param walletMembersIDs Identifiers of the wallet signing group members\n    /// @param redeemerOutputScript  The redeemer's length-prefixed output\n    ///        script (P2PKH, P2WPKH, P2SH or P2WSH)\n    /// @dev Requirements:\n    ///      - The wallet must be in the Live or MovingFunds or Terminated state\n    ///      - The redemption request identified by `walletPubKeyHash` and\n    ///        `redeemerOutputScript` must exist\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract\n    ///      - The amount of time defined by `redemptionTimeout` must have\n    ///        passed since the redemption was requested (the request must be\n    ///        timed-out)\n    function notifyRedemptionTimeout(\n        bytes20 walletPubKeyHash,\n        uint32[] calldata walletMembersIDs,\n        bytes calldata redeemerOutputScript\n    ) external {\n        self.notifyRedemptionTimeout(\n            walletPubKeyHash,\n            walletMembersIDs,\n            redeemerOutputScript\n        );\n    }\n\n    /// @notice Submits the moving funds target wallets commitment.\n    ///         Once all requirements are met, that function registers the\n    ///         target wallets commitment and opens the way for moving funds\n    ///         proof submission.\n    /// @param walletPubKeyHash 20-byte public key hash of the source wallet\n    /// @param walletMainUtxo Data of the source wallet's main UTXO, as\n    ///        currently known on the Ethereum chain\n    /// @param walletMembersIDs Identifiers of the source wallet signing group\n    ///        members\n    /// @param walletMemberIndex Position of the caller in the source wallet\n    ///        signing group members list\n    /// @param targetWallets List of 20-byte public key hashes of the target\n    ///        wallets that the source wallet commits to move the funds to\n    /// @dev Requirements:\n    ///      - The source wallet must be in the MovingFunds state\n    ///      - The source wallet must not have pending redemption requests\n    ///      - The source wallet must not have pending moved funds sweep requests\n    ///      - The source wallet must not have submitted its commitment already\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given source wallet in the ECDSA registry. Those IDs are\n    ///        not directly stored in the contract for gas efficiency purposes\n    ///        but they can be read from appropriate `DkgResultSubmitted`\n    ///        and `DkgResultApproved` events.\n    ///      - The `walletMemberIndex` must be in range [1, walletMembersIDs.length]\n    ///      - The caller must be the member of the source wallet signing group\n    ///        at the position indicated by `walletMemberIndex` parameter\n    ///      - The `walletMainUtxo` components must point to the recent main\n    ///        UTXO of the source wallet, as currently known on the Ethereum\n    ///        chain.\n    ///      - Source wallet BTC balance must be greater than zero\n    ///      - At least one Live wallet must exist in the system\n    ///      - Submitted target wallets count must match the expected count\n    ///        `N = min(liveWalletsCount, ceil(walletBtcBalance / walletMaxBtcTransfer))`\n    ///        where `N > 0`\n    ///      - Each target wallet must be not equal to the source wallet\n    ///      - Each target wallet must follow the expected order i.e. all\n    ///        target wallets 20-byte public key hashes represented as numbers\n    ///        must form a strictly increasing sequence without duplicates.\n    ///      - Each target wallet must be in Live state\n    function submitMovingFundsCommitment(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata walletMainUtxo,\n        uint32[] calldata walletMembersIDs,\n        uint256 walletMemberIndex,\n        bytes20[] calldata targetWallets\n    ) external {\n        self.submitMovingFundsCommitment(\n            walletPubKeyHash,\n            walletMainUtxo,\n            walletMembersIDs,\n            walletMemberIndex,\n            targetWallets\n        );\n    }\n\n    /// @notice Used by the wallet to prove the BTC moving funds transaction\n    ///         and to make the necessary state changes. Moving funds is only\n    ///         accepted if it satisfies SPV proof.\n    ///\n    ///         The function validates the moving funds transaction structure\n    ///         by checking if it actually spends the main UTXO of the declared\n    ///         wallet and locks the value on the pre-committed target wallets\n    ///         using a reasonable transaction fee. If all preconditions are\n    ///         met, this functions closes the source wallet.\n    ///\n    ///         It is possible to prove the given moving funds transaction only\n    ///         one time.\n    /// @param movingFundsTx Bitcoin moving funds transaction data\n    /// @param movingFundsProof Bitcoin moving funds proof data\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    ///        HASH160 over the compressed ECDSA public key) of the wallet\n    ///        which performed the moving funds transaction\n    /// @dev Requirements:\n    ///      - `movingFundsTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash.\n    ///      - The `movingFundsTx` should represent a Bitcoin transaction with\n    ///        exactly 1 input that refers to the wallet's main UTXO. That\n    ///        transaction should have 1..n outputs corresponding to the\n    ///        pre-committed target wallets. Outputs must be ordered in the\n    ///        same way as their corresponding target wallets are ordered\n    ///        within the target wallets commitment.\n    ///      - `movingFundsProof` components must match the expected structure.\n    ///        See `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant.\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        Additionally, the recent main UTXO on Ethereum must be set.\n    ///      - `walletPubKeyHash` must be connected with the main UTXO used\n    ///        as transaction single input.\n    ///      - The wallet that `walletPubKeyHash` points to must be in the\n    ///        MovingFunds state.\n    ///      - The target wallets commitment must be submitted by the wallet\n    ///        that `walletPubKeyHash` points to.\n    ///      - The total Bitcoin transaction fee must be lesser or equal\n    ///        to `movingFundsTxMaxTotalFee` governable parameter.\n    function submitMovingFundsProof(\n        BitcoinTx.Info calldata movingFundsTx,\n        BitcoinTx.Proof calldata movingFundsProof,\n        BitcoinTx.UTXO calldata mainUtxo,\n        bytes20 walletPubKeyHash\n    ) external {\n        self.submitMovingFundsProof(\n            movingFundsTx,\n            movingFundsProof,\n            mainUtxo,\n            walletPubKeyHash\n        );\n    }\n\n    /// @notice Notifies about a timed out moving funds process. Terminates\n    ///         the wallet and slashes signing group members as a result.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param walletMembersIDs Identifiers of the wallet signing group members\n    /// @dev Requirements:\n    ///      - The wallet must be in the MovingFunds state\n    ///      - The moving funds timeout must be actually exceeded\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract\n    function notifyMovingFundsTimeout(\n        bytes20 walletPubKeyHash,\n        uint32[] calldata walletMembersIDs\n    ) external {\n        self.notifyMovingFundsTimeout(walletPubKeyHash, walletMembersIDs);\n    }\n\n    /// @notice Notifies about a moving funds wallet whose BTC balance is\n    ///         below the moving funds dust threshold. Ends the moving funds\n    ///         process and begins wallet closing immediately.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known\n    ///        on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - The wallet must be in the MovingFunds state\n    ///      - The `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        If the wallet has no main UTXO, this parameter can be empty as it\n    ///        is ignored.\n    ///      - The wallet BTC balance must be below the moving funds threshold\n    function notifyMovingFundsBelowDust(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata mainUtxo\n    ) external {\n        self.notifyMovingFundsBelowDust(walletPubKeyHash, mainUtxo);\n    }\n\n    /// @notice Used by the wallet to prove the BTC moved funds sweep\n    ///         transaction and to make the necessary state changes. Moved\n    ///         funds sweep is only accepted if it satisfies SPV proof.\n    ///\n    ///         The function validates the sweep transaction structure by\n    ///         checking if it actually spends the moved funds UTXO and the\n    ///         sweeping wallet's main UTXO (optionally), and if it locks the\n    ///         value on the sweeping wallet's 20-byte public key hash using a\n    ///         reasonable transaction fee. If all preconditions are\n    ///         met, this function updates the sweeping wallet main UTXO, thus\n    ///         their BTC balance.\n    ///\n    ///         It is possible to prove the given sweep transaction only\n    ///         one time.\n    /// @param sweepTx Bitcoin sweep funds transaction data\n    /// @param sweepProof Bitcoin sweep funds proof data\n    /// @param mainUtxo Data of the sweeping wallet's main UTXO, as currently\n    ///        known on the Ethereum chain\n    /// @dev Requirements:\n    ///      - `sweepTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash.\n    ///      - The `sweepTx` should represent a Bitcoin transaction with\n    ///        the first input pointing to a moved funds sweep request targeted\n    ///        to the wallet, and optionally, the second input pointing to the\n    ///        wallet's main UTXO, if the sweeping wallet has a main UTXO set.\n    ///        There should be only one output locking funds on the sweeping\n    ///        wallet 20-byte public key hash.\n    ///      - `sweepProof` components must match the expected structure.\n    ///        See `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant.\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the sweeping wallet, as currently known on the Ethereum chain.\n    ///        If there is no main UTXO, this parameter is ignored.\n    ///      - The sweeping wallet must be in the Live or MovingFunds state.\n    ///      - The total Bitcoin transaction fee must be lesser or equal\n    ///        to `movedFundsSweepTxMaxTotalFee` governable parameter.\n    function submitMovedFundsSweepProof(\n        BitcoinTx.Info calldata sweepTx,\n        BitcoinTx.Proof calldata sweepProof,\n        BitcoinTx.UTXO calldata mainUtxo\n    ) external {\n        self.submitMovedFundsSweepProof(sweepTx, sweepProof, mainUtxo);\n    }\n\n    /// @notice Notifies about a timed out moved funds sweep process. If the\n    ///         wallet is not terminated yet, that function terminates\n    ///         the wallet and slashes signing group members as a result.\n    ///         Marks the given sweep request as TimedOut.\n    /// @param movingFundsTxHash 32-byte hash of the moving funds transaction\n    ///        that caused the sweep request to be created\n    /// @param movingFundsTxOutputIndex Index of the moving funds transaction\n    ///        output that is subject of the sweep request.\n    /// @param walletMembersIDs Identifiers of the wallet signing group members\n    /// @dev Requirements:\n    ///      - The moved funds sweep request must be in the Pending state\n    ///      - The moved funds sweep timeout must be actually exceeded\n    ///      - The wallet must be either in the Live or MovingFunds or\n    ///        Terminated state\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract\n    function notifyMovedFundsSweepTimeout(\n        bytes32 movingFundsTxHash,\n        uint32 movingFundsTxOutputIndex,\n        uint32[] calldata walletMembersIDs\n    ) external {\n        self.notifyMovedFundsSweepTimeout(\n            movingFundsTxHash,\n            movingFundsTxOutputIndex,\n            walletMembersIDs\n        );\n    }\n\n    /// @notice Requests creation of a new wallet. This function just\n    ///         forms a request and the creation process is performed\n    ///         asynchronously. Once a wallet is created, the ECDSA Wallet\n    ///         Registry will notify this contract by calling the\n    ///         `__ecdsaWalletCreatedCallback` function.\n    /// @param activeWalletMainUtxo Data of the active wallet's main UTXO, as\n    ///        currently known on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - `activeWalletMainUtxo` components must point to the recent main\n    ///        UTXO of the given active wallet, as currently known on the\n    ///        Ethereum chain. If there is no active wallet at the moment, or\n    ///        the active wallet has no main UTXO, this parameter can be\n    ///        empty as it is ignored.\n    ///      - Wallet creation must not be in progress\n    ///      - If the active wallet is set, one of the following\n    ///        conditions must be true:\n    ///        - The active wallet BTC balance is above the minimum threshold\n    ///          and the active wallet is old enough, i.e. the creation period\n    ///          was elapsed since its creation time\n    ///        - The active wallet BTC balance is above the maximum threshold\n    function requestNewWallet(BitcoinTx.UTXO calldata activeWalletMainUtxo)\n        external\n    {\n        self.requestNewWallet(activeWalletMainUtxo);\n    }\n\n    /// @notice A callback function that is called by the ECDSA Wallet Registry\n    ///         once a new ECDSA wallet is created.\n    /// @param ecdsaWalletID Wallet's unique identifier.\n    /// @param publicKeyX Wallet's public key's X coordinate.\n    /// @param publicKeyY Wallet's public key's Y coordinate.\n    /// @dev Requirements:\n    ///      - The only caller authorized to call this function is `registry`\n    ///      - Given wallet data must not belong to an already registered wallet\n    function __ecdsaWalletCreatedCallback(\n        bytes32 ecdsaWalletID,\n        bytes32 publicKeyX,\n        bytes32 publicKeyY\n    ) external override {\n        self.registerNewWallet(ecdsaWalletID, publicKeyX, publicKeyY);\n    }\n\n    /// @notice A callback function that is called by the ECDSA Wallet Registry\n    ///         once a wallet heartbeat failure is detected.\n    /// @param publicKeyX Wallet's public key's X coordinate\n    /// @param publicKeyY Wallet's public key's Y coordinate\n    /// @dev Requirements:\n    ///      - The only caller authorized to call this function is `registry`\n    ///      - Wallet must be in Live state\n    function __ecdsaWalletHeartbeatFailedCallback(\n        bytes32,\n        bytes32 publicKeyX,\n        bytes32 publicKeyY\n    ) external override {\n        self.notifyWalletHeartbeatFailed(publicKeyX, publicKeyY);\n    }\n\n    /// @notice Notifies that the wallet is either old enough or has too few\n    ///         satoshi left and qualifies to be closed.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param walletMainUtxo Data of the wallet's main UTXO, as currently\n    ///        known on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - Wallet must not be set as the current active wallet\n    ///      - Wallet must exceed the wallet maximum age OR the wallet BTC\n    ///        balance must be lesser than the minimum threshold. If the latter\n    ///        case is true, the `walletMainUtxo` components must point to the\n    ///        recent main UTXO of the given wallet, as currently known on the\n    ///        Ethereum chain. If the wallet has no main UTXO, this parameter\n    ///        can be empty as it is ignored since the wallet balance is\n    ///        assumed to be zero.\n    ///      - Wallet must be in Live state\n    function notifyCloseableWallet(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata walletMainUtxo\n    ) external {\n        self.notifyCloseableWallet(walletPubKeyHash, walletMainUtxo);\n    }\n\n    /// @notice Notifies about the end of the closing period for the given wallet.\n    ///         Closes the wallet ultimately and notifies the ECDSA registry\n    ///         about this fact.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @dev Requirements:\n    ///      - The wallet must be in the Closing state\n    ///      - The wallet closing period must have elapsed\n    function notifyWalletClosingPeriodElapsed(bytes20 walletPubKeyHash)\n        external\n    {\n        self.notifyWalletClosingPeriodElapsed(walletPubKeyHash);\n    }\n\n    /// @notice Submits a fraud challenge indicating that a UTXO being under\n    ///         wallet control was unlocked by the wallet but was not used\n    ///         according to the protocol rules. That means the wallet signed\n    ///         a transaction input pointing to that UTXO and there is a unique\n    ///         sighash and signature pair associated with that input. This\n    ///         function uses those parameters to create a fraud accusation that\n    ///         proves a given transaction input unlocking the given UTXO was\n    ///         actually signed by the wallet. This function cannot determine\n    ///         whether the transaction was actually broadcast and the input was\n    ///         consumed in a fraudulent way so it just opens a challenge period\n    ///         during which the wallet can defeat the challenge by submitting\n    ///         proof of a transaction that consumes the given input according\n    ///         to protocol rules. To prevent spurious allegations, the caller\n    ///         must deposit ETH that is returned back upon justified fraud\n    ///         challenge or confiscated otherwise.\n    ///@param walletPublicKey The public key of the wallet in the uncompressed\n    ///       and unprefixed format (64 bytes)\n    /// @param sighash The hash that was used to produce the ECDSA signature\n    ///        that is the subject of the fraud claim. This hash is constructed\n    ///        by applying double SHA-256 over a serialized subset of the\n    ///        transaction. The exact subset used as hash preimage depends on\n    ///        the transaction input the signature is produced for. See BIP-143\n    ///        for reference\n    /// @param signature Bitcoin signature in the R/S/V format\n    /// @dev Requirements:\n    ///      - Wallet behind `walletPublicKey` must be in Live or MovingFunds\n    ///        or Closing state\n    ///      - The challenger must send appropriate amount of ETH used as\n    ///        fraud challenge deposit\n    ///      - The signature (represented by r, s and v) must be generated by\n    ///        the wallet behind `walletPubKey` during signing of `sighash`\n    ///      - Wallet can be challenged for the given signature only once\n    function submitFraudChallenge(\n        bytes calldata walletPublicKey,\n        bytes32 sighash,\n        BitcoinTx.RSVSignature calldata signature\n    ) external payable {\n        self.submitFraudChallenge(walletPublicKey, sighash, signature);\n    }\n\n    /// @notice Allows to defeat a pending fraud challenge against a wallet if\n    ///         the transaction that spends the UTXO follows the protocol rules.\n    ///         In order to defeat the challenge the same `walletPublicKey` and\n    ///         signature (represented by `r`, `s` and `v`) must be provided as\n    ///         were used to calculate the sighash during input signing.\n    ///         The fraud challenge defeat attempt will only succeed if the\n    ///         inputs in the preimage are considered honestly spent by the\n    ///         wallet. Therefore the transaction spending the UTXO must be\n    ///         proven in the Bridge before a challenge defeat is called.\n    ///         If successfully defeated, the fraud challenge is marked as\n    ///         resolved and the amount of ether deposited by the challenger is\n    ///         sent to the treasury.\n    /// @param walletPublicKey The public key of the wallet in the uncompressed\n    ///        and unprefixed format (64 bytes)\n    /// @param preimage The preimage which produces sighash used to generate the\n    ///        ECDSA signature that is the subject of the fraud claim. It is a\n    ///        serialized subset of the transaction. The exact subset used as\n    ///        the preimage depends on the transaction input the signature is\n    ///        produced for. See BIP-143 for reference\n    /// @param witness Flag indicating whether the preimage was produced for a\n    ///        witness input. True for witness, false for non-witness input\n    /// @dev Requirements:\n    ///      - `walletPublicKey` and `sighash` calculated as `hash256(preimage)`\n    ///        must identify an open fraud challenge\n    ///      - the preimage must be a valid preimage of a transaction generated\n    ///        according to the protocol rules and already proved in the Bridge\n    ///      - before a defeat attempt is made the transaction that spends the\n    ///        given UTXO must be proven in the Bridge\n    function defeatFraudChallenge(\n        bytes calldata walletPublicKey,\n        bytes calldata preimage,\n        bool witness\n    ) external {\n        self.defeatFraudChallenge(walletPublicKey, preimage, witness);\n    }\n\n    /// @notice Notifies about defeat timeout for the given fraud challenge.\n    ///         Can be called only if there was a fraud challenge identified by\n    ///         the provided `walletPublicKey` and `sighash` and it was not\n    ///         defeated on time. The amount of time that needs to pass after\n    ///         a fraud challenge is reported is indicated by the\n    ///         `challengeDefeatTimeout`. After a successful fraud challenge\n    ///         defeat timeout notification the fraud challenge is marked as\n    ///         resolved, the stake of each operator is slashed, the ether\n    ///         deposited is returned to the challenger and the challenger is\n    ///         rewarded.\n    /// @param walletPublicKey The public key of the wallet in the uncompressed\n    ///        and unprefixed format (64 bytes)\n    /// @param walletMembersIDs Identifiers of the wallet signing group members\n    /// @param sighash The hash that was used to produce the ECDSA signature\n    ///        that is the subject of the fraud claim. This hash is constructed\n    ///        by applying double SHA-256 over a serialized subset of the\n    ///        transaction. The exact subset used as hash preimage depends on\n    ///        the transaction input the signature is produced for. See BIP-143\n    ///        for reference\n    /// @dev Requirements:\n    ///      - The wallet must be in the Live or MovingFunds or Closing or\n    ///        Terminated state\n    ///      - The `walletPublicKey` and `sighash` must identify an open fraud\n    ///        challenge\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract\n    ///      - The amount of time indicated by `challengeDefeatTimeout` must pass\n    ///        after the challenge was reported\n    function notifyFraudChallengeDefeatTimeout(\n        bytes calldata walletPublicKey,\n        uint32[] calldata walletMembersIDs,\n        bytes32 sighash\n    ) external {\n        self.notifyFraudChallengeDefeatTimeout(\n            walletPublicKey,\n            walletMembersIDs,\n            sighash\n        );\n    }\n\n    /// @notice Allows the Governance to mark the given vault address as trusted\n    ///         or no longer trusted. Vaults are not trusted by default.\n    ///         Trusted vault must meet the following criteria:\n    ///         - `IVault.receiveBalanceIncrease` must have a known, low gas\n    ///           cost.\n    ///         - `IVault.receiveBalanceIncrease` must never revert.\n    /// @dev Without restricting reveal only to trusted vaults, malicious\n    ///      vaults not meeting the criteria would be able to nuke sweep proof\n    ///      transactions executed by ECDSA wallet with  deposits routed to\n    ///      them.\n    /// @param vault The address of the vault\n    /// @param isTrusted flag indicating whether the vault is trusted or not\n    /// @dev Can only be called by the Governance.\n    function setVaultStatus(address vault, bool isTrusted)\n        external\n        onlyGovernance\n    {\n        self.isVaultTrusted[vault] = isTrusted;\n        emit VaultStatusUpdated(vault, isTrusted);\n    }\n\n    /// @notice Updates parameters of deposits.\n    /// @param depositDustThreshold New value of the deposit dust threshold in\n    ///        satoshis. It is the minimal amount that can be requested to\n    ////       deposit. Value of this parameter must take into account the value\n    ///        of `depositTreasuryFeeDivisor` and `depositTxMaxFee` parameters\n    ///        in order to make requests that can incur the treasury and\n    ///        transaction fee and still satisfy the depositor\n    /// @param depositTreasuryFeeDivisor New value of the treasury fee divisor.\n    ///        It is the divisor used to compute the treasury fee taken from\n    ///        each deposit and transferred to the treasury upon sweep proof\n    ///        submission. That fee is computed as follows:\n    ///        `treasuryFee = depositedAmount / depositTreasuryFeeDivisor`\n    ///        For example, if the treasury fee needs to be 2% of each deposit,\n    ///        the `depositTreasuryFeeDivisor` should be set to `50`\n    ///        because `1/50 = 0.02 = 2%`\n    /// @param depositTxMaxFee New value of the deposit tx max fee in satoshis.\n    ///        It is the maximum amount of BTC transaction fee that can\n    ///        be incurred by each swept deposit being part of the given sweep\n    ///        transaction. If the maximum BTC transaction fee is exceeded,\n    ///        such transaction is considered a fraud\n    /// @dev Requirements:\n    ///      - Deposit dust threshold must be greater than zero\n    ///      - Deposit treasury fee divisor must be greater than zero\n    ///      - Deposit transaction max fee must be greater than zero\n    function updateDepositParameters(\n        uint64 depositDustThreshold,\n        uint64 depositTreasuryFeeDivisor,\n        uint64 depositTxMaxFee\n    ) external onlyGovernance {\n        self.updateDepositParameters(\n            depositDustThreshold,\n            depositTreasuryFeeDivisor,\n            depositTxMaxFee\n        );\n    }\n\n    /// @notice Updates parameters of redemptions.\n    /// @param redemptionDustThreshold New value of the redemption dust\n    ///        threshold in satoshis. It is the minimal amount that can be\n    ///        requested for redemption. Value of this parameter must take into\n    ///        account the value of `redemptionTreasuryFeeDivisor` and\n    ///        `redemptionTxMaxFee` parameters in order to make requests that\n    ///        can incur the treasury and transaction fee and still satisfy the\n    ///        redeemer.\n    /// @param redemptionTreasuryFeeDivisor New value of the redemption\n    ///        treasury fee divisor. It is the divisor used to compute the\n    ///        treasury fee taken from each redemption request and transferred\n    ///        to the treasury upon successful request finalization. That fee is\n    ///        computed as follows:\n    ///        `treasuryFee = requestedAmount / redemptionTreasuryFeeDivisor`\n    ///        For example, if the treasury fee needs to be 2% of each\n    ///        redemption request, the `redemptionTreasuryFeeDivisor` should\n    ///        be set to `50` because `1/50 = 0.02 = 2%`.\n    /// @param redemptionTxMaxFee New value of the redemption transaction max\n    ///        fee in satoshis. It is the maximum amount of BTC transaction fee\n    ///        that can be incurred by each redemption request being part of the\n    ///        given redemption transaction. If the maximum BTC transaction fee\n    ///        is exceeded, such transaction is considered a fraud.\n    ///        This is a per-redemption output max fee for the redemption\n    ///        transaction.\n    /// @param redemptionTimeout New value of the redemption timeout in seconds.\n    ///        It is the time after which the redemption request can be reported\n    ///        as timed out. It is counted from the moment when the redemption\n    ///        request was created via `requestRedemption` call. Reported  timed\n    ///        out requests are cancelled and locked TBTC is returned to the\n    ///        redeemer in full amount.\n    /// @param redemptionTimeoutSlashingAmount New value of the redemption\n    ///        timeout slashing amount in T, it is the amount slashed from each\n    ///        wallet member for redemption timeout\n    /// @param redemptionTimeoutNotifierRewardMultiplier New value of the\n    ///        redemption timeout notifier reward multiplier as percentage,\n    ///        it determines the percentage of the notifier reward from the\n    ///        staking contact the notifier of a redemption timeout receives.\n    ///        The value must be in the range [0, 100]\n    /// @dev Requirements:\n    ///      - Redemption dust threshold must be greater than zero\n    ///      - Redemption treasury fee divisor must be greater than zero\n    ///      - Redemption transaction max fee must be greater than zero\n    ///      - Redemption timeout must be greater than zero\n    ///      - Redemption timeout notifier reward multiplier must be in the\n    ///        range [0, 100]\n    function updateRedemptionParameters(\n        uint64 redemptionDustThreshold,\n        uint64 redemptionTreasuryFeeDivisor,\n        uint64 redemptionTxMaxFee,\n        uint256 redemptionTimeout,\n        uint96 redemptionTimeoutSlashingAmount,\n        uint256 redemptionTimeoutNotifierRewardMultiplier\n    ) external onlyGovernance {\n        self.updateRedemptionParameters(\n            redemptionDustThreshold,\n            redemptionTreasuryFeeDivisor,\n            redemptionTxMaxFee,\n            redemptionTimeout,\n            redemptionTimeoutSlashingAmount,\n            redemptionTimeoutNotifierRewardMultiplier\n        );\n    }\n\n    /// @notice Updates parameters of moving funds.\n    /// @param movingFundsTxMaxTotalFee New value of the moving funds transaction\n    ///        max total fee in satoshis. It is the maximum amount of the total\n    ///        BTC transaction fee that is acceptable in a single moving funds\n    ///        transaction. This is a _total_ max fee for the entire moving\n    ///        funds transaction.\n    /// @param movingFundsDustThreshold New value of the moving funds dust\n    ///        threshold. It is the minimal satoshi amount that makes sense to\n    //         be transferred during the moving funds process. Moving funds\n    //         wallets having their BTC balance below that value can begin\n    //         closing immediately as transferring such a low value may not be\n    //         possible due to BTC network fees.\n    /// @param movingFundsTimeout New value of the moving funds timeout in\n    ///        seconds. It is the time after which the moving funds process can\n    ///        be reported as timed out. It is counted from the moment when the\n    ///        wallet was requested to move their funds and switched to the\n    ///        MovingFunds state.\n    /// @param movingFundsTimeoutSlashingAmount New value of the moving funds\n    ///        timeout slashing amount in T, it is the amount slashed from each\n    ///        wallet member for moving funds timeout\n    /// @param movingFundsTimeoutNotifierRewardMultiplier New value of the\n    ///        moving funds timeout notifier reward multiplier as percentage,\n    ///        it determines the percentage of the notifier reward from the\n    ///        staking contact the notifier of a moving funds timeout receives.\n    ///        The value must be in the range [0, 100]\n    /// @param movedFundsSweepTxMaxTotalFee New value of the moved funds sweep\n    ///        transaction max total fee in satoshis. It is the maximum amount\n    ///        of the total BTC transaction fee that is acceptable in a single\n    ///        moved funds sweep transaction. This is a _total_ max fee for the\n    ///        entire moved funds sweep transaction.\n    /// @param movedFundsSweepTimeout New value of the moved funds sweep\n    ///        timeout in seconds. It is the time after which the moved funds\n    ///        sweep process can be reported as timed out. It is counted from\n    ///        the moment when the wallet was requested to sweep the received\n    ///        funds.\n    /// @param movedFundsSweepTimeoutSlashingAmount New value of the moved\n    ///        funds sweep timeout slashing amount in T, it is the amount\n    ///        slashed from each wallet member for moved funds sweep timeout\n    /// @param movedFundsSweepTimeoutNotifierRewardMultiplier New value of\n    ///        the moved funds sweep timeout notifier reward multiplier as\n    ///        percentage, it determines the percentage of the notifier reward\n    ///        from the staking contact the notifier of a moved funds sweep\n    ///        timeout receives. The value must be in the range [0, 100]\n    /// @dev Requirements:\n    ///      - Moving funds transaction max total fee must be greater than zero\n    ///      - Moving funds dust threshold must be greater than zero\n    ///      - Moving funds timeout must be greater than zero\n    ///      - Moving funds timeout notifier reward multiplier must be in the\n    ///        range [0, 100]\n    ///      - Moved funds sweep transaction max total fee must be greater than zero\n    ///      - Moved funds sweep timeout must be greater than zero\n    ///      - Moved funds sweep timeout notifier reward multiplier must be in the\n    ///        range [0, 100]\n    function updateMovingFundsParameters(\n        uint64 movingFundsTxMaxTotalFee,\n        uint64 movingFundsDustThreshold,\n        uint32 movingFundsTimeout,\n        uint96 movingFundsTimeoutSlashingAmount,\n        uint256 movingFundsTimeoutNotifierRewardMultiplier,\n        uint64 movedFundsSweepTxMaxTotalFee,\n        uint32 movedFundsSweepTimeout,\n        uint96 movedFundsSweepTimeoutSlashingAmount,\n        uint256 movedFundsSweepTimeoutNotifierRewardMultiplier\n    ) external onlyGovernance {\n        self.updateMovingFundsParameters(\n            movingFundsTxMaxTotalFee,\n            movingFundsDustThreshold,\n            movingFundsTimeout,\n            movingFundsTimeoutSlashingAmount,\n            movingFundsTimeoutNotifierRewardMultiplier,\n            movedFundsSweepTxMaxTotalFee,\n            movedFundsSweepTimeout,\n            movedFundsSweepTimeoutSlashingAmount,\n            movedFundsSweepTimeoutNotifierRewardMultiplier\n        );\n    }\n\n    /// @notice Updates parameters of wallets.\n    /// @param walletCreationPeriod New value of the wallet creation period in\n    ///        seconds, determines how frequently a new wallet creation can be\n    ///        requested\n    /// @param walletCreationMinBtcBalance New value of the wallet minimum BTC\n    ///        balance in satoshi, used to decide about wallet creation\n    /// @param walletCreationMaxBtcBalance New value of the wallet maximum BTC\n    ///        balance in satoshi, used to decide about wallet creation\n    /// @param walletClosureMinBtcBalance New value of the wallet minimum BTC\n    ///        balance in satoshi, used to decide about wallet closure\n    /// @param walletMaxAge New value of the wallet maximum age in seconds,\n    ///        indicates the maximum age of a wallet in seconds, after which\n    ///        the wallet moving funds process can be requested\n    /// @param walletMaxBtcTransfer New value of the wallet maximum BTC transfer\n    ///        in satoshi, determines the maximum amount that can be transferred\n    //         to a single target wallet during the moving funds process\n    /// @param walletClosingPeriod New value of the wallet closing period in\n    ///        seconds, determines the length of the wallet closing period,\n    //         i.e. the period when the wallet remains in the Closing state\n    //         and can be subject of deposit fraud challenges\n    /// @dev Requirements:\n    ///      - Wallet minimum BTC balance must be greater than zero\n    ///      - Wallet maximum BTC balance must be greater than the wallet\n    ///        minimum BTC balance\n    ///      - Wallet maximum BTC transfer must be greater than zero\n    ///      - Wallet closing period must be greater than zero\n    function updateWalletParameters(\n        uint32 walletCreationPeriod,\n        uint64 walletCreationMinBtcBalance,\n        uint64 walletCreationMaxBtcBalance,\n        uint64 walletClosureMinBtcBalance,\n        uint32 walletMaxAge,\n        uint64 walletMaxBtcTransfer,\n        uint32 walletClosingPeriod\n    ) external onlyGovernance {\n        self.updateWalletParameters(\n            walletCreationPeriod,\n            walletCreationMinBtcBalance,\n            walletCreationMaxBtcBalance,\n            walletClosureMinBtcBalance,\n            walletMaxAge,\n            walletMaxBtcTransfer,\n            walletClosingPeriod\n        );\n    }\n\n    /// @notice Updates parameters related to frauds.\n    /// @param fraudChallengeDepositAmount New value of the fraud challenge\n    ///        deposit amount in wei, it is the amount of ETH the party\n    ///        challenging the wallet for fraud needs to deposit\n    /// @param fraudChallengeDefeatTimeout New value of the challenge defeat\n    ///        timeout in seconds, it is the amount of time the wallet has to\n    ///        defeat a fraud challenge. The value must be greater than zero\n    /// @param fraudSlashingAmount New value of the fraud slashing amount in T,\n    ///        it is the amount slashed from each wallet member for committing\n    ///        a fraud\n    /// @param fraudNotifierRewardMultiplier New value of the fraud notifier\n    ///        reward multiplier as percentage, it determines the percentage of\n    ///        the notifier reward from the staking contact the notifier of\n    ///        a fraud receives. The value must be in the range [0, 100]\n    /// @dev Requirements:\n    ///      - Fraud challenge defeat timeout must be greater than 0\n    ///      - Fraud notifier reward multiplier must be in the range [0, 100]\n    function updateFraudParameters(\n        uint256 fraudChallengeDepositAmount,\n        uint256 fraudChallengeDefeatTimeout,\n        uint96 fraudSlashingAmount,\n        uint256 fraudNotifierRewardMultiplier\n    ) external onlyGovernance {\n        self.updateFraudParameters(\n            fraudChallengeDepositAmount,\n            fraudChallengeDefeatTimeout,\n            fraudSlashingAmount,\n            fraudNotifierRewardMultiplier\n        );\n    }\n\n    /// @notice Collection of all revealed deposits indexed by\n    ///         keccak256(fundingTxHash | fundingOutputIndex).\n    ///         The fundingTxHash is bytes32 (ordered as in Bitcoin internally)\n    ///         and fundingOutputIndex an uint32. This mapping may contain valid\n    ///         and invalid deposits and the wallet is responsible for\n    ///         validating them before attempting to execute a sweep.\n    function deposits(uint256 depositKey)\n        external\n        view\n        returns (Deposit.DepositRequest memory)\n    {\n        return self.deposits[depositKey];\n    }\n\n    /// @notice Collection of all pending redemption requests indexed by\n    ///         redemption key built as\n    ///         keccak256(walletPubKeyHash | redeemerOutputScript). The\n    ///         walletPubKeyHash is the 20-byte wallet's public key hash\n    ///         (computed using Bitcoin HASH160 over the compressed ECDSA\n    ///         public key) and redeemerOutputScript is a Bitcoin script\n    ///         (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock\n    ///         redeemed BTC as requested by the redeemer. Requests are added\n    ///         to this mapping by the `requestRedemption` method (duplicates\n    ///         not allowed) and are removed by one of the following methods:\n    ///         - `submitRedemptionProof` in case the request was handled\n    ///           successfully\n    ///         - `notifyRedemptionTimeout` in case the request was reported\n    ///           to be timed out\n    function pendingRedemptions(uint256 redemptionKey)\n        external\n        view\n        returns (Redemption.RedemptionRequest memory)\n    {\n        return self.pendingRedemptions[redemptionKey];\n    }\n\n    /// @notice Collection of all timed out redemptions requests indexed by\n    ///         redemption key built as\n    ///         keccak256(walletPubKeyHash | redeemerOutputScript). The\n    ///         walletPubKeyHash is the 20-byte wallet's public key hash\n    ///         (computed using Bitcoin HASH160 over the compressed ECDSA\n    ///         public key) and redeemerOutputScript is the Bitcoin script\n    ///         (P2PKH, P2WPKH, P2SH or P2WSH) that is involved in the timed\n    ///         out request. Timed out requests are stored in this mapping to\n    ///         avoid slashing the wallets multiple times for the same timeout.\n    ///         Only one method can add to this mapping:\n    ///         - `notifyRedemptionTimeout` which puts the redemption key\n    ///           to this mapping basing on a timed out request stored\n    ///           previously in `pendingRedemptions` mapping.\n    function timedOutRedemptions(uint256 redemptionKey)\n        external\n        view\n        returns (Redemption.RedemptionRequest memory)\n    {\n        return self.timedOutRedemptions[redemptionKey];\n    }\n\n    /// @notice Collection of main UTXOs that are honestly spent indexed by\n    ///         keccak256(fundingTxHash | fundingOutputIndex). The fundingTxHash\n    ///         is bytes32 (ordered as in Bitcoin internally) and\n    ///         fundingOutputIndex an uint32. A main UTXO is considered honestly\n    ///         spent if it was used as an input of a transaction that have been\n    ///         proven in the Bridge.\n    function spentMainUTXOs(uint256 utxoKey) external view returns (bool) {\n        return self.spentMainUTXOs[utxoKey];\n    }\n\n    /// @notice Gets details about a registered wallet.\n    /// @param walletPubKeyHash The 20-byte wallet public key hash (computed\n    ///        using Bitcoin HASH160 over the compressed ECDSA public key)\n    /// @return Wallet details.\n    function wallets(bytes20 walletPubKeyHash)\n        external\n        view\n        returns (Wallets.Wallet memory)\n    {\n        return self.registeredWallets[walletPubKeyHash];\n    }\n\n    /// @notice Gets the public key hash of the active wallet.\n    /// @return The 20-byte public key hash (computed using Bitcoin HASH160\n    ///         over the compressed ECDSA public key) of the active wallet.\n    ///         Returns bytes20(0) if there is no active wallet at the moment.\n    function activeWalletPubKeyHash() external view returns (bytes20) {\n        return self.activeWalletPubKeyHash;\n    }\n\n    /// @notice Gets the live wallets count.\n    /// @return The current count of wallets being in the Live state.\n    function liveWalletsCount() external view returns (uint32) {\n        return self.liveWalletsCount;\n    }\n\n    /// @notice Returns the fraud challenge identified by the given key built\n    ///         as keccak256(walletPublicKey|sighash).\n    function fraudChallenges(uint256 challengeKey)\n        external\n        view\n        returns (Fraud.FraudChallenge memory)\n    {\n        return self.fraudChallenges[challengeKey];\n    }\n\n    /// @notice Collection of all moved funds sweep requests indexed by\n    ///         `keccak256(movingFundsTxHash | movingFundsOutputIndex)`.\n    ///         The `movingFundsTxHash` is `bytes32` (ordered as in Bitcoin\n    ///         internally) and `movingFundsOutputIndex` an `uint32`. Each entry\n    ///         is actually an UTXO representing the moved funds and is supposed\n    ///         to be swept with the current main UTXO of the recipient wallet.\n    /// @param requestKey Request key built as\n    ///        `keccak256(movingFundsTxHash | movingFundsOutputIndex)`\n    /// @return Details of the moved funds sweep request.\n    function movedFundsSweepRequests(uint256 requestKey)\n        external\n        view\n        returns (MovingFunds.MovedFundsSweepRequest memory)\n    {\n        return self.movedFundsSweepRequests[requestKey];\n    }\n\n    /// @notice Indicates if the vault with the given address is trusted or not.\n    ///         Depositors can route their revealed deposits only to trusted\n    ///         vaults and have trusted vaults notified about new deposits as\n    ///         soon as these deposits get swept. Vaults not trusted by the\n    ///         Bridge can still be used by Bank balance owners on their own\n    ///         responsibility - anyone can approve their Bank balance to any\n    ///         address.\n    function isVaultTrusted(address vault) external view returns (bool) {\n        return self.isVaultTrusted[vault];\n    }\n\n    /// @notice Returns the current values of Bridge deposit parameters.\n    /// @return depositDustThreshold The minimal amount that can be requested\n    ///         to deposit. Value of this parameter must take into account the\n    ///         value of `depositTreasuryFeeDivisor` and `depositTxMaxFee`\n    ///         parameters in order to make requests that can incur the\n    ///         treasury and transaction fee and still satisfy the depositor.\n    /// @return depositTreasuryFeeDivisor Divisor used to compute the treasury\n    ///         fee taken from each deposit and transferred to the treasury upon\n    ///         sweep proof submission. That fee is computed as follows:\n    ///         `treasuryFee = depositedAmount / depositTreasuryFeeDivisor`\n    ///         For example, if the treasury fee needs to be 2% of each deposit,\n    ///         the `depositTreasuryFeeDivisor` should be set to `50`\n    ///         because `1/50 = 0.02 = 2%`.\n    /// @return depositTxMaxFee Maximum amount of BTC transaction fee that can\n    ///         be incurred by each swept deposit being part of the given sweep\n    ///         transaction. If the maximum BTC transaction fee is exceeded,\n    ///         such transaction is considered a fraud.\n    function depositParameters()\n        external\n        view\n        returns (\n            uint64 depositDustThreshold,\n            uint64 depositTreasuryFeeDivisor,\n            uint64 depositTxMaxFee\n        )\n    {\n        depositDustThreshold = self.depositDustThreshold;\n        depositTreasuryFeeDivisor = self.depositTreasuryFeeDivisor;\n        depositTxMaxFee = self.depositTxMaxFee;\n    }\n\n    /// @notice Returns the current values of Bridge redemption parameters.\n    /// @return redemptionDustThreshold The minimal amount that can be requested\n    ///         for redemption. Value of this parameter must take into account\n    ///         the value of `redemptionTreasuryFeeDivisor` and `redemptionTxMaxFee`\n    ///         parameters in order to make requests that can incur the\n    ///         treasury and transaction fee and still satisfy the redeemer.\n    /// @return redemptionTreasuryFeeDivisor Divisor used to compute the treasury\n    ///         fee taken from each redemption request and transferred to the\n    ///         treasury upon successful request finalization. That fee is\n    ///         computed as follows:\n    ///         `treasuryFee = requestedAmount / redemptionTreasuryFeeDivisor`\n    ///         For example, if the treasury fee needs to be 2% of each\n    ///         redemption request, the `redemptionTreasuryFeeDivisor` should\n    ///         be set to `50` because `1/50 = 0.02 = 2%`.\n    /// @return redemptionTxMaxFee Maximum amount of BTC transaction fee that\n    ///         can be incurred by each redemption request being part of the\n    ///         given redemption transaction. If the maximum BTC transaction\n    ///         fee is exceeded, such transaction is considered a fraud.\n    ///         This is a per-redemption output max fee for the redemption\n    ///         transaction.\n    /// @return redemptionTimeout Time after which the redemption request can be\n    ///         reported as timed out. It is counted from the moment when the\n    ///         redemption request was created via `requestRedemption` call.\n    ///         Reported  timed out requests are cancelled and locked TBTC is\n    ///         returned to the redeemer in full amount.\n    /// @return redemptionTimeoutSlashingAmount The amount of stake slashed\n    ///         from each member of a wallet for a redemption timeout.\n    /// @return redemptionTimeoutNotifierRewardMultiplier The percentage of the\n    ///         notifier reward from the staking contract the notifier of a\n    ///         redemption timeout receives. The value is in the range [0, 100].\n    function redemptionParameters()\n        external\n        view\n        returns (\n            uint64 redemptionDustThreshold,\n            uint64 redemptionTreasuryFeeDivisor,\n            uint64 redemptionTxMaxFee,\n            uint256 redemptionTimeout,\n            uint96 redemptionTimeoutSlashingAmount,\n            uint256 redemptionTimeoutNotifierRewardMultiplier\n        )\n    {\n        redemptionDustThreshold = self.redemptionDustThreshold;\n        redemptionTreasuryFeeDivisor = self.redemptionTreasuryFeeDivisor;\n        redemptionTxMaxFee = self.redemptionTxMaxFee;\n        redemptionTimeout = self.redemptionTimeout;\n        redemptionTimeoutSlashingAmount = self.redemptionTimeoutSlashingAmount;\n        redemptionTimeoutNotifierRewardMultiplier = self\n            .redemptionTimeoutNotifierRewardMultiplier;\n    }\n\n    /// @notice Returns the current values of Bridge moving funds between\n    ///         wallets parameters.\n    /// @return movingFundsTxMaxTotalFee Maximum amount of the total BTC\n    ///         transaction fee that is acceptable in a single moving funds\n    ///         transaction. This is a _total_ max fee for the entire moving\n    ///         funds transaction.\n    /// @return movingFundsDustThreshold The minimal satoshi amount that makes\n    ///         sense to be transferred during the moving funds process. Moving\n    ///         funds wallets having their BTC balance below that value can\n    ///         begin closing immediately as transferring such a low value may\n    ///         not be possible due to BTC network fees.\n    /// @return movingFundsTimeout Time after which the moving funds process\n    ///         can be reported as timed out. It is counted from the moment\n    ///         when the wallet was requested to move their funds and switched\n    ///         to the MovingFunds state. Value in seconds.\n    /// @return movingFundsTimeoutSlashingAmount The amount of stake slashed\n    ///         from each member of a wallet for a moving funds timeout.\n    /// @return movingFundsTimeoutNotifierRewardMultiplier The percentage of the\n    ///         notifier reward from the staking contract the notifier of a\n    ///         moving funds timeout receives. The value is in the range [0, 100].\n    /// @return movedFundsSweepTxMaxTotalFee Maximum amount of the total BTC\n    ///         transaction fee that is acceptable in a single moved funds\n    ///         sweep transaction. This is a _total_ max fee for the entire\n    ///         moved funds sweep transaction.\n    /// @return movedFundsSweepTimeout Time after which the moved funds sweep\n    ///         process can be reported as timed out. It is counted from the\n    ///         moment when the wallet was requested to sweep the received funds.\n    ///         Value in seconds.\n    /// @return movedFundsSweepTimeoutSlashingAmount The amount of stake slashed\n    ///         from each member of a wallet for a moved funds sweep timeout.\n    /// @return movedFundsSweepTimeoutNotifierRewardMultiplier The percentage\n    ///         of the notifier reward from the staking contract the notifier\n    ///         of a moved funds sweep timeout receives. The value is in the\n    ///         range [0, 100].\n    function movingFundsParameters()\n        external\n        view\n        returns (\n            uint64 movingFundsTxMaxTotalFee,\n            uint64 movingFundsDustThreshold,\n            uint32 movingFundsTimeout,\n            uint96 movingFundsTimeoutSlashingAmount,\n            uint256 movingFundsTimeoutNotifierRewardMultiplier,\n            uint64 movedFundsSweepTxMaxTotalFee,\n            uint32 movedFundsSweepTimeout,\n            uint96 movedFundsSweepTimeoutSlashingAmount,\n            uint256 movedFundsSweepTimeoutNotifierRewardMultiplier\n        )\n    {\n        movingFundsTxMaxTotalFee = self.movingFundsTxMaxTotalFee;\n        movingFundsDustThreshold = self.movingFundsDustThreshold;\n        movingFundsTimeout = self.movingFundsTimeout;\n        movingFundsTimeoutSlashingAmount = self\n            .movingFundsTimeoutSlashingAmount;\n        movingFundsTimeoutNotifierRewardMultiplier = self\n            .movingFundsTimeoutNotifierRewardMultiplier;\n        movedFundsSweepTxMaxTotalFee = self.movedFundsSweepTxMaxTotalFee;\n        movedFundsSweepTimeout = self.movedFundsSweepTimeout;\n        movedFundsSweepTimeoutSlashingAmount = self\n            .movedFundsSweepTimeoutSlashingAmount;\n        movedFundsSweepTimeoutNotifierRewardMultiplier = self\n            .movedFundsSweepTimeoutNotifierRewardMultiplier;\n    }\n\n    /// @return walletCreationPeriod Determines how frequently a new wallet\n    ///         creation can be requested. Value in seconds.\n    /// @return walletCreationMinBtcBalance The minimum BTC threshold in satoshi\n    ///         that is used to decide about wallet creation.\n    /// @return walletCreationMaxBtcBalance The maximum BTC threshold in satoshi\n    ///         that is used to decide about wallet creation.\n    /// @return walletClosureMinBtcBalance The minimum BTC threshold in satoshi\n    ///         that is used to decide about wallet closure.\n    /// @return walletMaxAge The maximum age of a wallet in seconds, after which\n    ///         the wallet moving funds process can be requested.\n    /// @return walletMaxBtcTransfer The maximum BTC amount in satoshi than\n    ///         can be transferred to a single target wallet during the moving\n    ///         funds process.\n    /// @return walletClosingPeriod Determines the length of the wallet closing\n    ///         period, i.e. the period when the wallet remains in the Closing\n    ///         state and can be subject of deposit fraud challenges. Value\n    ///         in seconds.\n    function walletParameters()\n        external\n        view\n        returns (\n            uint32 walletCreationPeriod,\n            uint64 walletCreationMinBtcBalance,\n            uint64 walletCreationMaxBtcBalance,\n            uint64 walletClosureMinBtcBalance,\n            uint32 walletMaxAge,\n            uint64 walletMaxBtcTransfer,\n            uint32 walletClosingPeriod\n        )\n    {\n        walletCreationPeriod = self.walletCreationPeriod;\n        walletCreationMinBtcBalance = self.walletCreationMinBtcBalance;\n        walletCreationMaxBtcBalance = self.walletCreationMaxBtcBalance;\n        walletClosureMinBtcBalance = self.walletClosureMinBtcBalance;\n        walletMaxAge = self.walletMaxAge;\n        walletMaxBtcTransfer = self.walletMaxBtcTransfer;\n        walletClosingPeriod = self.walletClosingPeriod;\n    }\n\n    /// @notice Returns the current values of Bridge fraud parameters.\n    /// @return fraudChallengeDepositAmount The amount of ETH in wei the party\n    ///         challenging the wallet for fraud needs to deposit.\n    /// @return fraudChallengeDefeatTimeout The amount of time the wallet has to\n    ///         defeat a fraud challenge.\n    /// @return fraudSlashingAmount The amount slashed from each wallet member\n    ///         for committing a fraud.\n    /// @return fraudNotifierRewardMultiplier The percentage of the notifier\n    ///         reward from the staking contract the notifier of a fraud\n    ///         receives. The value is in the range [0, 100].\n    function fraudParameters()\n        external\n        view\n        returns (\n            uint256 fraudChallengeDepositAmount,\n            uint256 fraudChallengeDefeatTimeout,\n            uint96 fraudSlashingAmount,\n            uint256 fraudNotifierRewardMultiplier\n        )\n    {\n        fraudChallengeDepositAmount = self.fraudChallengeDepositAmount;\n        fraudChallengeDefeatTimeout = self.fraudChallengeDefeatTimeout;\n        fraudSlashingAmount = self.fraudSlashingAmount;\n        fraudNotifierRewardMultiplier = self.fraudNotifierRewardMultiplier;\n    }\n\n    /// @notice Returns the addresses of contracts Bridge is interacting with.\n    /// @return bank Address of the Bank the Bridge belongs to.\n    /// @return relay Address of the Bitcoin relay providing the current Bitcoin\n    ///         network difficulty.\n    /// @return ecdsaWalletRegistry Address of the ECDSA Wallet Registry.\n    function contractReferences()\n        external\n        view\n        returns (\n            Bank bank,\n            IRelay relay,\n            EcdsaWalletRegistry ecdsaWalletRegistry\n        )\n    {\n        bank = self.bank;\n        relay = self.relay;\n        ecdsaWalletRegistry = self.ecdsaWalletRegistry;\n    }\n\n    /// @notice Address where the deposit treasury fees will be sent to.\n    ///         Treasury takes part in the operators rewarding process.\n    function treasury() external view returns (address) {\n        return self.treasury;\n    }\n\n    /// @notice The number of confirmations on the Bitcoin chain required to\n    ///         successfully evaluate an SPV proof.\n    function txProofDifficultyFactor() external view returns (uint256) {\n        return self.txProofDifficultyFactor;\n    }\n}\n"
     },
     "@keep-network/random-beacon/contracts/Governable.sol": {
       "content": "// SPDX-License-Identifier: MIT\n//\n// ▓▓▌ ▓▓ ▐▓▓ ▓▓▓▓▓▓▓▓▓▓▌▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▄\n// ▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▌▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓\n//   ▓▓▓▓▓▓    ▓▓▓▓▓▓▓▀    ▐▓▓▓▓▓▓    ▐▓▓▓▓▓   ▓▓▓▓▓▓     ▓▓▓▓▓   ▐▓▓▓▓▓▌   ▐▓▓▓▓▓▓\n//   ▓▓▓▓▓▓▄▄▓▓▓▓▓▓▓▀      ▐▓▓▓▓▓▓▄▄▄▄         ▓▓▓▓▓▓▄▄▄▄         ▐▓▓▓▓▓▌   ▐▓▓▓▓▓▓\n//   ▓▓▓▓▓▓▓▓▓▓▓▓▓▀        ▐▓▓▓▓▓▓▓▓▓▓         ▓▓▓▓▓▓▓▓▓▓         ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓\n//   ▓▓▓▓▓▓▀▀▓▓▓▓▓▓▄       ▐▓▓▓▓▓▓▀▀▀▀         ▓▓▓▓▓▓▀▀▀▀         ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▀\n//   ▓▓▓▓▓▓   ▀▓▓▓▓▓▓▄     ▐▓▓▓▓▓▓     ▓▓▓▓▓   ▓▓▓▓▓▓     ▓▓▓▓▓   ▐▓▓▓▓▓▌\n// ▓▓▓▓▓▓▓▓▓▓ █▓▓▓▓▓▓▓▓▓ ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓▓▓\n// ▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓ ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓▓▓\n//\n//                           Trust math, not hardware.\n\npragma solidity ^0.8.9;\n\n/// @notice Governable contract.\n/// @dev A constructor is not defined, which makes the contract compatible with\n///      upgradable proxies. This requires calling explicitly `_transferGovernance`\n///      function in a child contract.\nabstract contract Governable {\n    // Governance of the contract\n    // The variable should be initialized by the implementing contract.\n    // slither-disable-next-line uninitialized-state\n    address public governance;\n\n    event GovernanceTransferred(address oldGovernance, address newGovernance);\n\n    modifier onlyGovernance() virtual {\n        require(governance == msg.sender, \"Caller is not the governance\");\n        _;\n    }\n\n    /// @notice Transfers governance of the contract to `newGovernance`.\n    function transferGovernance(address newGovernance)\n        external\n        virtual\n        onlyGovernance\n    {\n        require(\n            newGovernance != address(0),\n            \"New governance is the zero address\"\n        );\n        _transferGovernance(newGovernance);\n    }\n\n    function _transferGovernance(address newGovernance) internal virtual {\n        address oldGovernance = governance;\n        governance = newGovernance;\n        emit GovernanceTransferred(oldGovernance, newGovernance);\n    }\n}\n"
@@ -169,11 +172,8 @@
     "@keep-network/ecdsa/contracts/api/IWalletOwner.sol": {
       "content": "// SPDX-License-Identifier: MIT\n//\n// ▓▓▌ ▓▓ ▐▓▓ ▓▓▓▓▓▓▓▓▓▓▌▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▄\n// ▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▌▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓\n//   ▓▓▓▓▓▓    ▓▓▓▓▓▓▓▀    ▐▓▓▓▓▓▓    ▐▓▓▓▓▓   ▓▓▓▓▓▓     ▓▓▓▓▓   ▐▓▓▓▓▓▌   ▐▓▓▓▓▓▓\n//   ▓▓▓▓▓▓▄▄▓▓▓▓▓▓▓▀      ▐▓▓▓▓▓▓▄▄▄▄         ▓▓▓▓▓▓▄▄▄▄         ▐▓▓▓▓▓▌   ▐▓▓▓▓▓▓\n//   ▓▓▓▓▓▓▓▓▓▓▓▓▓▀        ▐▓▓▓▓▓▓▓▓▓▓         ▓▓▓▓▓▓▓▓▓▓         ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓\n//   ▓▓▓▓▓▓▀▀▓▓▓▓▓▓▄       ▐▓▓▓▓▓▓▀▀▀▀         ▓▓▓▓▓▓▀▀▀▀         ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▀\n//   ▓▓▓▓▓▓   ▀▓▓▓▓▓▓▄     ▐▓▓▓▓▓▓     ▓▓▓▓▓   ▓▓▓▓▓▓     ▓▓▓▓▓   ▐▓▓▓▓▓▌\n// ▓▓▓▓▓▓▓▓▓▓ █▓▓▓▓▓▓▓▓▓ ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓▓▓\n// ▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓ ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓▓▓\n//\n//                           Trust math, not hardware.\n\npragma solidity ^0.8.9;\n\ninterface IWalletOwner {\n    /// @notice Callback function executed once a new wallet is created.\n    /// @dev Should be callable only by the Wallet Registry.\n    /// @param walletID Wallet's unique identifier.\n    /// @param publicKeyY Wallet's public key's X coordinate.\n    /// @param publicKeyY Wallet's public key's Y coordinate.\n    function __ecdsaWalletCreatedCallback(\n        bytes32 walletID,\n        bytes32 publicKeyX,\n        bytes32 publicKeyY\n    ) external;\n\n    /// @notice Callback function executed once a wallet heartbeat failure\n    ///         is detected.\n    /// @dev Should be callable only by the Wallet Registry.\n    /// @param walletID Wallet's unique identifier.\n    /// @param publicKeyY Wallet's public key's X coordinate.\n    /// @param publicKeyY Wallet's public key's Y coordinate.\n    function __ecdsaWalletHeartbeatFailedCallback(\n        bytes32 walletID,\n        bytes32 publicKeyX,\n        bytes32 publicKeyY\n    ) external;\n}\n"
     },
-    "contracts/bridge/Sweep.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\";\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 Sweep {\n    using BridgeState for BridgeState.Storage;\n    using BitcoinTx for BridgeState.Storage;\n\n    using BTCUtils for bytes;\n\n    /// @notice Represents an outcome of the sweep Bitcoin transaction\n    ///         inputs processing.\n    struct SweepTxInputsInfo {\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    }\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    /// @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    ///      - `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 submitSweepProof(\n        BridgeState.Storage storage self,\n        BitcoinTx.Info calldata sweepTx,\n        BitcoinTx.Proof calldata sweepProof,\n        BitcoinTx.UTXO calldata mainUtxo\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        ) = processSweepTxOutput(sweepTx.outputVector);\n\n        (\n            Wallets.Wallet storage wallet,\n            BitcoinTx.UTXO memory resolvedMainUtxo\n        ) = resolveSweepingWallet(self, walletPubKeyHash, mainUtxo);\n\n        // Process sweep transaction inputs and extract all information needed\n        // to perform deposit bookkeeping.\n        SweepTxInputsInfo memory inputsInfo = processSweepTxInputs(\n            self,\n            sweepTx.inputVector,\n            resolvedMainUtxo\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        ) = sweepTxFeeDistribution(\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        emit DepositsSwept(walletPubKeyHash, sweepTxHash);\n\n        // Update depositors balances in the Bank.\n        self.bank.increaseBalances(\n            inputsInfo.depositors,\n            inputsInfo.depositedAmounts\n        );\n        // Pass the treasury fee to the treasury address.\n        self.bank.increaseBalance(self.treasury, totalTreasuryFee);\n\n        // TODO: Handle deposits having `vault` set.\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    /// @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 resolveSweepingWallet(\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 processSweepTxOutput(bytes memory sweepTxOutputVector)\n        internal\n        pure\n        returns (bytes20 walletPubKeyHash, uint64 value)\n    {\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        value = output.extractValue();\n        bytes memory walletPubKeyHashBytes = output.extractHash();\n        // The sweep transaction output should always be P2PKH or P2WPKH.\n        // In both cases, the wallet public key hash should be 20 bytes length.\n        require(\n            walletPubKeyHashBytes.length == 20,\n            \"Wallet public key hash should have 20 bytes\"\n        );\n        /* solhint-disable-next-line no-inline-assembly */\n        assembly {\n            walletPubKeyHash := mload(add(walletPubKeyHashBytes, 32))\n        }\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    /// @param sweepTxInputVector Bitcoin sweep transaction input vector.\n    ///        This function assumes vector's structure is valid so it must be\n    ///        validated using e.g. `BTCUtils.validateVin` function before\n    ///        it is passed here\n    /// @param mainUtxo Data of the wallet's main UTXO. If no main UTXO\n    ///        exists for the given the wallet, this parameter's fields should\n    ///        be zeroed to bypass the main UTXO validation\n    /// @return info Outcomes of the processing.\n    function processSweepTxInputs(\n        BridgeState.Storage storage self,\n        bytes memory sweepTxInputVector,\n        BitcoinTx.UTXO memory mainUtxo\n    ) internal returns (SweepTxInputsInfo memory info) {\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 = 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        (\n            uint256 inputsCompactSizeUintLength,\n            uint256 inputsCount\n        ) = sweepTxInputVector.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        info.depositors = new address[](\n            !mainUtxoExpected ? inputsCount : inputsCount - 1\n        );\n        info.depositedAmounts = new uint256[](info.depositors.length);\n        info.treasuryFees = new uint256[](info.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            ) = parseTxInputAt(sweepTxInputVector, inputStartingIndex);\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                if (processedDepositsCount == info.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                info.depositors[processedDepositsCount] = deposit.depositor;\n                info.depositedAmounts[processedDepositsCount] = deposit.amount;\n                info.inputsTotalValue += info.depositedAmounts[\n                    processedDepositsCount\n                ];\n                info.treasuryFees[processedDepositsCount] = deposit.treasuryFee;\n\n                processedDepositsCount++;\n            } else if (\n                mainUtxoExpected != mainUtxoFound &&\n                mainUtxo.txHash == outpointTxHash\n            ) {\n                // If we entered here, that means the input was identified as\n                // the expected main UTXO.\n                info.inputsTotalValue += mainUtxo.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 == info.depositors.length == info.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 info;\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 parseTxInputAt(\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 sweepTxFeeDistribution(\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/MovingFunds.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 \"./Redemption.sol\";\nimport \"./Wallets.sol\";\n\n/// @title Moving Bridge wallet funds\n/// @notice The library handles the logic for moving Bitcoin between Bridge\n///         wallets.\n/// @dev A wallet that failed a heartbeat, did not process requested redemption\n///      on time, or qualifies to be closed, begins the procedure of moving\n///      funds to other wallets in the Bridge. The wallet needs to commit to\n///      which other Live wallets it is moving the funds to and then, provide an\n///      SPV proof of moving funds to the previously committed wallets.\nlibrary MovingFunds {\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    event MovingFundsCommitmentSubmitted(\n        bytes20 walletPubKeyHash,\n        bytes20[] targetWallets,\n        address submitter\n    );\n\n    event MovingFundsCompleted(\n        bytes20 walletPubKeyHash,\n        bytes32 movingFundsTxHash\n    );\n\n    event MovingFundsTimedOut(bytes20 walletPubKeyHash);\n\n    event MovingFundsBelowDustReported(bytes20 walletPubKeyHash);\n\n    /// @notice Submits the moving funds target wallets commitment.\n    ///         Once all requirements are met, that function registers the\n    ///         target wallets commitment and opens the way for moving funds\n    ///         proof submission.\n    /// @param walletPubKeyHash 20-byte public key hash of the source wallet\n    /// @param walletMainUtxo Data of the source wallet's main UTXO, as\n    ///        currently known on the Ethereum chain\n    /// @param walletMembersIDs Identifiers of the source wallet signing group\n    ///        members\n    /// @param walletMemberIndex Position of the caller in the source wallet\n    ///        signing group members list\n    /// @param targetWallets List of 20-byte public key hashes of the target\n    ///        wallets that the source wallet commits to move the funds to\n    /// @dev Requirements:\n    ///      - The source wallet must be in the MovingFunds state\n    ///      - The source wallet must not have pending redemption requests\n    ///      - The source wallet must not have submitted its commitment already\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given source wallet in the ECDSA registry. Those IDs are\n    ///        not directly stored in the contract for gas efficiency purposes\n    ///        but they can be read from appropriate `DkgResultSubmitted`\n    ///        and `DkgResultApproved` events.\n    ///      - The `walletMemberIndex` must be in range [1, walletMembersIDs.length]\n    ///      - The caller must be the member of the source wallet signing group\n    ///        at the position indicated by `walletMemberIndex` parameter\n    ///      - The `walletMainUtxo` components must point to the recent main\n    ///        UTXO of the source wallet, as currently known on the Ethereum\n    ///        chain.\n    ///      - Source wallet BTC balance must be greater than zero\n    ///      - At least one Live wallet must exist in the system\n    ///      - Submitted target wallets count must match the expected count\n    ///        `N = min(liveWalletsCount, ceil(walletBtcBalance / walletMaxBtcTransfer))`\n    ///        where `N > 0`\n    ///      - Each target wallet must be not equal to the source wallet\n    ///      - Each target wallet must follow the expected order i.e. all\n    ///        target wallets 20-byte public key hashes represented as numbers\n    ///        must form a strictly increasing sequence without duplicates.\n    ///      - Each target wallet must be in Live state\n    function submitMovingFundsCommitment(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata walletMainUtxo,\n        uint32[] calldata walletMembersIDs,\n        uint256 walletMemberIndex,\n        bytes20[] calldata targetWallets\n    ) external {\n        Wallets.Wallet storage wallet = self.registeredWallets[\n            walletPubKeyHash\n        ];\n\n        require(\n            wallet.state == Wallets.WalletState.MovingFunds,\n            \"Source wallet must be in MovingFunds state\"\n        );\n\n        require(\n            wallet.pendingRedemptionsValue == 0,\n            \"Source wallet must handle all pending redemptions first\"\n        );\n\n        require(\n            wallet.movingFundsTargetWalletsCommitmentHash == bytes32(0),\n            \"Target wallets commitment already submitted\"\n        );\n\n        require(\n            self.ecdsaWalletRegistry.isWalletMember(\n                wallet.ecdsaWalletID,\n                walletMembersIDs,\n                msg.sender,\n                walletMemberIndex\n            ),\n            \"Caller is not a member of the source wallet\"\n        );\n\n        uint64 walletBtcBalance = self.getWalletBtcBalance(\n            walletPubKeyHash,\n            walletMainUtxo\n        );\n\n        require(walletBtcBalance > 0, \"Wallet BTC balance is zero\");\n\n        uint256 expectedTargetWalletsCount = Math.min(\n            self.liveWalletsCount,\n            Math.ceilDiv(walletBtcBalance, self.walletMaxBtcTransfer)\n        );\n\n        // This requirement fails only when `liveWalletsCount` is zero. In\n        // that case, the system cannot accept the commitment and must provide\n        // new wallets first.\n        //\n        // TODO: Expose separate function to reset the moving funds timeout\n        //       if no Live wallets exist in the system.\n        require(expectedTargetWalletsCount > 0, \"No target wallets available\");\n\n        require(\n            targetWallets.length == expectedTargetWalletsCount,\n            \"Submitted target wallets count is other than expected\"\n        );\n\n        uint160 lastProcessedTargetWallet = 0;\n\n        for (uint256 i = 0; i < targetWallets.length; i++) {\n            bytes20 targetWallet = targetWallets[i];\n\n            require(\n                targetWallet != walletPubKeyHash,\n                \"Submitted target wallet cannot be equal to the source wallet\"\n            );\n\n            require(\n                uint160(targetWallet) > lastProcessedTargetWallet,\n                \"Submitted target wallet breaks the expected order\"\n            );\n\n            require(\n                self.registeredWallets[targetWallet].state ==\n                    Wallets.WalletState.Live,\n                \"Submitted target wallet must be in Live state\"\n            );\n\n            lastProcessedTargetWallet = uint160(targetWallet);\n        }\n\n        wallet.movingFundsTargetWalletsCommitmentHash = keccak256(\n            abi.encodePacked(targetWallets)\n        );\n\n        emit MovingFundsCommitmentSubmitted(\n            walletPubKeyHash,\n            targetWallets,\n            msg.sender\n        );\n    }\n\n    /// @notice Used by the wallet to prove the BTC moving funds transaction\n    ///         and to make the necessary state changes. Moving funds is only\n    ///         accepted if it satisfies SPV proof.\n    ///\n    ///         The function validates the moving funds transaction structure\n    ///         by checking if it actually spends the main UTXO of the declared\n    ///         wallet and locks the value on the pre-committed target wallets\n    ///         using a reasonable transaction fee. If all preconditions are\n    ///         met, this functions closes the source wallet.\n    ///\n    ///         It is possible to prove the given moving funds transaction only\n    ///         one time.\n    /// @param movingFundsTx Bitcoin moving funds transaction data\n    /// @param movingFundsProof Bitcoin moving funds proof data\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    ///        HASH160 over the compressed ECDSA public key) of the wallet\n    ///        which performed the moving funds transaction\n    /// @dev Requirements:\n    ///      - `movingFundsTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash.\n    ///      - The `movingFundsTx` should represent a Bitcoin transaction with\n    ///        exactly 1 input that refers to the wallet's main UTXO. That\n    ///        transaction should have 1..n outputs corresponding to the\n    ///        pre-committed target wallets. Outputs must be ordered in the\n    ///        same way as their corresponding target wallets are ordered\n    ///        within the target wallets commitment.\n    ///      - `movingFundsProof` components must match the expected structure.\n    ///        See `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant.\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        Additionally, the recent main UTXO on Ethereum must be set.\n    ///      - `walletPubKeyHash` must be connected with the main UTXO used\n    ///        as transaction single input.\n    ///      - The wallet that `walletPubKeyHash` points to must be in the\n    ///        MovingFunds state.\n    ///      - The target wallets commitment must be submitted by the wallet\n    ///        that `walletPubKeyHash` points to.\n    ///      - The total Bitcoin transaction fee must be lesser or equal\n    ///        to `movingFundsTxMaxTotalFee` governable parameter.\n    function submitMovingFundsProof(\n        BridgeState.Storage storage self,\n        BitcoinTx.Info calldata movingFundsTx,\n        BitcoinTx.Proof calldata movingFundsProof,\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 movingFundsTxHash = self.validateProof(\n            movingFundsTx,\n            movingFundsProof\n        );\n\n        // Process the moving funds transaction input. Specifically, check if\n        // it refers to the expected wallet's main UTXO.\n        OutboundTx.processWalletOutboundTxInput(\n            self,\n            movingFundsTx.inputVector,\n            mainUtxo,\n            walletPubKeyHash\n        );\n\n        (\n            bytes32 targetWalletsHash,\n            uint256 outputsTotalValue\n        ) = processMovingFundsTxOutputs(movingFundsTx.outputVector);\n\n        require(\n            mainUtxo.txOutputValue - outputsTotalValue <=\n                self.movingFundsTxMaxTotalFee,\n            \"Transaction fee is too high\"\n        );\n\n        self.notifyWalletFundsMoved(walletPubKeyHash, targetWalletsHash);\n        // slither-disable-next-line reentrancy-events\n        emit MovingFundsCompleted(walletPubKeyHash, movingFundsTxHash);\n    }\n\n    /// @notice Processes the moving funds Bitcoin transaction output vector\n    ///         and extracts information required for further processing.\n    /// @param movingFundsTxOutputVector Bitcoin moving funds 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    /// @return targetWalletsHash keccak256 hash over the list of actual\n    ///         target wallets used in the transaction.\n    /// @return outputsTotalValue Sum of all outputs values.\n    /// @dev Requirements:\n    ///      - The `movingFundsTxOutputVector` must be parseable, i.e. must\n    ///        be validated by the caller as stated in their parameter doc.\n    ///      - Each output must refer to a 20-byte public key hash.\n    ///      - The total outputs value must be evenly divided over all outputs.\n    function processMovingFundsTxOutputs(bytes memory movingFundsTxOutputVector)\n        internal\n        pure\n        returns (bytes32 targetWalletsHash, uint256 outputsTotalValue)\n    {\n        // Determining the total number of Bitcoin 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        ) = movingFundsTxOutputVector.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        bytes20[] memory targetWallets = new bytes20[](outputsCount);\n        uint64[] memory outputsValues = new uint64[](outputsCount);\n\n        // Outputs processing loop.\n        for (uint256 i = 0; i < outputsCount; i++) {\n            uint256 outputLength = movingFundsTxOutputVector\n                .determineOutputLengthAt(outputStartingIndex);\n\n            bytes memory output = movingFundsTxOutputVector.slice(\n                outputStartingIndex,\n                outputLength\n            );\n\n            // Extract the output script payload.\n            bytes memory targetWalletPubKeyHashBytes = output.extractHash();\n            // Output script payload must refer to a known wallet public key\n            // hash which is always 20-byte.\n            require(\n                targetWalletPubKeyHashBytes.length == 20,\n                \"Target wallet public key hash must have 20 bytes\"\n            );\n\n            bytes20 targetWalletPubKeyHash = targetWalletPubKeyHashBytes\n                .slice20(0);\n\n            // The next step is making 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 targetWalletP2PKHScriptKeccak = keccak256(\n                abi.encodePacked(\n                    hex\"1976a914\",\n                    targetWalletPubKeyHash,\n                    hex\"88ac\"\n                )\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 targetWalletP2WPKHScriptKeccak = keccak256(\n                abi.encodePacked(hex\"160014\", targetWalletPubKeyHash)\n            );\n            // Make sure the actual output script matches either the P2PKH\n            // or P2WPKH format.\n            require(\n                outputScriptKeccak == targetWalletP2PKHScriptKeccak ||\n                    outputScriptKeccak == targetWalletP2WPKHScriptKeccak,\n                \"Output must be P2PKH or P2WPKH\"\n            );\n\n            // Add the wallet public key hash to the list that will be used\n            // to build the result list hash. There is no need to check if\n            // given output is a change here because the actual target wallet\n            // list must be exactly the same as the pre-committed target wallet\n            // list which is guaranteed to be valid.\n            targetWallets[i] = targetWalletPubKeyHash;\n\n            // Extract the value from given output.\n            outputsValues[i] = output.extractValue();\n            outputsTotalValue += outputsValues[i];\n\n            // Make the `outputStartingIndex` pointing to the next output by\n            // increasing it by current output's length.\n            outputStartingIndex += outputLength;\n        }\n\n        // Compute the indivisible remainder that remains after dividing the\n        // outputs total value over all outputs evenly.\n        uint256 outputsTotalValueRemainder = outputsTotalValue % outputsCount;\n        // Compute the minimum allowed output value by dividing the outputs\n        // total value (reduced by the remainder) by the number of outputs.\n        uint256 minOutputValue = (outputsTotalValue -\n            outputsTotalValueRemainder) / outputsCount;\n        // Maximum possible value is the minimum value with the remainder included.\n        uint256 maxOutputValue = minOutputValue + outputsTotalValueRemainder;\n\n        for (uint256 i = 0; i < outputsCount; i++) {\n            require(\n                minOutputValue <= outputsValues[i] &&\n                    outputsValues[i] <= maxOutputValue,\n                \"Transaction amount is not distributed evenly\"\n            );\n        }\n\n        targetWalletsHash = keccak256(abi.encodePacked(targetWallets));\n\n        return (targetWalletsHash, outputsTotalValue);\n    }\n\n    /// @notice Notifies about a timed out moving funds process. Terminates\n    ///         the wallet and slashes signing group members as a result.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param walletMembersIDs Identifiers of the wallet signing group members\n    /// @dev Requirements:\n    ///      - The wallet must be in the MovingFunds state\n    ///      - The moving funds timeout must be actually exceeded\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract\n    function notifyMovingFundsTimeout(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        uint32[] calldata walletMembersIDs\n    ) external {\n        Wallets.Wallet storage wallet = self.registeredWallets[\n            walletPubKeyHash\n        ];\n\n        require(\n            wallet.state == Wallets.WalletState.MovingFunds,\n            \"ECDSA wallet must be in MovingFunds state\"\n        );\n\n        require(\n            /* solhint-disable-next-line not-rely-on-time */\n            block.timestamp >\n                wallet.movingFundsRequestedAt + self.movingFundsTimeout,\n            \"Moving funds has not timed out yet\"\n        );\n\n        self.terminateWallet(walletPubKeyHash);\n\n        self.ecdsaWalletRegistry.seize(\n            self.movingFundsTimeoutSlashingAmount,\n            self.movingFundsTimeoutNotifierRewardMultiplier,\n            msg.sender,\n            wallet.ecdsaWalletID,\n            walletMembersIDs\n        );\n\n        // slither-disable-next-line reentrancy-events\n        emit MovingFundsTimedOut(walletPubKeyHash);\n    }\n\n    /// @notice Notifies about a moving funds wallet whose BTC balance is\n    ///         below the moving funds dust threshold. Ends the moving funds\n    ///         process and begins wallet closing immediately.\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known\n    ///        on the Ethereum chain.\n    /// @dev Requirements:\n    ///      - The wallet must be in the MovingFunds state\n    ///      - The `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        If the wallet has no main UTXO, this parameter can be empty as it\n    ///        is ignored.\n    ///      - The wallet BTC balance must be below the moving funds threshold\n    function notifyMovingFundsBelowDust(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata mainUtxo\n    ) external {\n        Wallets.Wallet storage wallet = self.registeredWallets[\n            walletPubKeyHash\n        ];\n\n        require(\n            wallet.state == Wallets.WalletState.MovingFunds,\n            \"ECDSA wallet must be in MovingFunds state\"\n        );\n\n        uint64 walletBtcBalance = self.getWalletBtcBalance(\n            walletPubKeyHash,\n            mainUtxo\n        );\n\n        require(\n            walletBtcBalance < self.movingFundsDustThreshold,\n            \"Wallet BTC balance must be below the moving funds dust threshold\"\n        );\n\n        self.beginWalletClosing(walletPubKeyHash);\n\n        // slither-disable-next-line reentrancy-events\n        emit MovingFundsBelowDustReported(walletPubKeyHash);\n    }\n}\n"
+    "contracts/bridge/DepositSweep.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\";\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 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    }\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    /// @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    ///      - `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    ) 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(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                sweepTx.inputVector,\n                resolvedMainUtxo\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        emit DepositsSwept(walletPubKeyHash, sweepTxHash);\n\n        // Update depositors balances in the Bank.\n        self.bank.increaseBalances(\n            inputsInfo.depositors,\n            inputsInfo.depositedAmounts\n        );\n        // Pass the treasury fee to the treasury address.\n        self.bank.increaseBalance(self.treasury, totalTreasuryFee);\n\n        // TODO: Handle deposits having `vault` set.\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(bytes memory sweepTxOutputVector)\n        internal\n        pure\n        returns (bytes20 walletPubKeyHash, uint64 value)\n    {\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        value = output.extractValue();\n        // TODO: Extract `walletPubKeyHash` using `self.extractPubKeyHash`\n        //       in order to get stronger validation.\n        bytes memory walletPubKeyHashBytes = output.extractHash();\n        // The sweep transaction output should always be P2PKH or P2WPKH.\n        // In both cases, the wallet public key hash should be 20 bytes length.\n        require(\n            walletPubKeyHashBytes.length == 20,\n            \"Wallet public key hash should have 20 bytes\"\n        );\n        /* solhint-disable-next-line no-inline-assembly */\n        assembly {\n            walletPubKeyHash := mload(add(walletPubKeyHashBytes, 32))\n        }\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    /// @param sweepTxInputVector Bitcoin sweep transaction input vector.\n    ///        This function assumes vector's structure is valid so it must be\n    ///        validated using e.g. `BTCUtils.validateVin` function before\n    ///        it is passed here\n    /// @param mainUtxo Data of the wallet's main UTXO. If no main UTXO\n    ///        exists for the given the wallet, this parameter's fields should\n    ///        be zeroed to bypass the main UTXO validation\n    /// @return info Outcomes of the processing.\n    function processDepositSweepTxInputs(\n        BridgeState.Storage storage self,\n        bytes memory sweepTxInputVector,\n        BitcoinTx.UTXO memory mainUtxo\n    ) internal returns (DepositSweepTxInputsInfo memory info) {\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 = 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        (\n            uint256 inputsCompactSizeUintLength,\n            uint256 inputsCount\n        ) = sweepTxInputVector.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        info.depositors = new address[](\n            !mainUtxoExpected ? inputsCount : inputsCount - 1\n        );\n        info.depositedAmounts = new uint256[](info.depositors.length);\n        info.treasuryFees = new uint256[](info.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                    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                if (processedDepositsCount == info.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                info.depositors[processedDepositsCount] = deposit.depositor;\n                info.depositedAmounts[processedDepositsCount] = deposit.amount;\n                info.inputsTotalValue += info.depositedAmounts[\n                    processedDepositsCount\n                ];\n                info.treasuryFees[processedDepositsCount] = deposit.treasuryFee;\n\n                processedDepositsCount++;\n            } else if (\n                mainUtxoExpected != mainUtxoFound &&\n                mainUtxo.txHash == outpointTxHash\n                // TODO: We probably need to check `mainUtxo.txOutputIndex == outpointIndex` as well.\n            ) {\n                // If we entered here, that means the input was identified as\n                // the expected main UTXO.\n                info.inputsTotalValue += mainUtxo.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 == info.depositors.length == info.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 info;\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/test/TestRelay.sol": {
       "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.9;\n\nimport \"../bridge/Bridge.sol\";\n\ncontract TestRelay is IRelay {\n    uint256 private currentEpochDifficulty;\n    uint256 private prevEpochDifficulty;\n\n    function setCurrentEpochDifficulty(uint256 _difficulty) external {\n        currentEpochDifficulty = _difficulty;\n    }\n\n    function setPrevEpochDifficulty(uint256 _difficulty) external {\n        prevEpochDifficulty = _difficulty;\n    }\n\n    function getCurrentEpochDifficulty()\n        external\n        view\n        override\n        returns (uint256)\n    {\n        return currentEpochDifficulty;\n    }\n\n    function getPrevEpochDifficulty() external view override returns (uint256) {\n        return prevEpochDifficulty;\n    }\n}\n"