@keep-network/tbtc-v2 0.1.1-dev.63 → 0.1.1-dev.64

package/artifacts/solcInputs/{888980850d09abe497842d2096dd7e11.json → 2190be89eb3998f4cbf0924da2c5641c.json}

@@ -167,7 +167,7 @@
       "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 setProcessedMovedFundsSweepRequests(\n        BitcoinTx.UTXO[] calldata utxos\n    ) 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.movedFundsSweepRequests[utxoKey].state = MovingFunds\n                .MovedFundsSweepRequestState\n                .Processed;\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 \"./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 Allows to defeat a pending fraud challenge against a wallet by\n    ///         proving the sighash and signature were produced for an off-chain\n    ///         wallet heartbeat message following a strict format.\n    ///         In order to defeat the challenge the same `walletPublicKey` and\n    ///         signature (represented by `r`, `s` and `v`) must be provided as\n    ///         were used to calculate the sighash during heartbeat message\n    ///         signing. The fraud challenge defeat attempt will only succeed if\n    ///         the signed message follows a strict format required for\n    ///         heartbeat messages. If successfully defeated, the fraud\n    ///         challenge is marked as resolved and the amount of ether\n    ///         deposited by the challenger is sent to the treasury.\n    /// @param walletPublicKey The public key of the wallet in the uncompressed\n    ///        and unprefixed format (64 bytes)\n    /// @param heartbeatMessage Off-chain heartbeat message meeting the heartbeat\n    ///        message format requirements which produces sighash used to\n    ///        generate the ECDSA signature that is the subject of the fraud\n    ///        claim\n    /// @dev Requirements:\n    ///      - `walletPublicKey` and `sighash` calculated as\n    ///        `hash256(heartbeatMessage)` must identify an open fraud challenge\n    ///      - `heartbeatMessage` must follow a strict format of heartbeat\n    ///        messages\n    function defeatFraudChallengeWithHeartbeat(\n        bytes calldata walletPublicKey,\n        bytes calldata heartbeatMessage\n    ) external {\n        self.defeatFraudChallengeWithHeartbeat(\n            walletPublicKey,\n            heartbeatMessage\n        );\n    }\n\n    /// @notice Notifies about defeat timeout for the given fraud challenge.\n    ///         Can be called only if there was a fraud challenge identified by\n    ///         the provided `walletPublicKey` and `sighash` and it was not\n    ///         defeated on time. The amount of time that needs to pass after\n    ///         a fraud challenge is reported is indicated by the\n    ///         `challengeDefeatTimeout`. After a successful fraud challenge\n    ///         defeat timeout notification the fraud challenge is marked as\n    ///         resolved, the stake of each operator is slashed, the ether\n    ///         deposited is returned to the challenger and the challenger is\n    ///         rewarded.\n    /// @param walletPublicKey The public key of the wallet in the uncompressed\n    ///        and unprefixed format (64 bytes)\n    /// @param walletMembersIDs Identifiers of the wallet signing group members\n    /// @param 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"
+      "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    /// @param vault Optional address of the vault where all swept deposits\n    ///        should be routed to. All deposits swept as part of the transaction\n    ///        must have their `vault` parameters set to the same address.\n    ///        If this parameter is set to an address of a trusted vault, swept\n    ///        deposits are routed to that vault.\n    ///        If this parameter is set to the zero address or to an address\n    ///        of a non-trusted vault, swept deposits are not routed to a\n    ///        vault but depositors' balances are increased in the Bank\n    ///        individually.\n    /// @dev Requirements:\n    ///      - `sweepTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash.\n    ///      - The `sweepTx` should represent a Bitcoin transaction with 1..n\n    ///        inputs. If the wallet has no main UTXO, all n inputs should\n    ///        correspond to P2(W)SH revealed deposits UTXOs. If the wallet has\n    ///        an existing main UTXO, one of the n inputs must point to that\n    ///        main UTXO and remaining n-1 inputs should correspond to P2(W)SH\n    ///        revealed deposits UTXOs. That transaction must have only\n    ///        one P2(W)PKH output locking funds on the 20-byte wallet public\n    ///        key hash.\n    ///      - All revealed deposits that are swept by `sweepTx` must have\n    ///        their `vault` parameters set to the same address as the address\n    ///        passed in the `vault` function parameter.\n    ///      - `sweepProof` components must match the expected structure. See\n    ///        `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant.\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        If there is no main UTXO, this parameter is ignored.\n    function submitDepositSweepProof(\n        BitcoinTx.Info calldata sweepTx,\n        BitcoinTx.Proof calldata sweepProof,\n        BitcoinTx.UTXO calldata mainUtxo,\n        address vault\n    ) external {\n        self.submitDepositSweepProof(sweepTx, sweepProof, mainUtxo, vault);\n    }\n\n    /// @notice Requests redemption of the given amount from the specified\n    ///         wallet to the redeemer Bitcoin output script.\n    /// @param walletPubKeyHash The 20-byte wallet public key hash (computed\n    ///        using Bitcoin HASH160 over the compressed ECDSA public key)\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain\n    /// @param redeemerOutputScript The redeemer's length-prefixed output\n    ///        script (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock\n    ///        redeemed BTC\n    /// @param amount Requested amount in satoshi. This is also the TBTC amount\n    ///        that is taken from redeemer's balance in the Bank upon request.\n    ///        Once the request is handled, the actual amount of BTC locked\n    ///        on the redeemer output script will be always lower than this value\n    ///        since the treasury and Bitcoin transaction fees must be incurred.\n    ///        The minimal amount satisfying the request can be computed as:\n    ///        `amount - (amount / redemptionTreasuryFeeDivisor) - redemptionTxMaxFee`.\n    ///        Fees values are taken at the moment of request creation.\n    /// @dev Requirements:\n    ///      - Wallet behind `walletPubKeyHash` must be live\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///      - `redeemerOutputScript` must be a proper Bitcoin script\n    ///      - `redeemerOutputScript` cannot have wallet PKH as payload\n    ///      - `amount` must be above or equal the `redemptionDustThreshold`\n    ///      - Given `walletPubKeyHash` and `redeemerOutputScript` pair can be\n    ///        used for only one pending request at the same time\n    ///      - Wallet must have enough Bitcoin balance to proceed the request\n    ///      - Redeemer must make an allowance in the Bank that the Bridge\n    ///        contract can spend the given `amount`.\n    function requestRedemption(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata mainUtxo,\n        bytes calldata redeemerOutputScript,\n        uint64 amount\n    ) external {\n        self.requestRedemption(\n            walletPubKeyHash,\n            mainUtxo,\n            redeemerOutputScript,\n            amount\n        );\n    }\n\n    /// @notice Used by the wallet to prove the BTC redemption transaction\n    ///         and to make the necessary bookkeeping. Redemption is only\n    ///         accepted if it satisfies SPV proof.\n    ///\n    ///         The function is performing Bank balance updates by burning\n    ///         the total redeemed Bitcoin amount from Bridge balance and\n    ///         transferring the treasury fee sum to the treasury address.\n    ///\n    ///         It is possible to prove the given redemption only one time.\n    /// @param redemptionTx Bitcoin redemption transaction data\n    /// @param redemptionProof Bitcoin redemption proof data\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain\n    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin\n    ///        HASH160 over the compressed ECDSA public key) of the wallet which\n    ///        performed the redemption transaction\n    /// @dev Requirements:\n    ///      - `redemptionTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash.\n    ///      - The `redemptionTx` should represent a Bitcoin transaction with\n    ///        exactly 1 input that refers to the wallet's main UTXO. That\n    ///        transaction should have 1..n outputs handling existing pending\n    ///        redemption requests or pointing to reported timed out requests.\n    ///        There can be also 1 optional output representing the\n    ///        change and pointing back to the 20-byte wallet public key hash.\n    ///        The change should be always present if the redeemed value sum\n    ///        is lower than the total wallet's BTC balance.\n    ///      - `redemptionProof` components must match the expected structure.\n    ///        See `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant.\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        Additionally, the recent main UTXO on Ethereum must be set.\n    ///      - `walletPubKeyHash` must be connected with the main UTXO used\n    ///        as transaction single input.\n    ///      Other remarks:\n    ///      - Putting the change output as the first transaction output can\n    ///        save some gas because the output processing loop begins each\n    ///        iteration by checking whether the given output is the change\n    ///        thus uses some gas for making the comparison. Once the change\n    ///        is identified, that check is omitted in further iterations.\n    function submitRedemptionProof(\n        BitcoinTx.Info calldata redemptionTx,\n        BitcoinTx.Proof calldata redemptionProof,\n        BitcoinTx.UTXO calldata mainUtxo,\n        bytes20 walletPubKeyHash\n    ) external {\n        self.submitRedemptionProof(\n            redemptionTx,\n            redemptionProof,\n            mainUtxo,\n            walletPubKeyHash\n        );\n    }\n\n    /// @notice Notifies that there is a pending redemption request associated\n    ///         with the given wallet, that has timed out. The redemption\n    ///         request is identified by the key built as\n    ///         `keccak256(walletPubKeyHash | redeemerOutputScript)`.\n    ///         The results of calling this function:\n    ///         - the pending redemptions value for the wallet will be decreased\n    ///           by the requested amount (minus treasury fee),\n    ///         - the tokens taken from the redeemer on redemption request will\n    ///           be returned to the redeemer,\n    ///         - the request will be moved from pending redemptions to\n    ///           timed-out redemptions,\n    ///         - if the state of the wallet is `Live` or `MovingFunds`, the\n    ///           wallet operators will be slashed and the notifier will be\n    ///           rewarded,\n    ///         - if the state of wallet is `Live`, the wallet will be closed or\n    ///           marked as `MovingFunds` (depending on the presence or absence\n    ///           of the wallet's main UTXO) and the wallet will no longer be\n    ///           marked as the active wallet (if it was marked as such).\n    /// @param walletPubKeyHash 20-byte public key hash of the wallet\n    /// @param walletMembersIDs Identifiers of the wallet signing group members\n    /// @param redeemerOutputScript  The redeemer's length-prefixed output\n    ///        script (P2PKH, P2WPKH, P2SH or P2WSH)\n    /// @dev Requirements:\n    ///      - The wallet must be in the Live or MovingFunds or Terminated state\n    ///      - The redemption request identified by `walletPubKeyHash` and\n    ///        `redeemerOutputScript` must exist\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given `walletID`. Those IDs are not directly stored\n    ///        in the contract for gas efficiency purposes but they can be\n    ///        read from appropriate `DkgResultSubmitted` and `DkgResultApproved`\n    ///        events of the `WalletRegistry` contract\n    ///      - The amount of time defined by `redemptionTimeout` must have\n    ///        passed since the redemption was requested (the request must be\n    ///        timed-out)\n    function notifyRedemptionTimeout(\n        bytes20 walletPubKeyHash,\n        uint32[] calldata walletMembersIDs,\n        bytes calldata redeemerOutputScript\n    ) external {\n        self.notifyRedemptionTimeout(\n            walletPubKeyHash,\n            walletMembersIDs,\n            redeemerOutputScript\n        );\n    }\n\n    /// @notice Submits the moving funds target wallets commitment.\n    ///         Once all requirements are met, that function registers the\n    ///         target wallets commitment and opens the way for moving funds\n    ///         proof submission.\n    /// @param walletPubKeyHash 20-byte public key hash of the source wallet\n    /// @param walletMainUtxo Data of the source wallet's main UTXO, as\n    ///        currently known on the Ethereum chain\n    /// @param walletMembersIDs Identifiers of the source wallet signing group\n    ///        members\n    /// @param walletMemberIndex Position of the caller in the source wallet\n    ///        signing group members list\n    /// @param targetWallets List of 20-byte public key hashes of the target\n    ///        wallets that the source wallet commits to move the funds to\n    /// @dev Requirements:\n    ///      - The source wallet must be in the MovingFunds state\n    ///      - The source wallet must not have pending redemption requests\n    ///      - The source wallet must not have pending moved funds sweep requests\n    ///      - The source wallet must not have submitted its commitment already\n    ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must\n    ///        be exactly the same as the hash stored under `membersIdsHash`\n    ///        for the given source wallet in the ECDSA registry. Those IDs are\n    ///        not directly stored in the contract for gas efficiency purposes\n    ///        but they can be read from appropriate `DkgResultSubmitted`\n    ///        and `DkgResultApproved` events.\n    ///      - The `walletMemberIndex` must be in range [1, walletMembersIDs.length]\n    ///      - The caller must be the member of the source wallet signing group\n    ///        at the position indicated by `walletMemberIndex` parameter\n    ///      - The `walletMainUtxo` components must point to the recent main\n    ///        UTXO of the source wallet, as currently known on the Ethereum\n    ///        chain.\n    ///      - Source wallet BTC balance must be greater than zero\n    ///      - At least one Live wallet must exist in the system\n    ///      - Submitted target wallets count must match the expected count\n    ///        `N = min(liveWalletsCount, ceil(walletBtcBalance / walletMaxBtcTransfer))`\n    ///        where `N > 0`\n    ///      - Each target wallet must be not equal to the source wallet\n    ///      - Each target wallet must follow the expected order i.e. all\n    ///        target wallets 20-byte public key hashes represented as numbers\n    ///        must form a strictly increasing sequence without duplicates.\n    ///      - Each target wallet must be in Live state\n    function submitMovingFundsCommitment(\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata walletMainUtxo,\n        uint32[] calldata walletMembersIDs,\n        uint256 walletMemberIndex,\n        bytes20[] calldata targetWallets\n    ) external {\n        self.submitMovingFundsCommitment(\n            walletPubKeyHash,\n            walletMainUtxo,\n            walletMembersIDs,\n            walletMemberIndex,\n            targetWallets\n        );\n    }\n\n    /// @notice 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 Allows to defeat a pending fraud challenge against a wallet by\n    ///         proving the sighash and signature were produced for an off-chain\n    ///         wallet heartbeat message following a strict format.\n    ///         In order to defeat the challenge the same `walletPublicKey` and\n    ///         signature (represented by `r`, `s` and `v`) must be provided as\n    ///         were used to calculate the sighash during heartbeat message\n    ///         signing. The fraud challenge defeat attempt will only succeed if\n    ///         the signed message follows a strict format required for\n    ///         heartbeat messages. If successfully defeated, the fraud\n    ///         challenge is marked as resolved and the amount of ether\n    ///         deposited by the challenger is sent to the treasury.\n    /// @param walletPublicKey The public key of the wallet in the uncompressed\n    ///        and unprefixed format (64 bytes)\n    /// @param heartbeatMessage Off-chain heartbeat message meeting the heartbeat\n    ///        message format requirements which produces sighash used to\n    ///        generate the ECDSA signature that is the subject of the fraud\n    ///        claim\n    /// @dev Requirements:\n    ///      - `walletPublicKey` and `sighash` calculated as\n    ///        `hash256(heartbeatMessage)` must identify an open fraud challenge\n    ///      - `heartbeatMessage` must follow a strict format of heartbeat\n    ///        messages\n    function defeatFraudChallengeWithHeartbeat(\n        bytes calldata walletPublicKey,\n        bytes calldata heartbeatMessage\n    ) external {\n        self.defeatFraudChallengeWithHeartbeat(\n            walletPublicKey,\n            heartbeatMessage\n        );\n    }\n\n    /// @notice Notifies about defeat timeout for the given fraud challenge.\n    ///         Can be called only if there was a fraud challenge identified by\n    ///         the provided `walletPublicKey` and `sighash` and it was not\n    ///         defeated on time. The amount of time that needs to pass after\n    ///         a fraud challenge is reported is indicated by the\n    ///         `challengeDefeatTimeout`. After a successful fraud challenge\n    ///         defeat timeout notification the fraud challenge is marked as\n    ///         resolved, the stake of each operator is slashed, the ether\n    ///         deposited is returned to the challenger and the challenger is\n    ///         rewarded.\n    /// @param walletPublicKey The public key of the wallet in the uncompressed\n    ///        and unprefixed format (64 bytes)\n    /// @param walletMembersIDs Identifiers of the wallet signing group members\n    /// @param 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"
@@ -176,7 +176,7 @@
       "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/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(self, sweepTx.outputVector);\n\n        (\n            Wallets.Wallet storage wallet,\n            BitcoinTx.UTXO memory resolvedMainUtxo\n        ) = resolveDepositSweepingWallet(self, walletPubKeyHash, mainUtxo);\n\n        // Process sweep transaction inputs and extract all information needed\n        // to perform deposit bookkeeping.\n        DepositSweepTxInputsInfo\n            memory inputsInfo = processDepositSweepTxInputs(\n                self,\n                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        // slither-disable-next-line reentrancy-events\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(\n        BridgeState.Storage storage self,\n        bytes memory sweepTxOutputVector\n    ) internal view returns (bytes20 walletPubKeyHash, uint64 value) {\n        // To determine the total number of sweep transaction outputs, we need to\n        // parse the compactSize uint (VarInt) the output vector is prepended by.\n        // That compactSize uint encodes the number of vector elements using the\n        // format presented in:\n        // https://developer.bitcoin.org/reference/transactions.html#compactsize-unsigned-integers\n        // We don't need asserting the compactSize uint is parseable since it\n        // was already checked during `validateVout` validation.\n        // See `BitcoinTx.outputVector` docs for more details.\n        (, uint256 outputsCount) = sweepTxOutputVector.parseVarInt();\n        require(\n            outputsCount == 1,\n            \"Sweep transaction must have a single output\"\n        );\n\n        bytes memory output = sweepTxOutputVector.extractOutputAtIndex(0);\n        walletPubKeyHash = self.extractPubKeyHash(output);\n        value = output.extractValue();\n\n        return (walletPubKeyHash, value);\n    }\n\n    /// @notice Processes the Bitcoin sweep transaction input vector. It\n    ///         extracts each input and tries to obtain associated deposit or\n    ///         main UTXO data, depending on the input type. Reverts\n    ///         if one of the inputs cannot be recognized as a pointer to a\n    ///         revealed deposit or expected main UTXO.\n    ///         This function also marks each processed deposit as swept.\n    /// @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                mainUtxo.txOutputIndex == outpointIndex\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"
+      "content": "// SPDX-License-Identifier: MIT\n\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n// ██████████████     ▐████▌     ██████████████\n// ██████████████     ▐████▌     ██████████████\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n//               ▐████▌    ▐████▌\n\npragma solidity ^0.8.9;\n\nimport {BTCUtils} from \"@keep-network/bitcoin-spv-sol/contracts/BTCUtils.sol\";\n\nimport \"./BitcoinTx.sol\";\nimport \"./BridgeState.sol\";\nimport \"./Wallets.sol\";\n\nimport \"../bank/Bank.sol\";\n\n/// @title Bridge deposit sweep\n/// @notice The library handles the logic for sweeping transactions revealed to\n///         the Bridge\n/// @dev Bridge active wallet periodically signs a transaction that unlocks all\n///      of the valid, revealed deposits above the dust threshold, combines them\n///      into a single UTXO with the existing main wallet UTXO, and relocks\n///      those transactions without a 30-day refund clause to the same wallet.\n///      This has two main effects: it consolidates the UTXO set and it disables\n///      the refund. Balances of depositors in the Bank are increased when the\n///      SPV sweep proof is submitted to the Bridge.\nlibrary DepositSweep {\n    using BridgeState for BridgeState.Storage;\n    using BitcoinTx for BridgeState.Storage;\n\n    using BTCUtils for bytes;\n\n    /// @notice Represents temporary information needed during the processing\n    ///         of the deposit sweep Bitcoin transaction inputs. This structure\n    ///         is an internal one and should not be exported outside of the\n    ///         deposit sweep transaction processing code.\n    /// @dev Allows to mitigate \"stack too deep\" errors on EVM.\n    struct DepositSweepTxInputsProcessingInfo {\n        // Input vector of the deposit sweep Bitcoin transaction. It is\n        // assumed the vector's structure is valid so it must be validated\n        // using e.g. `BTCUtils.validateVin` function before being used\n        // during the processing. The validation is usually done as part\n        // of the `BitcoinTx.validateProof` call that checks the SPV proof.\n        bytes sweepTxInputVector;\n        // Data of the wallet's main UTXO. If no main UTXO exists for the given\n        // sweeping wallet, this parameter's fields should be zeroed to bypass\n        // the main UTXO validation\n        BitcoinTx.UTXO mainUtxo;\n        // Address of the vault where all swept deposits should be routed to.\n        // It is used to validate whether all swept deposits have been revealed\n        // with the same `vault` parameter. It is an optional parameter.\n        // Set to zero address if deposits are not routed to a vault.\n        address vault;\n    }\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    /// @param vault Optional address of the vault where all swept deposits\n    ///        should be routed to. All deposits swept as part of the transaction\n    ///        must have their `vault` parameters set to the same address.\n    ///        If this parameter is set to an address of a trusted vault, swept\n    ///        deposits are routed to that vault.\n    ///        If this parameter is set to the zero address or to an address\n    ///        of a non-trusted vault, swept deposits are not routed to a\n    ///        vault but depositors' balances are increased in the Bank\n    ///        individually.\n    /// @dev Requirements:\n    ///      - `sweepTx` components must match the expected structure. See\n    ///        `BitcoinTx.Info` docs for reference. Their values must exactly\n    ///        correspond to appropriate Bitcoin transaction fields to produce\n    ///        a provable transaction hash.\n    ///      - The `sweepTx` should represent a Bitcoin transaction with 1..n\n    ///        inputs. If the wallet has no main UTXO, all n inputs should\n    ///        correspond to P2(W)SH revealed deposits UTXOs. If the wallet has\n    ///        an existing main UTXO, one of the n inputs must point to that\n    ///        main UTXO and remaining n-1 inputs should correspond to P2(W)SH\n    ///        revealed deposits UTXOs. That transaction must have only\n    ///        one P2(W)PKH output locking funds on the 20-byte wallet public\n    ///        key hash.\n    ///      - All revealed deposits that are swept by `sweepTx` must have\n    ///        their `vault` parameters set to the same address as the address\n    ///        passed in the `vault` function parameter.\n    ///      - `sweepProof` components must match the expected structure. See\n    ///        `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`\n    ///        field must contain a valid number of block headers, not less\n    ///        than the `txProofDifficultyFactor` contract constant.\n    ///      - `mainUtxo` components must point to the recent main UTXO\n    ///        of the given wallet, as currently known on the Ethereum chain.\n    ///        If there is no main UTXO, this parameter is ignored.\n    function submitDepositSweepProof(\n        BridgeState.Storage storage self,\n        BitcoinTx.Info calldata sweepTx,\n        BitcoinTx.Proof calldata sweepProof,\n        BitcoinTx.UTXO calldata mainUtxo,\n        address vault\n    ) external {\n        // The actual transaction proof is performed here. After that point, we\n        // can assume the transaction happened on Bitcoin chain and has\n        // a sufficient number of confirmations as determined by\n        // `txProofDifficultyFactor` constant.\n        bytes32 sweepTxHash = self.validateProof(sweepTx, sweepProof);\n\n        // Process sweep transaction output and extract its target wallet\n        // public key hash and value.\n        (\n            bytes20 walletPubKeyHash,\n            uint64 sweepTxOutputValue\n        ) = processDepositSweepTxOutput(self, sweepTx.outputVector);\n\n        (\n            Wallets.Wallet storage wallet,\n            BitcoinTx.UTXO memory resolvedMainUtxo\n        ) = resolveDepositSweepingWallet(self, walletPubKeyHash, mainUtxo);\n\n        // Process sweep transaction inputs and extract all information needed\n        // to perform deposit bookkeeping.\n        DepositSweepTxInputsInfo\n            memory inputsInfo = processDepositSweepTxInputs(\n                self,\n                DepositSweepTxInputsProcessingInfo(\n                    sweepTx.inputVector,\n                    resolvedMainUtxo,\n                    vault\n                )\n            );\n\n        // Helper variable that will hold the sum of treasury fees paid by\n        // all deposits.\n        uint256 totalTreasuryFee = 0;\n\n        // Determine the transaction fee that should be incurred by each deposit\n        // and the indivisible remainder that should be additionally incurred\n        // by the last deposit.\n        (\n            uint256 depositTxFee,\n            uint256 depositTxFeeRemainder\n        ) = depositSweepTxFeeDistribution(\n                inputsInfo.inputsTotalValue,\n                sweepTxOutputValue,\n                inputsInfo.depositedAmounts.length\n            );\n\n        // Make sure the highest value of the deposit transaction fee does not\n        // exceed the maximum value limited by the governable parameter.\n        require(\n            depositTxFee + depositTxFeeRemainder <= self.depositTxMaxFee,\n            \"Transaction fee is too high\"\n        );\n\n        // Reduce each deposit amount by treasury fee and transaction fee.\n        for (uint256 i = 0; i < inputsInfo.depositedAmounts.length; i++) {\n            // The last deposit should incur the deposit transaction fee\n            // remainder.\n            uint256 depositTxFeeIncurred = i ==\n                inputsInfo.depositedAmounts.length - 1\n                ? depositTxFee + depositTxFeeRemainder\n                : depositTxFee;\n\n            // There is no need to check whether\n            // `inputsInfo.depositedAmounts[i] - inputsInfo.treasuryFees[i] - txFee > 0`\n            // since the `depositDustThreshold` should force that condition\n            // to be always true.\n            inputsInfo.depositedAmounts[i] =\n                inputsInfo.depositedAmounts[i] -\n                inputsInfo.treasuryFees[i] -\n                depositTxFeeIncurred;\n            totalTreasuryFee += inputsInfo.treasuryFees[i];\n        }\n\n        // Record this sweep data and assign them to the wallet public key hash\n        // as new main UTXO. Transaction output index is always 0 as sweep\n        // transaction always contains only one output.\n        wallet.mainUtxoHash = keccak256(\n            abi.encodePacked(sweepTxHash, uint32(0), sweepTxOutputValue)\n        );\n\n        // slither-disable-next-line reentrancy-events\n        emit DepositsSwept(walletPubKeyHash, sweepTxHash);\n\n        if (vault != address(0) && self.isVaultTrusted[vault]) {\n            // If the `vault` address is not zero and belongs to a trusted\n            // vault, route the deposits to that vault.\n            self.bank.increaseBalanceAndCall(\n                vault,\n                inputsInfo.depositors,\n                inputsInfo.depositedAmounts\n            );\n        } else {\n            // If the `vault` address is zero or belongs to a non-trusted\n            // vault, increase balances in the Bank individually for each\n            // depositor.\n            self.bank.increaseBalances(\n                inputsInfo.depositors,\n                inputsInfo.depositedAmounts\n            );\n        }\n\n        // Pass the treasury fee to the treasury address.\n        self.bank.increaseBalance(self.treasury, totalTreasuryFee);\n    }\n\n    /// @notice Resolves sweeping wallet based on the provided wallet public key\n    ///         hash. Validates the wallet state and current main UTXO, as\n    ///         currently known on the Ethereum chain.\n    /// @param walletPubKeyHash public key hash of the wallet proving the sweep\n    ///        Bitcoin transaction.\n    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on\n    ///        the Ethereum chain. If no main UTXO exists for the given wallet,\n    ///        this parameter is ignored\n    /// @return wallet Data of the sweeping wallet.\n    /// @return resolvedMainUtxo The actual main UTXO of the sweeping wallet\n    ///         resolved by cross-checking the `mainUtxo` parameter with\n    ///         the chain state. If the validation went well, this is the\n    ///         plain-text main UTXO corresponding to the `wallet.mainUtxoHash`.\n    /// @dev Requirements:\n    ///     - Sweeping wallet must be either in Live or MovingFunds state.\n    ///     - If the main UTXO of the sweeping wallet exists in the storage,\n    ///       the passed `mainUTXO` parameter must be equal to the stored one.\n    function resolveDepositSweepingWallet(\n        BridgeState.Storage storage self,\n        bytes20 walletPubKeyHash,\n        BitcoinTx.UTXO calldata mainUtxo\n    )\n        internal\n        view\n        returns (\n            Wallets.Wallet storage wallet,\n            BitcoinTx.UTXO memory resolvedMainUtxo\n        )\n    {\n        wallet = self.registeredWallets[walletPubKeyHash];\n\n        Wallets.WalletState walletState = wallet.state;\n        require(\n            walletState == Wallets.WalletState.Live ||\n                walletState == Wallets.WalletState.MovingFunds,\n            \"Wallet must be in Live or MovingFunds state\"\n        );\n\n        // Check if the main UTXO for given wallet exists. If so, validate\n        // passed main UTXO data against the stored hash and use them for\n        // further processing. If no main UTXO exists, use empty data.\n        resolvedMainUtxo = BitcoinTx.UTXO(bytes32(0), 0, 0);\n        bytes32 mainUtxoHash = wallet.mainUtxoHash;\n        if (mainUtxoHash != bytes32(0)) {\n            require(\n                keccak256(\n                    abi.encodePacked(\n                        mainUtxo.txHash,\n                        mainUtxo.txOutputIndex,\n                        mainUtxo.txOutputValue\n                    )\n                ) == mainUtxoHash,\n                \"Invalid main UTXO data\"\n            );\n            resolvedMainUtxo = mainUtxo;\n        }\n    }\n\n    /// @notice Processes the Bitcoin sweep transaction output vector by\n    ///         extracting the single output and using it to gain additional\n    ///         information required for further processing (e.g. value and\n    ///         wallet public key hash).\n    /// @param sweepTxOutputVector Bitcoin sweep transaction output vector.\n    ///        This function assumes vector's structure is valid so it must be\n    ///        validated using e.g. `BTCUtils.validateVout` function before\n    ///        it is passed here\n    /// @return walletPubKeyHash 20-byte wallet public key hash.\n    /// @return value 8-byte sweep transaction output value.\n    function processDepositSweepTxOutput(\n        BridgeState.Storage storage self,\n        bytes memory sweepTxOutputVector\n    ) internal view returns (bytes20 walletPubKeyHash, uint64 value) {\n        // To determine the total number of sweep transaction outputs, we need to\n        // parse the compactSize uint (VarInt) the output vector is prepended by.\n        // That compactSize uint encodes the number of vector elements using the\n        // format presented in:\n        // https://developer.bitcoin.org/reference/transactions.html#compactsize-unsigned-integers\n        // We don't need asserting the compactSize uint is parseable since it\n        // was already checked during `validateVout` validation.\n        // See `BitcoinTx.outputVector` docs for more details.\n        (, uint256 outputsCount) = sweepTxOutputVector.parseVarInt();\n        require(\n            outputsCount == 1,\n            \"Sweep transaction must have a single output\"\n        );\n\n        bytes memory output = sweepTxOutputVector.extractOutputAtIndex(0);\n        walletPubKeyHash = self.extractPubKeyHash(output);\n        value = output.extractValue();\n\n        return (walletPubKeyHash, value);\n    }\n\n    /// @notice Processes the Bitcoin sweep transaction input vector. It\n    ///         extracts each input and tries to obtain associated deposit or\n    ///         main UTXO data, depending on the input type. Reverts\n    ///         if one of the inputs cannot be recognized as a pointer to a\n    ///         revealed deposit or expected main UTXO.\n    ///         This function also marks each processed deposit as swept.\n    /// @return resultInfo Outcomes of the processing.\n    function processDepositSweepTxInputs(\n        BridgeState.Storage storage self,\n        DepositSweepTxInputsProcessingInfo memory processInfo\n    ) internal returns (DepositSweepTxInputsInfo memory resultInfo) {\n        // If the passed `mainUtxo` parameter's values are zeroed, the main UTXO\n        // for the given wallet doesn't exist and it is not expected to be\n        // included in the sweep transaction input vector.\n        bool mainUtxoExpected = processInfo.mainUtxo.txHash != bytes32(0);\n        bool mainUtxoFound = false;\n\n        // Determining the total number of sweep transaction inputs in the same\n        // way as for number of outputs. See `BitcoinTx.inputVector` docs for\n        // more details.\n        (uint256 inputsCompactSizeUintLength, uint256 inputsCount) = processInfo\n            .sweepTxInputVector\n            .parseVarInt();\n\n        // To determine the first input starting index, we must jump over\n        // the compactSize uint which prepends the input vector. One byte\n        // must be added because `BtcUtils.parseVarInt` does not include\n        // compactSize uint tag in the returned length.\n        //\n        // For >= 0 && <= 252, `BTCUtils.determineVarIntDataLengthAt`\n        // returns `0`, so we jump over one byte of compactSize uint.\n        //\n        // For >= 253 && <= 0xffff there is `0xfd` tag,\n        // `BTCUtils.determineVarIntDataLengthAt` returns `2` (no\n        // tag byte included) so we need to jump over 1+2 bytes of\n        // compactSize uint.\n        //\n        // Please refer `BTCUtils` library and compactSize uint\n        // docs in `BitcoinTx` library for more details.\n        uint256 inputStartingIndex = 1 + inputsCompactSizeUintLength;\n\n        // Determine the swept deposits count. If main UTXO is NOT expected,\n        // all inputs should be deposits. If main UTXO is expected, one input\n        // should point to that main UTXO.\n        resultInfo.depositors = new address[](\n            !mainUtxoExpected ? inputsCount : inputsCount - 1\n        );\n        resultInfo.depositedAmounts = new uint256[](\n            resultInfo.depositors.length\n        );\n        resultInfo.treasuryFees = new uint256[](resultInfo.depositors.length);\n\n        // Initialize helper variables.\n        uint256 processedDepositsCount = 0;\n\n        // Inputs processing loop.\n        for (uint256 i = 0; i < inputsCount; i++) {\n            (\n                bytes32 outpointTxHash,\n                uint32 outpointIndex,\n                uint256 inputLength\n            ) = parseDepositSweepTxInputAt(\n                    processInfo.sweepTxInputVector,\n                    inputStartingIndex\n                );\n\n            Deposit.DepositRequest storage deposit = self.deposits[\n                uint256(\n                    keccak256(abi.encodePacked(outpointTxHash, outpointIndex))\n                )\n            ];\n\n            if (deposit.revealedAt != 0) {\n                // If we entered here, that means the input was identified as\n                // a revealed deposit.\n                require(deposit.sweptAt == 0, \"Deposit already swept\");\n\n                require(\n                    deposit.vault == processInfo.vault,\n                    \"Deposit should be routed to another vault\"\n                );\n\n                if (processedDepositsCount == resultInfo.depositors.length) {\n                    // If this condition is true, that means a deposit input\n                    // took place of an expected main UTXO input.\n                    // In other words, there is no expected main UTXO\n                    // input and all inputs come from valid, revealed deposits.\n                    revert(\n                        \"Expected main UTXO not present in sweep transaction inputs\"\n                    );\n                }\n\n                /* solhint-disable-next-line not-rely-on-time */\n                deposit.sweptAt = uint32(block.timestamp);\n\n                resultInfo.depositors[processedDepositsCount] = deposit\n                    .depositor;\n                resultInfo.depositedAmounts[processedDepositsCount] = deposit\n                    .amount;\n                resultInfo.inputsTotalValue += resultInfo.depositedAmounts[\n                    processedDepositsCount\n                ];\n                resultInfo.treasuryFees[processedDepositsCount] = deposit\n                    .treasuryFee;\n\n                processedDepositsCount++;\n            } else if (\n                mainUtxoExpected != mainUtxoFound &&\n                processInfo.mainUtxo.txHash == outpointTxHash &&\n                processInfo.mainUtxo.txOutputIndex == outpointIndex\n            ) {\n                // If we entered here, that means the input was identified as\n                // the expected main UTXO.\n                resultInfo.inputsTotalValue += processInfo\n                    .mainUtxo\n                    .txOutputValue;\n                mainUtxoFound = true;\n\n                // Main UTXO used as an input, mark it as spent.\n                self.spentMainUTXOs[\n                    uint256(\n                        keccak256(\n                            abi.encodePacked(outpointTxHash, outpointIndex)\n                        )\n                    )\n                ] = true;\n            } else {\n                revert(\"Unknown input type\");\n            }\n\n            // Make the `inputStartingIndex` pointing to the next input by\n            // increasing it by current input's length.\n            inputStartingIndex += inputLength;\n        }\n\n        // Construction of the input processing loop guarantees that:\n        // `processedDepositsCount == resultInfo.depositors.length == resultInfo.depositedAmounts.length`\n        // is always true at this point. We just use the first variable\n        // to assert the total count of swept deposit is bigger than zero.\n        require(\n            processedDepositsCount > 0,\n            \"Sweep transaction must process at least one deposit\"\n        );\n\n        // Assert the main UTXO was used as one of current sweep's inputs if\n        // it was actually expected.\n        require(\n            mainUtxoExpected == mainUtxoFound,\n            \"Expected main UTXO not present in sweep transaction inputs\"\n        );\n\n        return resultInfo;\n    }\n\n    /// @notice Parses a Bitcoin transaction input starting at the given index.\n    /// @param inputVector Bitcoin transaction input vector\n    /// @param inputStartingIndex Index the given input starts at\n    /// @return outpointTxHash 32-byte hash of the Bitcoin transaction which is\n    ///         pointed in the given input's outpoint.\n    /// @return outpointIndex 4-byte index of the Bitcoin transaction output\n    ///         which is pointed in the given input's outpoint.\n    /// @return inputLength Byte length of the given input.\n    /// @dev This function assumes vector's structure is valid so it must be\n    ///      validated using e.g. `BTCUtils.validateVin` function before it\n    ///      is passed here.\n    function parseDepositSweepTxInputAt(\n        bytes memory inputVector,\n        uint256 inputStartingIndex\n    )\n        internal\n        pure\n        returns (\n            bytes32 outpointTxHash,\n            uint32 outpointIndex,\n            uint256 inputLength\n        )\n    {\n        outpointTxHash = inputVector.extractInputTxIdLeAt(inputStartingIndex);\n\n        outpointIndex = BTCUtils.reverseUint32(\n            uint32(inputVector.extractTxIndexLeAt(inputStartingIndex))\n        );\n\n        inputLength = inputVector.determineInputLengthAt(inputStartingIndex);\n\n        return (outpointTxHash, outpointIndex, inputLength);\n    }\n\n    /// @notice Determines the distribution of the sweep transaction fee\n    ///         over swept deposits.\n    /// @param sweepTxInputsTotalValue Total value of all sweep transaction inputs.\n    /// @param sweepTxOutputValue Value of the sweep transaction output.\n    /// @param depositsCount Count of the deposits swept by the sweep transaction.\n    /// @return depositTxFee Transaction fee per deposit determined by evenly\n    ///         spreading the divisible part of the sweep transaction fee\n    ///         over all deposits.\n    /// @return depositTxFeeRemainder The indivisible part of the sweep\n    ///         transaction fee than cannot be distributed over all deposits.\n    /// @dev It is up to the caller to decide how the remainder should be\n    ///      counted in. This function only computes its value.\n    function depositSweepTxFeeDistribution(\n        uint256 sweepTxInputsTotalValue,\n        uint256 sweepTxOutputValue,\n        uint256 depositsCount\n    )\n        internal\n        pure\n        returns (uint256 depositTxFee, uint256 depositTxFeeRemainder)\n    {\n        // The sweep transaction fee is just the difference between inputs\n        // amounts sum and the output amount.\n        uint256 sweepTxFee = sweepTxInputsTotalValue - sweepTxOutputValue;\n        // Compute the indivisible remainder that remains after dividing the\n        // sweep transaction fee over all deposits evenly.\n        depositTxFeeRemainder = sweepTxFee % depositsCount;\n        // Compute the transaction fee per deposit by dividing the sweep\n        // transaction fee (reduced by the remainder) by the number of deposits.\n        depositTxFee = (sweepTxFee - depositTxFeeRemainder) / depositsCount;\n\n        return (depositTxFee, depositTxFeeRemainder);\n    }\n}\n"
     },
     "contracts/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"