@keep-network/tbtc-v2 0.1.1-dev.40 → 0.1.1-dev.43

package/contracts/bridge/Bridge.sol

@@ -17,20 +17,17 @@ pragma solidity ^0.8.9;
 
 import "@openzeppelin/contracts/access/Ownable.sol";
 
-import {BTCUtils} from "@keep-network/bitcoin-spv-sol/contracts/BTCUtils.sol";
-import {BytesLib} from "@keep-network/bitcoin-spv-sol/contracts/BytesLib.sol";
-
 import {IWalletOwner as EcdsaWalletOwner} from "@keep-network/ecdsa/contracts/api/IWalletOwner.sol";
 
 import "./IRelay.sol";
 import "./BridgeState.sol";
 import "./Deposit.sol";
 import "./Sweep.sol";
-import "./Redeem.sol";
+import "./Redemption.sol";
 import "./BitcoinTx.sol";
 import "./EcdsaLib.sol";
 import "./Wallets.sol";
-import "./Frauds.sol";
+import "./Fraud.sol";
 import "./MovingFunds.sol";
 
 import "../bank/Bank.sol";
@@ -53,81 +50,20 @@ import "../bank/Bank.sol";
 ///         the sweep operation is confirmed on the Bitcoin network, the ECDSA
 ///         wallet informs the Bridge about the sweep increasing appropriate
 ///         balances in the Bank.
-/// @dev Bridge is an upgradeable component of the Bank.
-///
-// TODO: All wallets-related operations that are currently done directly
-//       by the Bridge can be probably delegated to the Wallets library.
-//       Examples of such operations are main UTXO or pending redemptions
-//       value updates.
+/// @dev Bridge is an upgradeable component of the Bank. The order of
+///      functionalities in this contract is: deposit, sweep, redemption,
+///      moving funds, wallet lifecycle, frauds, parameters.
 contract Bridge is Ownable, EcdsaWalletOwner {
     using BridgeState for BridgeState.Storage;
     using Deposit for BridgeState.Storage;
     using Sweep for BridgeState.Storage;
-    using Redeem for BridgeState.Storage;
+    using Redemption for BridgeState.Storage;
     using MovingFunds for BridgeState.Storage;
-    using Frauds for Frauds.Data;
-    using Wallets for Wallets.Data;
-
-    using BTCUtils for bytes;
-    using BTCUtils for uint256;
-    using BytesLib for bytes;
+    using Wallets for BridgeState.Storage;
+    using Fraud for BridgeState.Storage;
 
     BridgeState.Storage internal self;
 
-    /// @notice Contains parameters related to frauds and the collection of all
-    ///         submitted fraud challenges.
-    Frauds.Data internal frauds;
-
-    /// @notice State related with wallets.
-    Wallets.Data internal wallets;
-
-    event WalletCreationPeriodUpdated(uint32 newCreationPeriod);
-
-    event WalletBtcBalanceRangeUpdated(
-        uint64 newMinBtcBalance,
-        uint64 newMaxBtcBalance
-    );
-
-    event WalletMaxAgeUpdated(uint32 newMaxAge);
-
-    event NewWalletRequested();
-
-    event NewWalletRegistered(
-        bytes32 indexed ecdsaWalletID,
-        bytes20 indexed walletPubKeyHash
-    );
-
-    event WalletMovingFunds(
-        bytes32 indexed ecdsaWalletID,
-        bytes20 indexed walletPubKeyHash
-    );
-
-    event WalletClosed(
-        bytes32 indexed ecdsaWalletID,
-        bytes20 indexed walletPubKeyHash
-    );
-
-    event WalletTerminated(
-        bytes32 indexed ecdsaWalletID,
-        bytes20 indexed walletPubKeyHash
-    );
-
-    event VaultStatusUpdated(address indexed vault, bool isTrusted);
-
-    event FraudSlashingAmountUpdated(uint256 newFraudSlashingAmount);
-
-    event FraudNotifierRewardMultiplierUpdated(
-        uint256 newFraudNotifierRewardMultiplier
-    );
-
-    event FraudChallengeDefeatTimeoutUpdated(
-        uint256 newFraudChallengeDefeatTimeout
-    );
-
-    event FraudChallengeDepositAmountUpdated(
-        uint256 newFraudChallengeDepositAmount
-    );
-
     event DepositRevealed(
         bytes32 fundingTxHash,
         uint32 fundingOutputIndex,
@@ -161,6 +97,33 @@ contract Bridge is Ownable, EcdsaWalletOwner {
         bytes redeemerOutputScript
     );
 
+    event WalletMovingFunds(
+        bytes32 indexed ecdsaWalletID,
+        bytes20 indexed walletPubKeyHash
+    );
+
+    event MovingFundsCompleted(
+        bytes20 walletPubKeyHash,
+        bytes32 movingFundsTxHash
+    );
+
+    event NewWalletRequested();
+
+    event NewWalletRegistered(
+        bytes32 indexed ecdsaWalletID,
+        bytes20 indexed walletPubKeyHash
+    );
+
+    event WalletClosed(
+        bytes32 indexed ecdsaWalletID,
+        bytes20 indexed walletPubKeyHash
+    );
+
+    event WalletTerminated(
+        bytes32 indexed ecdsaWalletID,
+        bytes20 indexed walletPubKeyHash
+    );
+
     event FraudChallengeSubmitted(
         bytes20 walletPublicKeyHash,
         bytes32 sighash,
@@ -176,9 +139,13 @@ contract Bridge is Ownable, EcdsaWalletOwner {
         bytes32 sighash
     );
 
-    event MovingFundsCompleted(
-        bytes20 walletPubKeyHash,
-        bytes32 movingFundsTxHash
+    event VaultStatusUpdated(address indexed vault, bool isTrusted);
+
+    event WalletParametersUpdated(
+        uint32 walletCreationPeriod,
+        uint64 walletMinBtcBalance,
+        uint64 walletMaxBtcBalance,
+        uint32 walletMaxAge
     );
 
     constructor(
@@ -194,6 +161,12 @@ contract Bridge is Ownable, EcdsaWalletOwner {
         require(_relay != address(0), "Relay address cannot be zero");
         self.relay = IRelay(_relay);
 
+        require(
+            _ecdsaWalletRegistry != address(0),
+            "ECDSA Wallet Registry address cannot be zero"
+        );
+        self.ecdsaWalletRegistry = EcdsaWalletRegistry(_ecdsaWalletRegistry);
+
         require(_treasury != address(0), "Treasury address cannot be zero");
         self.treasury = _treasury;
 
@@ -208,177 +181,14 @@ contract Bridge is Ownable, EcdsaWalletOwner {
         self.redemptionTxMaxFee = 10000; // 10000 satoshi
         self.redemptionTimeout = 172800; // 48 hours
         self.movingFundsTxMaxTotalFee = 10000; // 10000 satoshi
-
-        // TODO: Revisit initial values.
-        frauds.setSlashingAmount(10000 * 1e18); // 10000 T
-        frauds.setNotifierRewardMultiplier(100); // 100%
-        frauds.setChallengeDefeatTimeout(7 days);
-        frauds.setChallengeDepositAmount(2 ether);
-
-        // TODO: Revisit initial values.
-        wallets.init(_ecdsaWalletRegistry);
-        wallets.setCreationPeriod(1 weeks);
-        wallets.setBtcBalanceRange(1 * 1e8, 10 * 1e8); // [1 BTC, 10 BTC]
-        wallets.setMaxAge(26 weeks); // ~6 months
-    }
-
-    /// @notice Updates parameters used by the `Wallets` library.
-    /// @param creationPeriod New value of the wallet creation period
-    /// @param minBtcBalance New value of the minimum BTC balance
-    /// @param maxBtcBalance New value of the maximum BTC balance
-    /// @param maxAge New value of the wallet maximum age
-    /// @dev Requirements:
-    ///      - Caller must be the contract owner.
-    ///      - Minimum BTC balance must be greater than zero
-    ///      - Maximum BTC balance must be greater than minimum BTC balance
-    function updateWalletsParameters(
-        uint32 creationPeriod,
-        uint64 minBtcBalance,
-        uint64 maxBtcBalance,
-        uint32 maxAge
-    ) external onlyOwner {
-        wallets.setCreationPeriod(creationPeriod);
-        wallets.setBtcBalanceRange(minBtcBalance, maxBtcBalance);
-        wallets.setMaxAge(maxAge);
-    }
-
-    /// @return creationPeriod Value of the wallet creation period
-    /// @return minBtcBalance Value of the minimum BTC balance
-    /// @return maxBtcBalance Value of the maximum BTC balance
-    /// @return maxAge Value of the wallet max age
-    function getWalletsParameters()
-        external
-        view
-        returns (
-            uint32 creationPeriod,
-            uint64 minBtcBalance,
-            uint64 maxBtcBalance,
-            uint32 maxAge
-        )
-    {
-        creationPeriod = wallets.creationPeriod;
-        minBtcBalance = wallets.minBtcBalance;
-        maxBtcBalance = wallets.maxBtcBalance;
-        maxAge = wallets.maxAge;
-
-        return (creationPeriod, minBtcBalance, maxBtcBalance, maxAge);
-    }
-
-    /// @notice Allows the Governance to mark the given vault address as trusted
-    ///         or no longer trusted. Vaults are not trusted by default.
-    ///         Trusted vault must meet the following criteria:
-    ///         - `IVault.receiveBalanceIncrease` must have a known, low gas
-    ///           cost.
-    ///         - `IVault.receiveBalanceIncrease` must never revert.
-    /// @dev Without restricting reveal only to trusted vaults, malicious
-    ///      vaults not meeting the criteria would be able to nuke sweep proof
-    ///      transactions executed by ECDSA wallet with  deposits routed to
-    ///      them.
-    /// @param vault The address of the vault
-    /// @param isTrusted flag indicating whether the vault is trusted or not
-    /// @dev Can only be called by the Governance.
-    function setVaultStatus(address vault, bool isTrusted) external onlyOwner {
-        self.isVaultTrusted[vault] = isTrusted;
-        emit VaultStatusUpdated(vault, isTrusted);
-    }
-
-    /// @notice Requests creation of a new wallet. This function just
-    ///         forms a request and the creation process is performed
-    ///         asynchronously. Once a wallet is created, the ECDSA Wallet
-    ///         Registry will notify this contract by calling the
-    ///         `__ecdsaWalletCreatedCallback` function.
-    /// @param activeWalletMainUtxo Data of the active wallet's main UTXO, as
-    ///        currently known on the Ethereum chain.
-    /// @dev Requirements:
-    ///      - `activeWalletMainUtxo` components must point to the recent main
-    ///        UTXO of the given active wallet, as currently known on the
-    ///        Ethereum chain. If there is no active wallet at the moment, or
-    ///        the active wallet has no main UTXO, this parameter can be
-    ///        empty as it is ignored.
-    ///      - Wallet creation must not be in progress
-    ///      - If the active wallet is set, one of the following
-    ///        conditions must be true:
-    ///        - The active wallet BTC balance is above the minimum threshold
-    ///          and the active wallet is old enough, i.e. the creation period
-    ///          was elapsed since its creation time
-    ///        - The active wallet BTC balance is above the maximum threshold
-    function requestNewWallet(BitcoinTx.UTXO calldata activeWalletMainUtxo)
-        external
-    {
-        wallets.requestNewWallet(activeWalletMainUtxo);
-    }
-
-    /// @notice A callback function that is called by the ECDSA Wallet Registry
-    ///         once a new ECDSA wallet is created.
-    /// @param ecdsaWalletID Wallet's unique identifier.
-    /// @param publicKeyX Wallet's public key's X coordinate.
-    /// @param publicKeyY Wallet's public key's Y coordinate.
-    /// @dev Requirements:
-    ///      - The only caller authorized to call this function is `registry`
-    ///      - Given wallet data must not belong to an already registered wallet
-    function __ecdsaWalletCreatedCallback(
-        bytes32 ecdsaWalletID,
-        bytes32 publicKeyX,
-        bytes32 publicKeyY
-    ) external override {
-        wallets.registerNewWallet(ecdsaWalletID, publicKeyX, publicKeyY);
-    }
-
-    /// @notice A callback function that is called by the ECDSA Wallet Registry
-    ///         once a wallet heartbeat failure is detected.
-    /// @param publicKeyX Wallet's public key's X coordinate
-    /// @param publicKeyY Wallet's public key's Y coordinate
-    /// @dev Requirements:
-    ///      - The only caller authorized to call this function is `registry`
-    ///      - Wallet must be in Live state
-    function __ecdsaWalletHeartbeatFailedCallback(
-        bytes32,
-        bytes32 publicKeyX,
-        bytes32 publicKeyY
-    ) external override {
-        wallets.notifyWalletHeartbeatFailed(publicKeyX, publicKeyY);
-    }
-
-    /// @notice Notifies that the wallet is either old enough or has too few
-    ///         satoshis left and qualifies to be closed.
-    /// @param walletPubKeyHash 20-byte public key hash of the wallet
-    /// @param walletMainUtxo Data of the wallet's main UTXO, as currently
-    ///        known on the Ethereum chain.
-    /// @dev Requirements:
-    ///      - Wallet must not be set as the current active wallet
-    ///      - Wallet must exceed the wallet maximum age OR the wallet BTC
-    ///        balance must be lesser than the minimum threshold. If the latter
-    ///        case is true, the `walletMainUtxo` components must point to the
-    ///        recent main UTXO of the given wallet, as currently known on the
-    ///        Ethereum chain. If the wallet has no main UTXO, this parameter
-    ///        can be empty as it is ignored since the wallet balance is
-    ///        assumed to be zero.
-    ///      - Wallet must be in Live state
-    function notifyCloseableWallet(
-        bytes20 walletPubKeyHash,
-        BitcoinTx.UTXO calldata walletMainUtxo
-    ) external {
-        wallets.notifyCloseableWallet(walletPubKeyHash, walletMainUtxo);
-    }
-
-    /// @notice Gets details about a registered wallet.
-    /// @param walletPubKeyHash The 20-byte wallet public key hash (computed
-    ///        using Bitcoin HASH160 over the compressed ECDSA public key)
-    /// @return Wallet details.
-    function getWallet(bytes20 walletPubKeyHash)
-        external
-        view
-        returns (Wallets.Wallet memory)
-    {
-        return wallets.registeredWallets[walletPubKeyHash];
-    }
-
-    /// @notice Gets the public key hash of the active wallet.
-    /// @return The 20-byte public key hash (computed using Bitcoin HASH160
-    ///         over the compressed ECDSA public key) of the active wallet.
-    ///         Returns bytes20(0) if there is no active wallet at the moment.
-    function getActiveWalletPubKeyHash() external view returns (bytes20) {
-        return wallets.activeWalletPubKeyHash;
+        self.fraudSlashingAmount = 10000 * 1e18; // 10000 T
+        self.fraudNotifierRewardMultiplier = 100; // 100%
+        self.fraudChallengeDefeatTimeout = 7 days;
+        self.fraudChallengeDepositAmount = 2 ether;
+        self.walletCreationPeriod = 1 weeks;
+        self.walletMinBtcBalance = 1e8; // 1 BTC
+        self.walletMaxBtcBalance = 10e8; // 10 BTC
+        self.walletMaxAge = 26 weeks; // ~6 months
     }
 
     /// @notice Used by the depositor to reveal information about their P2(W)SH
@@ -419,7 +229,7 @@ contract Bridge is Ownable, EcdsaWalletOwner {
         BitcoinTx.Info calldata fundingTx,
         Deposit.DepositRevealInfo calldata reveal
     ) external {
-        self.revealDeposit(wallets, fundingTx, reveal);
+        self.revealDeposit(fundingTx, reveal);
     }
 
     /// @notice Used by the wallet to prove the BTC deposit sweep transaction
@@ -463,203 +273,26 @@ contract Bridge is Ownable, EcdsaWalletOwner {
         BitcoinTx.Proof calldata sweepProof,
         BitcoinTx.UTXO calldata mainUtxo
     ) external {
-        self.submitSweepProof(wallets, sweepTx, sweepProof, mainUtxo);
+        self.submitSweepProof(sweepTx, sweepProof, mainUtxo);
     }
 
-    /// @notice Submits a fraud challenge indicating that a UTXO being under
-    ///         wallet control was unlocked by the wallet but was not used
-    ///         according to the protocol rules. That means the wallet signed
-    ///         a transaction input pointing to that UTXO and there is a unique
-    ///         sighash and signature pair associated with that input. This
-    ///         function uses those parameters to create a fraud accusation that
-    ///         proves a given transaction input unlocking the given UTXO was
-    ///         actually signed by the wallet. This function cannot determine
-    ///         whether the transaction was actually broadcast and the input was
-    ///         consumed in a fraudulent way so it just opens a challenge period
-    ///         during which the wallet can defeat the challenge by submitting
-    ///         proof of a transaction that consumes the given input according
-    ///         to protocol rules. To prevent spurious allegations, the caller
-    ///         must deposit ETH that is returned back upon justified fraud
-    ///         challenge or confiscated otherwise.
-    ///@param walletPublicKey The public key of the wallet in the uncompressed
-    ///       and unprefixed format (64 bytes)
-    /// @param sighash The hash that was used to produce the ECDSA signature
-    ///        that is the subject of the fraud claim. This hash is constructed
-    ///        by applying double SHA-256 over a serialized subset of the
-    ///        transaction. The exact subset used as hash preimage depends on
-    ///        the transaction input the signature is produced for. See BIP-143
-    ///        for reference
-    /// @param signature Bitcoin signature in the R/S/V format
-    /// @dev Requirements:
-    ///      - Wallet behind `walletPubKey` must be in `Live` or `MovingFunds`
-    ///        state
-    ///      - The challenger must send appropriate amount of ETH used as
-    ///        fraud challenge deposit
-    ///      - The signature (represented by r, s and v) must be generated by
-    ///        the wallet behind `walletPubKey` during signing of `sighash`
-    ///      - Wallet can be challenged for the given signature only once
-    function submitFraudChallenge(
-        bytes calldata walletPublicKey,
-        bytes32 sighash,
-        BitcoinTx.RSVSignature calldata signature
-    ) external payable {
-        bytes memory compressedWalletPublicKey = EcdsaLib.compressPublicKey(
-            walletPublicKey.slice32(0),
-            walletPublicKey.slice32(32)
-        );
-        bytes20 walletPubKeyHash = compressedWalletPublicKey.hash160View();
-
-        Wallets.Wallet storage wallet = wallets.registeredWallets[
-            walletPubKeyHash
-        ];
-
-        require(
-            wallet.state == Wallets.WalletState.Live ||
-                wallet.state == Wallets.WalletState.MovingFunds,
-            "Wallet is neither in Live nor MovingFunds state"
-        );
-
-        frauds.submitChallenge(
-            walletPublicKey,
-            walletPubKeyHash,
-            sighash,
-            signature
-        );
-    }
-
-    /// @notice Allows to defeat a pending fraud challenge against a wallet if
-    ///         the transaction that spends the UTXO follows the protocol rules.
-    ///         In order to defeat the challenge the same `walletPublicKey` and
-    ///         signature (represented by `r`, `s` and `v`) must be provided as
-    ///         were used to calculate the sighash during input signing.
-    ///         The fraud challenge defeat attempt will only succeed if the
-    ///         inputs in the preimage are considered honestly spent by the
-    ///         wallet. Therefore the transaction spending the UTXO must be
-    ///         proven in the Bridge before a challenge defeat is called.
-    ///         If successfully defeated, the fraud challenge is marked as
-    ///         resolved and the amount of ether deposited by the challenger is
-    ///         sent to the treasury.
-    /// @param walletPublicKey The public key of the wallet in the uncompressed
-    ///        and unprefixed format (64 bytes)
-    /// @param preimage The preimage which produces sighash used to generate the
-    ///        ECDSA signature that is the subject of the fraud claim. It is a
-    ///        serialized subset of the transaction. The exact subset used as
-    ///        the preimage depends on the transaction input the signature is
-    ///        produced for. See BIP-143 for reference
-    /// @param witness Flag indicating whether the preimage was produced for a
-    ///        witness input. True for witness, false for non-witness input
-    /// @dev Requirements:
-    ///      - `walletPublicKey` and `sighash` calculated as `hash256(preimage)`
-    ///        must identify an open fraud challenge
-    ///      - the preimage must be a valid preimage of a transaction generated
-    ///        according to the protocol rules and already proved in the Bridge
-    ///      - before a defeat attempt is made the transaction that spends the
-    ///        given UTXO must be proven in the Bridge
-    function defeatFraudChallenge(
-        bytes calldata walletPublicKey,
-        bytes calldata preimage,
-        bool witness
-    ) external {
-        uint256 utxoKey = frauds.unwrapChallenge(
-            walletPublicKey,
-            preimage,
-            witness
-        );
-
-        // Check that the UTXO key identifies a correctly spent UTXO.
-        require(
-            self.deposits[utxoKey].sweptAt > 0 || self.spentMainUTXOs[utxoKey],
-            "Spent UTXO not found among correctly spent UTXOs"
-        );
-
-        frauds.defeatChallenge(walletPublicKey, preimage, self.treasury);
-    }
-
-    /// @notice Notifies about defeat timeout for the given fraud challenge.
-    ///         Can be called only if there was a fraud challenge identified by
-    ///         the provided `walletPublicKey` and `sighash` and it was not
-    ///         defeated on time. The amount of time that needs to pass after
-    ///         a fraud challenge is reported is indicated by the
-    ///         `challengeDefeatTimeout`. After a successful fraud challenge
-    ///         defeat timeout notification the fraud challenge is marked as
-    ///         resolved, the stake of each operator is slashed, the ether
-    ///         deposited is returned to the challenger and the challenger is
-    ///         rewarded.
-    /// @param walletPublicKey The public key of the wallet in the uncompressed
-    ///        and unprefixed format (64 bytes)
-    /// @param sighash The hash that was used to produce the ECDSA signature
-    ///        that is the subject of the fraud claim. This hash is constructed
-    ///        by applying double SHA-256 over a serialized subset of the
-    ///        transaction. The exact subset used as hash preimage depends on
-    ///        the transaction input the signature is produced for. See BIP-143
-    ///        for reference
-    /// @dev Requirements:
-    ///      - `walletPublicKey`and `sighash` must identify an open fraud
-    ///        challenge
-    ///      - the amount of time indicated by `challengeDefeatTimeout` must
-    ///        pass after the challenge was reported
-    function notifyFraudChallengeDefeatTimeout(
-        bytes calldata walletPublicKey,
-        bytes32 sighash
-    ) external {
-        frauds.notifyChallengeDefeatTimeout(walletPublicKey, sighash);
-    }
-
-    /// @notice Returns parameters used by the `Frauds` library.
-    /// @return slashingAmount Value of the slashing amount
-    /// @return notifierRewardMultiplier Value of the notifier reward multiplier
-    /// @return challengeDefeatTimeout Value of the challenge defeat timeout
-    /// @return challengeDepositAmount Value of the challenge deposit amount
-    function getFraudParameters()
-        external
-        view
-        returns (
-            uint256 slashingAmount,
-            uint256 notifierRewardMultiplier,
-            uint256 challengeDefeatTimeout,
-            uint256 challengeDepositAmount
-        )
-    {
-        slashingAmount = frauds.slashingAmount;
-        notifierRewardMultiplier = frauds.notifierRewardMultiplier;
-        challengeDefeatTimeout = frauds.challengeDefeatTimeout;
-        challengeDepositAmount = frauds.challengeDepositAmount;
-
-        return (
-            slashingAmount,
-            notifierRewardMultiplier,
-            challengeDefeatTimeout,
-            challengeDepositAmount
-        );
-    }
-
-    /// @notice Returns the fraud challenge identified by the given key built
-    ///         as keccak256(walletPublicKey|sighash).
-    function fraudChallenges(uint256 challengeKey)
-        external
-        view
-        returns (Frauds.FraudChallenge memory)
-    {
-        return frauds.challenges[challengeKey];
-    }
-
-    /// @notice Requests redemption of the given amount from the specified
-    ///         wallet to the redeemer Bitcoin output script.
-    /// @param walletPubKeyHash The 20-byte wallet public key hash (computed
-    ///        using Bitcoin HASH160 over the compressed ECDSA public key)
-    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on
-    ///        the Ethereum chain
-    /// @param redeemerOutputScript The redeemer's length-prefixed output
-    ///        script (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock
-    ///        redeemed BTC
-    /// @param amount Requested amount in satoshi. This is also the TBTC amount
-    ///        that is taken from redeemer's balance in the Bank upon request.
-    ///        Once the request is handled, the actual amount of BTC locked
-    ///        on the redeemer output script will be always lower than this value
-    ///        since the treasury and Bitcoin transaction fees must be incurred.
-    ///        The minimal amount satisfying the request can be computed as:
-    ///        `amount - (amount / redemptionTreasuryFeeDivisor) - redemptionTxMaxFee`.
-    ///        Fees values are taken at the moment of request creation.
+    /// @notice Requests redemption of the given amount from the specified
+    ///         wallet to the redeemer Bitcoin output script.
+    /// @param walletPubKeyHash The 20-byte wallet public key hash (computed
+    ///        using Bitcoin HASH160 over the compressed ECDSA public key)
+    /// @param mainUtxo Data of the wallet's main UTXO, as currently known on
+    ///        the Ethereum chain
+    /// @param redeemerOutputScript The redeemer's length-prefixed output
+    ///        script (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock
+    ///        redeemed BTC
+    /// @param amount Requested amount in satoshi. This is also the TBTC amount
+    ///        that is taken from redeemer's balance in the Bank upon request.
+    ///        Once the request is handled, the actual amount of BTC locked
+    ///        on the redeemer output script will be always lower than this value
+    ///        since the treasury and Bitcoin transaction fees must be incurred.
+    ///        The minimal amount satisfying the request can be computed as:
+    ///        `amount - (amount / redemptionTreasuryFeeDivisor) - redemptionTxMaxFee`.
+    ///        Fees values are taken at the moment of request creation.
     /// @dev Requirements:
     ///      - Wallet behind `walletPubKeyHash` must be live
     ///      - `mainUtxo` components must point to the recent main UTXO
@@ -679,7 +312,6 @@ contract Bridge is Ownable, EcdsaWalletOwner {
         uint64 amount
     ) external {
         self.requestRedemption(
-            wallets,
             walletPubKeyHash,
             mainUtxo,
             redeemerOutputScript,
@@ -738,7 +370,6 @@ contract Bridge is Ownable, EcdsaWalletOwner {
         bytes20 walletPubKeyHash
     ) external {
         self.submitRedemptionProof(
-            wallets,
             redemptionTx,
             redemptionProof,
             mainUtxo,
@@ -774,11 +405,7 @@ contract Bridge is Ownable, EcdsaWalletOwner {
         bytes20 walletPubKeyHash,
         bytes calldata redeemerOutputScript
     ) external {
-        self.notifyRedemptionTimeout(
-            wallets,
-            walletPubKeyHash,
-            redeemerOutputScript
-        );
+        self.notifyRedemptionTimeout(walletPubKeyHash, redeemerOutputScript);
     }
 
     /// @notice Used by the wallet to prove the BTC moving funds transaction
@@ -833,7 +460,6 @@ contract Bridge is Ownable, EcdsaWalletOwner {
         bytes20 walletPubKeyHash
     ) external {
         self.submitMovingFundsProof(
-            wallets,
             movingFundsTx,
             movingFundsProof,
             mainUtxo,
@@ -841,29 +467,350 @@ contract Bridge is Ownable, EcdsaWalletOwner {
         );
     }
 
-    /// @notice Returns the addresses of contracts Bridge is interacting with.
-    /// @return bank Address of the Bank the Bridge belongs to.
-    /// @return relay Address of the Bitcoin relay providing the current Bitcoin
-    ///         network difficulty.
-    function getContracts() external view returns (Bank bank, IRelay relay) {
-        bank = self.bank;
-        relay = self.relay;
+    /// @notice Requests creation of a new wallet. This function just
+    ///         forms a request and the creation process is performed
+    ///         asynchronously. Once a wallet is created, the ECDSA Wallet
+    ///         Registry will notify this contract by calling the
+    ///         `__ecdsaWalletCreatedCallback` function.
+    /// @param activeWalletMainUtxo Data of the active wallet's main UTXO, as
+    ///        currently known on the Ethereum chain.
+    /// @dev Requirements:
+    ///      - `activeWalletMainUtxo` components must point to the recent main
+    ///        UTXO of the given active wallet, as currently known on the
+    ///        Ethereum chain. If there is no active wallet at the moment, or
+    ///        the active wallet has no main UTXO, this parameter can be
+    ///        empty as it is ignored.
+    ///      - Wallet creation must not be in progress
+    ///      - If the active wallet is set, one of the following
+    ///        conditions must be true:
+    ///        - The active wallet BTC balance is above the minimum threshold
+    ///          and the active wallet is old enough, i.e. the creation period
+    ///          was elapsed since its creation time
+    ///        - The active wallet BTC balance is above the maximum threshold
+    function requestNewWallet(BitcoinTx.UTXO calldata activeWalletMainUtxo)
+        external
+    {
+        self.requestNewWallet(activeWalletMainUtxo);
     }
 
-    /// @notice Address where the deposit treasury fees will be sent to.
-    ///         Treasury takes part in the operators rewarding process.
-    function treasury() external view returns (address treasury) {
-        treasury = self.treasury;
+    /// @notice A callback function that is called by the ECDSA Wallet Registry
+    ///         once a new ECDSA wallet is created.
+    /// @param ecdsaWalletID Wallet's unique identifier.
+    /// @param publicKeyX Wallet's public key's X coordinate.
+    /// @param publicKeyY Wallet's public key's Y coordinate.
+    /// @dev Requirements:
+    ///      - The only caller authorized to call this function is `registry`
+    ///      - Given wallet data must not belong to an already registered wallet
+    function __ecdsaWalletCreatedCallback(
+        bytes32 ecdsaWalletID,
+        bytes32 publicKeyX,
+        bytes32 publicKeyY
+    ) external override {
+        self.registerNewWallet(ecdsaWalletID, publicKeyX, publicKeyY);
     }
 
-    /// @notice The number of confirmations on the Bitcoin chain required to
-    ///         successfully evaluate an SPV proof.
-    function txProofDifficultyFactor()
+    /// @notice A callback function that is called by the ECDSA Wallet Registry
+    ///         once a wallet heartbeat failure is detected.
+    /// @param publicKeyX Wallet's public key's X coordinate
+    /// @param publicKeyY Wallet's public key's Y coordinate
+    /// @dev Requirements:
+    ///      - The only caller authorized to call this function is `registry`
+    ///      - Wallet must be in Live state
+    function __ecdsaWalletHeartbeatFailedCallback(
+        bytes32,
+        bytes32 publicKeyX,
+        bytes32 publicKeyY
+    ) external override {
+        self.notifyWalletHeartbeatFailed(publicKeyX, publicKeyY);
+    }
+
+    /// @notice Notifies that the wallet is either old enough or has too few
+    ///         satoshis left and qualifies to be closed.
+    /// @param walletPubKeyHash 20-byte public key hash of the wallet
+    /// @param walletMainUtxo Data of the wallet's main UTXO, as currently
+    ///        known on the Ethereum chain.
+    /// @dev Requirements:
+    ///      - Wallet must not be set as the current active wallet
+    ///      - Wallet must exceed the wallet maximum age OR the wallet BTC
+    ///        balance must be lesser than the minimum threshold. If the latter
+    ///        case is true, the `walletMainUtxo` components must point to the
+    ///        recent main UTXO of the given wallet, as currently known on the
+    ///        Ethereum chain. If the wallet has no main UTXO, this parameter
+    ///        can be empty as it is ignored since the wallet balance is
+    ///        assumed to be zero.
+    ///      - Wallet must be in Live state
+    function notifyCloseableWallet(
+        bytes20 walletPubKeyHash,
+        BitcoinTx.UTXO calldata walletMainUtxo
+    ) external {
+        self.notifyCloseableWallet(walletPubKeyHash, walletMainUtxo);
+    }
+
+    /// @notice Submits a fraud challenge indicating that a UTXO being under
+    ///         wallet control was unlocked by the wallet but was not used
+    ///         according to the protocol rules. That means the wallet signed
+    ///         a transaction input pointing to that UTXO and there is a unique
+    ///         sighash and signature pair associated with that input. This
+    ///         function uses those parameters to create a fraud accusation that
+    ///         proves a given transaction input unlocking the given UTXO was
+    ///         actually signed by the wallet. This function cannot determine
+    ///         whether the transaction was actually broadcast and the input was
+    ///         consumed in a fraudulent way so it just opens a challenge period
+    ///         during which the wallet can defeat the challenge by submitting
+    ///         proof of a transaction that consumes the given input according
+    ///         to protocol rules. To prevent spurious allegations, the caller
+    ///         must deposit ETH that is returned back upon justified fraud
+    ///         challenge or confiscated otherwise.
+    ///@param walletPublicKey The public key of the wallet in the uncompressed
+    ///       and unprefixed format (64 bytes)
+    /// @param sighash The hash that was used to produce the ECDSA signature
+    ///        that is the subject of the fraud claim. This hash is constructed
+    ///        by applying double SHA-256 over a serialized subset of the
+    ///        transaction. The exact subset used as hash preimage depends on
+    ///        the transaction input the signature is produced for. See BIP-143
+    ///        for reference
+    /// @param signature Bitcoin signature in the R/S/V format
+    /// @dev Requirements:
+    ///      - Wallet behind `walletPubKey` must be in `Live` or `MovingFunds`
+    ///        state
+    ///      - The challenger must send appropriate amount of ETH used as
+    ///        fraud challenge deposit
+    ///      - The signature (represented by r, s and v) must be generated by
+    ///        the wallet behind `walletPubKey` during signing of `sighash`
+    ///      - Wallet can be challenged for the given signature only once
+    function submitFraudChallenge(
+        bytes calldata walletPublicKey,
+        bytes32 sighash,
+        BitcoinTx.RSVSignature calldata signature
+    ) external payable {
+        self.submitFraudChallenge(walletPublicKey, sighash, signature);
+    }
+
+    /// @notice Allows to defeat a pending fraud challenge against a wallet if
+    ///         the transaction that spends the UTXO follows the protocol rules.
+    ///         In order to defeat the challenge the same `walletPublicKey` and
+    ///         signature (represented by `r`, `s` and `v`) must be provided as
+    ///         were used to calculate the sighash during input signing.
+    ///         The fraud challenge defeat attempt will only succeed if the
+    ///         inputs in the preimage are considered honestly spent by the
+    ///         wallet. Therefore the transaction spending the UTXO must be
+    ///         proven in the Bridge before a challenge defeat is called.
+    ///         If successfully defeated, the fraud challenge is marked as
+    ///         resolved and the amount of ether deposited by the challenger is
+    ///         sent to the treasury.
+    /// @param walletPublicKey The public key of the wallet in the uncompressed
+    ///        and unprefixed format (64 bytes)
+    /// @param preimage The preimage which produces sighash used to generate the
+    ///        ECDSA signature that is the subject of the fraud claim. It is a
+    ///        serialized subset of the transaction. The exact subset used as
+    ///        the preimage depends on the transaction input the signature is
+    ///        produced for. See BIP-143 for reference
+    /// @param witness Flag indicating whether the preimage was produced for a
+    ///        witness input. True for witness, false for non-witness input
+    /// @dev Requirements:
+    ///      - `walletPublicKey` and `sighash` calculated as `hash256(preimage)`
+    ///        must identify an open fraud challenge
+    ///      - the preimage must be a valid preimage of a transaction generated
+    ///        according to the protocol rules and already proved in the Bridge
+    ///      - before a defeat attempt is made the transaction that spends the
+    ///        given UTXO must be proven in the Bridge
+    function defeatFraudChallenge(
+        bytes calldata walletPublicKey,
+        bytes calldata preimage,
+        bool witness
+    ) external {
+        self.defeatFraudChallenge(walletPublicKey, preimage, witness);
+    }
+
+    /// @notice Notifies about defeat timeout for the given fraud challenge.
+    ///         Can be called only if there was a fraud challenge identified by
+    ///         the provided `walletPublicKey` and `sighash` and it was not
+    ///         defeated on time. The amount of time that needs to pass after
+    ///         a fraud challenge is reported is indicated by the
+    ///         `challengeDefeatTimeout`. After a successful fraud challenge
+    ///         defeat timeout notification the fraud challenge is marked as
+    ///         resolved, the stake of each operator is slashed, the ether
+    ///         deposited is returned to the challenger and the challenger is
+    ///         rewarded.
+    /// @param walletPublicKey The public key of the wallet in the uncompressed
+    ///        and unprefixed format (64 bytes)
+    /// @param sighash The hash that was used to produce the ECDSA signature
+    ///        that is the subject of the fraud claim. This hash is constructed
+    ///        by applying double SHA-256 over a serialized subset of the
+    ///        transaction. The exact subset used as hash preimage depends on
+    ///        the transaction input the signature is produced for. See BIP-143
+    ///        for reference
+    /// @dev Requirements:
+    ///      - `walletPublicKey`and `sighash` must identify an open fraud
+    ///        challenge
+    ///      - the amount of time indicated by `challengeDefeatTimeout` must
+    ///        pass after the challenge was reported
+    function notifyFraudChallengeDefeatTimeout(
+        bytes calldata walletPublicKey,
+        bytes32 sighash
+    ) external {
+        self.notifyFraudChallengeDefeatTimeout(walletPublicKey, sighash);
+    }
+
+    /// @notice Allows the Governance to mark the given vault address as trusted
+    ///         or no longer trusted. Vaults are not trusted by default.
+    ///         Trusted vault must meet the following criteria:
+    ///         - `IVault.receiveBalanceIncrease` must have a known, low gas
+    ///           cost.
+    ///         - `IVault.receiveBalanceIncrease` must never revert.
+    /// @dev Without restricting reveal only to trusted vaults, malicious
+    ///      vaults not meeting the criteria would be able to nuke sweep proof
+    ///      transactions executed by ECDSA wallet with  deposits routed to
+    ///      them.
+    /// @param vault The address of the vault
+    /// @param isTrusted flag indicating whether the vault is trusted or not
+    /// @dev Can only be called by the Governance.
+    function setVaultStatus(address vault, bool isTrusted) external onlyOwner {
+        self.isVaultTrusted[vault] = isTrusted;
+        emit VaultStatusUpdated(vault, isTrusted);
+    }
+
+    // TODO: updateDepositParameters
+    // TODO: updateRedemptionParameters
+    // TODO: updateMovingFundsParameters
+
+    /// @notice Updates parameters of wallets.
+    /// @param walletCreationPeriod New value of the wallet creation period in
+    ///        seconds, determines how frequently a new wallet creation can be
+    ///        requested
+    /// @param walletMinBtcBalance New value of the wallet minimum BTC balance
+    ///        in satoshis, used to decide about wallet creation or closing
+    /// @param walletMaxBtcBalance New value of the wallet maximum BTC balance
+    ///        in satoshis, used to decide about wallet creation
+    /// @param walletMaxAge New value of the wallet maximum age in seconds,
+    ///        indicates the maximum age of a wallet in seconds, after which
+    ///        the wallet moving funds process can be requested
+    /// @dev Requirements:
+    ///      - Wallet minimum BTC balance must be greater than zero
+    ///      - Wallet maximum BTC balance must be greater than the wallet
+    ///        minimum BTC balance
+    function updateWalletParameters(
+        uint32 walletCreationPeriod,
+        uint64 walletMinBtcBalance,
+        uint64 walletMaxBtcBalance,
+        uint32 walletMaxAge
+    ) external onlyOwner {
+        self.updateWalletParameters(
+            walletCreationPeriod,
+            walletMinBtcBalance,
+            walletMaxBtcBalance,
+            walletMaxAge
+        );
+    }
+
+    // TODO: updateFraudParameters
+
+    /// @notice Collection of all revealed deposits indexed by
+    ///         keccak256(fundingTxHash | fundingOutputIndex).
+    ///         The fundingTxHash is bytes32 (ordered as in Bitcoin internally)
+    ///         and fundingOutputIndex an uint32. This mapping may contain valid
+    ///         and invalid deposits and the wallet is responsible for
+    ///         validating them before attempting to execute a sweep.
+    function deposits(uint256 depositKey)
+        external
+        view
+        returns (Deposit.DepositRequest memory)
+    {
+        return self.deposits[depositKey];
+    }
+
+    /// @notice Collection of all pending redemption requests indexed by
+    ///         redemption key built as
+    ///         keccak256(walletPubKeyHash | redeemerOutputScript). The
+    ///         walletPubKeyHash is the 20-byte wallet's public key hash
+    ///         (computed using Bitcoin HASH160 over the compressed ECDSA
+    ///         public key) and redeemerOutputScript is a Bitcoin script
+    ///         (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock
+    ///         redeemed BTC as requested by the redeemer. Requests are added
+    ///         to this mapping by the `requestRedemption` method (duplicates
+    ///         not allowed) and are removed by one of the following methods:
+    ///         - `submitRedemptionProof` in case the request was handled
+    ///           successfully
+    ///         - `notifyRedemptionTimeout` in case the request was reported
+    ///           to be timed out
+    function pendingRedemptions(uint256 redemptionKey)
         external
         view
-        returns (uint256 txProofDifficultyFactor)
+        returns (Redemption.RedemptionRequest memory)
     {
-        txProofDifficultyFactor = self.txProofDifficultyFactor;
+        return self.pendingRedemptions[redemptionKey];
+    }
+
+    /// @notice Collection of all timed out redemptions requests indexed by
+    ///         redemption key built as
+    ///         keccak256(walletPubKeyHash | redeemerOutputScript). The
+    ///         walletPubKeyHash is the 20-byte wallet's public key hash
+    ///         (computed using Bitcoin HASH160 over the compressed ECDSA
+    ///         public key) and redeemerOutputScript is the Bitcoin script
+    ///         (P2PKH, P2WPKH, P2SH or P2WSH) that is involved in the timed
+    ///         out request. Timed out requests are stored in this mapping to
+    ///         avoid slashing the wallets multiple times for the same timeout.
+    ///         Only one method can add to this mapping:
+    ///         - `notifyRedemptionTimeout` which puts the redemption key
+    ///           to this mapping basing on a timed out request stored
+    ///           previously in `pendingRedemptions` mapping.
+    function timedOutRedemptions(uint256 redemptionKey)
+        external
+        view
+        returns (Redemption.RedemptionRequest memory)
+    {
+        return self.timedOutRedemptions[redemptionKey];
+    }
+
+    /// @notice Collection of main UTXOs that are honestly spent indexed by
+    ///         keccak256(fundingTxHash | fundingOutputIndex). The fundingTxHash
+    ///         is bytes32 (ordered as in Bitcoin internally) and
+    ///         fundingOutputIndex an uint32. A main UTXO is considered honestly
+    ///         spent if it was used as an input of a transaction that have been
+    ///         proven in the Bridge.
+    function spentMainUTXOs(uint256 utxoKey) external view returns (bool) {
+        return self.spentMainUTXOs[utxoKey];
+    }
+
+    /// @notice Gets details about a registered wallet.
+    /// @param walletPubKeyHash The 20-byte wallet public key hash (computed
+    ///        using Bitcoin HASH160 over the compressed ECDSA public key)
+    /// @return Wallet details.
+    function wallets(bytes20 walletPubKeyHash)
+        external
+        view
+        returns (Wallets.Wallet memory)
+    {
+        return self.registeredWallets[walletPubKeyHash];
+    }
+
+    /// @notice Gets the public key hash of the active wallet.
+    /// @return The 20-byte public key hash (computed using Bitcoin HASH160
+    ///         over the compressed ECDSA public key) of the active wallet.
+    ///         Returns bytes20(0) if there is no active wallet at the moment.
+    function activeWalletPubKeyHash() external view returns (bytes20) {
+        return self.activeWalletPubKeyHash;
+    }
+
+    /// @notice Returns the fraud challenge identified by the given key built
+    ///         as keccak256(walletPublicKey|sighash).
+    function fraudChallenges(uint256 challengeKey)
+        external
+        view
+        returns (Fraud.FraudChallenge memory)
+    {
+        return self.fraudChallenges[challengeKey];
+    }
+
+    /// @notice Indicates if the vault with the given address is trusted or not.
+    ///         Depositors can route their revealed deposits only to trusted
+    ///         vaults and have trusted vaults notified about new deposits as
+    ///         soon as these deposits get swept. Vaults not trusted by the
+    ///         Bridge can still be used by Bank balance owners on their own
+    ///         responsibility - anyone can approve their Bank balance to any
+    ///         address.
+    function isVaultTrusted(address vault) external view returns (bool) {
+        return self.isVaultTrusted[vault];
     }
 
     /// @notice Returns the current values of Bridge deposit parameters.
@@ -927,9 +874,7 @@ contract Bridge is Ownable, EcdsaWalletOwner {
             uint64 redemptionDustThreshold,
             uint64 redemptionTreasuryFeeDivisor,
             uint64 redemptionTxMaxFee,
-            uint256 redemptionTimeout,
-            address treasury,
-            uint256 txProofDifficultyFactor
+            uint256 redemptionTimeout
         )
     {
         redemptionDustThreshold = self.redemptionDustThreshold;
@@ -953,81 +898,78 @@ contract Bridge is Ownable, EcdsaWalletOwner {
         movingFundsTxMaxTotalFee = self.movingFundsTxMaxTotalFee;
     }
 
-    /// @notice Indicates if the vault with the given address is trusted or not.
-    ///         Depositors can route their revealed deposits only to trusted
-    ///         vaults and have trusted vaults notified about new deposits as
-    ///         soon as these deposits get swept. Vaults not trusted by the
-    ///         Bridge can still be used by Bank balance owners on their own
-    ///         responsibility - anyone can approve their Bank balance to any
-    ///         address.
-    function isVaultTrusted(address vault) external view returns (bool) {
-        return self.isVaultTrusted[vault];
-    }
-
-    /// @notice Collection of all revealed deposits indexed by
-    ///         keccak256(fundingTxHash | fundingOutputIndex).
-    ///         The fundingTxHash is bytes32 (ordered as in Bitcoin internally)
-    ///         and fundingOutputIndex an uint32. This mapping may contain valid
-    ///         and invalid deposits and the wallet is responsible for
-    ///         validating them before attempting to execute a sweep.
-    function deposits(uint256 depositKey)
+    /// @return walletCreationPeriod Determines how frequently a new wallet
+    ///         creation can be requested. Value in seconds.
+    /// @return walletMinBtcBalance The minimum BTC threshold in satoshi that is
+    ///         used to decide about wallet creation or closing.
+    /// @return walletMaxBtcBalance The maximum BTC threshold in satoshi that is
+    ///         used to decide about wallet creation.
+    /// @return walletMaxAge The maximum age of a wallet in seconds, after which
+    ///         the wallet moving funds process can be requested.
+    function walletParameters()
         external
         view
-        returns (Deposit.DepositRequest memory)
+        returns (
+            uint32 walletCreationPeriod,
+            uint64 walletMinBtcBalance,
+            uint64 walletMaxBtcBalance,
+            uint32 walletMaxAge
+        )
     {
-        return self.deposits[depositKey];
-    }
-
-    /// @notice Collection of main UTXOs that are honestly spent indexed by
-    ///         keccak256(fundingTxHash | fundingOutputIndex). The fundingTxHash
-    ///         is bytes32 (ordered as in Bitcoin internally) and
-    ///         fundingOutputIndex an uint32. A main UTXO is considered honestly
-    ///         spent if it was used as an input of a transaction that have been
-    ///         proven in the Bridge.
-    function spentMainUTXOs(uint256 utxoKey) external view returns (bool) {
-        return self.spentMainUTXOs[utxoKey];
-    }
-
-    /// @notice Collection of all pending redemption requests indexed by
-    ///         redemption key built as
-    ///         keccak256(walletPubKeyHash | redeemerOutputScript). The
-    ///         walletPubKeyHash is the 20-byte wallet's public key hash
-    ///         (computed using Bitcoin HASH160 over the compressed ECDSA
-    ///         public key) and redeemerOutputScript is a Bitcoin script
-    ///         (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock
-    ///         redeemed BTC as requested by the redeemer. Requests are added
-    ///         to this mapping by the `requestRedemption` method (duplicates
-    ///         not allowed) and are removed by one of the following methods:
-    ///         - `submitRedemptionProof` in case the request was handled
-    ///           successfully
-    ///         - `notifyRedemptionTimeout` in case the request was reported
-    ///           to be timed out
-    function pendingRedemptions(uint256 redemptionKey)
+        walletCreationPeriod = self.walletCreationPeriod;
+        walletMinBtcBalance = self.walletMinBtcBalance;
+        walletMaxBtcBalance = self.walletMaxBtcBalance;
+        walletMaxAge = self.walletMaxAge;
+    }
+
+    /// @notice Returns the current values of Bridge fraud parameters.
+    /// @return fraudSlashingAmount The amount slashed from each wallet member
+    ///         for committing a fraud.
+    /// @return fraudNotifierRewardMultiplier The percentage of the notifier
+    ///         reward from the staking contract the notifier of a fraud
+    ///         receives. The value is in the range [0, 100].
+    /// @return fraudChallengeDefeatTimeout The amount of time the wallet has to
+    ///         defeat a fraud challenge.
+    /// @return fraudChallengeDepositAmount The amount of ETH in wei the party
+    ///         challenging the wallet for fraud needs to deposit.
+    function fraudParameters()
         external
         view
-        returns (Redeem.RedemptionRequest memory)
+        returns (
+            uint256 fraudSlashingAmount,
+            uint256 fraudNotifierRewardMultiplier,
+            uint256 fraudChallengeDefeatTimeout,
+            uint256 fraudChallengeDepositAmount
+        )
     {
-        return self.pendingRedemptions[redemptionKey];
+        fraudSlashingAmount = self.fraudSlashingAmount;
+        fraudNotifierRewardMultiplier = self.fraudNotifierRewardMultiplier;
+        fraudChallengeDefeatTimeout = self.fraudChallengeDefeatTimeout;
+        fraudChallengeDepositAmount = self.fraudChallengeDepositAmount;
     }
 
-    /// @notice Collection of all timed out redemptions requests indexed by
-    ///         redemption key built as
-    ///         keccak256(walletPubKeyHash | redeemerOutputScript). The
-    ///         walletPubKeyHash is the 20-byte wallet's public key hash
-    ///         (computed using Bitcoin HASH160 over the compressed ECDSA
-    ///         public key) and redeemerOutputScript is the Bitcoin script
-    ///         (P2PKH, P2WPKH, P2SH or P2WSH) that is involved in the timed
-    ///         out request. Timed out requests are stored in this mapping to
-    ///         avoid slashing the wallets multiple times for the same timeout.
-    ///         Only one method can add to this mapping:
-    ///         - `notifyRedemptionTimeout` which puts the redemption key
-    ///           to this mapping basing on a timed out request stored
-    ///           previously in `pendingRedemptions` mapping.
-    function timedOutRedemptions(uint256 redemptionKey)
+    /// @notice Returns the addresses of contracts Bridge is interacting with.
+    /// @return bank Address of the Bank the Bridge belongs to.
+    /// @return relay Address of the Bitcoin relay providing the current Bitcoin
+    ///         network difficulty.
+    function contractReferences()
         external
         view
-        returns (Redeem.RedemptionRequest memory)
+        returns (Bank bank, IRelay relay)
     {
-        return self.timedOutRedemptions[redemptionKey];
+        bank = self.bank;
+        relay = self.relay;
+    }
+
+    /// @notice Address where the deposit treasury fees will be sent to.
+    ///         Treasury takes part in the operators rewarding process.
+    function treasury() external view returns (address) {
+        return self.treasury;
+    }
+
+    /// @notice The number of confirmations on the Bitcoin chain required to
+    ///         successfully evaluate an SPV proof.
+    function txProofDifficultyFactor() external view returns (uint256) {
+        return self.txProofDifficultyFactor;
     }
 }