feat: add PegOutContract initial version

Author: Luisfc68

contracts/DaoContributor.sol

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.25;
+
+import {
+    OwnableUpgradeable
+} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {
+    ReentrancyGuardUpgradeable
+} from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
+import {Flyover} from "./libraries/Flyover.sol";
+
+abstract contract OwnableDaoContributorUpgradeable is
+    ReentrancyGuardUpgradeable,
+    OwnableUpgradeable {
+
+    // @custom:storage-location erc7201:rsk.dao.contributor
+    struct DaoContributorStorage {
+        uint256 feePercentage;
+        uint256 currentContribution;
+        address payable feeCollector;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256(bytes("rsk.dao.contributor"))) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant _CONTRIBUTOR_STORAGE_LOCATION =
+        0xb7e513d124139aa68259a99d4c2c344f3ba61e36716330d77f7fa887d0048e00;
+
+    event DaoContribution(address indexed contributor, uint256 indexed amount);
+    event DaoFeesClaimed(address indexed claimer, address indexed receiver, uint256 indexed amount);
+    event ContributionsConfigured(address indexed feeCollector, uint256 indexed feePercentage);
+
+    error NoFees();
+    error FeeCollectorUnset();
+
+    function claimContribution() external onlyOwner nonReentrant {
+        DaoContributorStorage storage $ = _getContributorStorage();
+        uint256 amount = $.currentContribution;
+        $.currentContribution = 0;
+        address feeCollector = $.feeCollector;
+        if (amount == 0) revert NoFees();
+        if (feeCollector == address(0)) revert FeeCollectorUnset();
+        if (amount > address(this).balance) revert Flyover.NoBalance(amount, address(this).balance);
+        emit DaoFeesClaimed(msg.sender, feeCollector, amount);
+        (bool sent, bytes memory reason) = feeCollector.call{value: amount}("");
+        if (!sent) revert Flyover.PaymentFailed(feeCollector, amount, reason);
+    }
+
+    function configureContributions(
+        address payable feeCollector,
+        uint256 feePercentage
+    ) external onlyOwner {
+        DaoContributorStorage storage $ = _getContributorStorage();
+        $.feeCollector = feeCollector;
+        $.feePercentage = feePercentage;
+        emit ContributionsConfigured(feeCollector, feePercentage);
+    }
+
+    function getFeePercentage() external view returns (uint256) {
+        return _getContributorStorage().feePercentage;
+    }
+
+    function getCurrentContribution() external view returns (uint256) {
+        return _getContributorStorage().currentContribution;
+    }
+
+    function getFeeCollector() external view returns (address) {
+        return _getContributorStorage().feeCollector;
+    }
+
+    // solhint-disable-next-line func-name-mixedcase
+    function __OwnableDaoContributor_init(
+        address owner,
+        uint256 feePercentage,
+        address payable feeCollector
+    ) internal onlyInitializing {
+        __Ownable_init(owner);
+        __ReentrancyGuard_init();
+        DaoContributorStorage storage $ = _getContributorStorage();
+        $.feePercentage = feePercentage;
+        $.feeCollector = feeCollector;
+    }
+
+    function _addDaoContribution(address contributor, uint256 amount) internal {
+        if (amount < 1) return;
+        DaoContributorStorage storage $ = _getContributorStorage();
+        $.currentContribution += amount;
+        emit DaoContribution(contributor, amount);
+    }
+
+    function _getContributorStorage() private pure returns (DaoContributorStorage storage $) {
+        assembly {
+            $.slot := _CONTRIBUTOR_STORAGE_LOCATION
+        }
+    }
+}

contracts/PegOutContract.sol

@@ -0,0 +1,274 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.25;
+
+import {BtcUtils} from "@rsksmart/btc-transaction-solidity-helper/contracts/BtcUtils.sol";
+import {OwnableDaoContributorUpgradeable} from "./DaoContributor.sol";
+import {IBridge} from "./interfaces/Bridge.sol";
+import {ICollateralManagement} from "./interfaces/CollateralManagement.sol";
+import {IPegOut} from "./interfaces/PegOut.sol";
+import {Flyover} from "./libraries/Flyover.sol";
+import {Quotes} from "./libraries/Quotes.sol";
+import {SignatureValidator} from "./libraries/SignatureValidator.sol";
+
+contract PegOutContract is
+    OwnableDaoContributorUpgradeable,
+    IPegOut
+{
+    struct PegOutRecord {
+        bool completed;
+        uint256 depositTimestamp;
+    }
+
+    string constant public VERSION = "1.0.0";
+    Flyover.ProviderType constant private _PEG_TYPE = Flyover.ProviderType.PegOut;
+    uint256 constant private _PAY_TO_ADDRESS_OUTPUT = 0;
+    uint256 constant private _QUOTE_HASH_OUTPUT = 1;
+    uint256 constant private _SAT_TO_WEI_CONVERSION = 10**10;
+    uint256 constant private _QUOTE_HASH_SIZE = 32;
+
+    IBridge private _bridge;
+    ICollateralManagement private _collateralManagement;
+
+    mapping(bytes32 => Quotes.PegOutQuote) private _pegOutQuotes;
+    mapping(bytes32 => PegOutRecord) private _pegOutRegistry;
+
+    uint256 public dustThreshold;
+    bool private _mainnet;
+    uint256 private _btcBlockTime;
+
+    function depositPegOut(
+        Quotes.PegOutQuote calldata quote,
+        bytes calldata signature
+    ) external payable nonReentrant override {
+        if(!_collateralManagement.isRegistered(_PEG_TYPE, quote.lpRskAddress)) {
+            revert Flyover.ProviderNotRegistered(quote.lpRskAddress);
+        }
+        uint256 requiredAmount = quote.value + quote.callFee + quote.productFeeAmount + quote.gasFee;
+        if (msg.value < requiredAmount) {
+            revert InsufficientAmount(msg.value, requiredAmount);
+        }
+        if (quote.depositDateLimit > block.timestamp || quote.expireDate > block.timestamp) {
+            revert QuoteExpiredByTime(quote.depositDateLimit, quote.expireDate);
+        }
+        if (quote.expireBlock > block.number) {
+            revert QuoteExpiredByBlocks(quote.expireBlock);
+        }
+
+        bytes32 quoteHash = _hashPegOutQuote(quote);
+        if (!SignatureValidator.verify(quote.lpRskAddress, quoteHash, signature)) {
+            revert SignatureValidator.IncorrectSignature(quote.lpRskAddress, quoteHash, signature);
+        }
+
+        Quotes.PegOutQuote storage registeredQuote = _pegOutQuotes[quoteHash];
+
+        if (_isQuoteCompleted(quoteHash)) {
+            revert QuoteAlreadyCompleted(quoteHash);
+        }
+        if (registeredQuote.lbcAddress != address(0)) {
+            revert QuoteAlreadyRegistered(quoteHash);
+        }
+
+        _pegOutQuotes[quoteHash] = quote;
+        _pegOutRegistry[quoteHash].depositTimestamp = block.timestamp;
+
+        emit PegOutDeposit(quoteHash, msg.sender, msg.value, block.timestamp);
+
+        if (dustThreshold < requiredAmount - msg.value) {
+            return;
+        }
+
+        uint256 change = requiredAmount - msg.value;
+        emit PegOutChangePaid(quoteHash, msg.sender, change);
+        (bool sent, bytes memory reason) = quote.lpRskAddress.call{value: change}("");
+        if (!sent) {
+            revert Flyover.PaymentFailed(quote.lpRskAddress, change, reason);
+        }
+    }
+
+    // solhint-disable-next-line comprehensive-interface
+    function initialize(
+        address owner,
+        address payable bridge,
+        uint256 dustThreshold_,
+        address collateralManagement,
+        bool mainnet,
+        uint256 daoFeePercentage,
+        address payable daoFeeCollector
+    ) external initializer {
+        __OwnableDaoContributor_init(owner, daoFeePercentage, daoFeeCollector);
+        _bridge = IBridge(bridge);
+        _collateralManagement = ICollateralManagement(collateralManagement);
+        _mainnet = mainnet;
+        dustThreshold = dustThreshold_;
+    }
+
+    function refundPegOut(
+        bytes32 quoteHash,
+        bytes calldata btcTx,
+        bytes32 btcBlockHeaderHash,
+        uint256 partialMerkleTree,
+        bytes32[] calldata merkleBranchHashes
+    ) external nonReentrant override {
+        if(!_collateralManagement.isRegistered(_PEG_TYPE, msg.sender)) {
+            revert Flyover.ProviderNotRegistered(msg.sender);
+        }
+        if (_isQuoteCompleted(quoteHash)) revert QuoteAlreadyCompleted(quoteHash);
+
+        Quotes.PegOutQuote storage quote = _pegOutQuotes[quoteHash];
+        if (quote.lbcAddress == address(0)) revert Flyover.QuoteNotFound(quoteHash);
+        if (quote.lpRskAddress != msg.sender) revert InvalidSender(quote.lpRskAddress, msg.sender);
+
+        BtcUtils.TxRawOutput[] memory outputs = BtcUtils.getOutputs(btcTx);
+        _validateBtcTxNullData(outputs, quoteHash);
+        _validateBtcTxConfirmations(quote, btcTx, btcBlockHeaderHash, partialMerkleTree, merkleBranchHashes);
+        _validateBtcTxAmount(outputs, quote);
+        _validateBtcTxDestination(outputs, quote);
+
+        if (_shouldPenalize(quote, quoteHash, btcBlockHeaderHash)) {
+            _collateralManagement.slashPegOutCollateral(quote, quoteHash);
+        }
+
+        delete _pegOutQuotes[quoteHash];
+        _pegOutRegistry[quoteHash].completed = true;
+        emit PegOutRefunded(quoteHash);
+
+        uint256 refundAmount = quote.value + quote.callFee + quote.gasFee;
+        (bool sent, bytes memory reason) = quote.lpRskAddress.call{value: refundAmount}("");
+        if (!sent) {
+            revert Flyover.PaymentFailed(quote.lpRskAddress, refundAmount, reason);
+        }
+        _addDaoContribution(quote.lpRskAddress, quote.productFeeAmount);
+    }
+
+    function refundUserPegOut(bytes32 quoteHash) external nonReentrant override {
+        Quotes.PegOutQuote storage quote = _pegOutQuotes[quoteHash];
+
+        if (quote.lbcAddress == address(0)) revert Flyover.QuoteNotFound(quoteHash);
+        // solhint-disable-next-line gas-strict-inequalities
+        if (quote.expireDate >= block.timestamp || quote.expireBlock >= block.number) revert QuoteNotExpired(quoteHash);
+
+        uint256 valueToTransfer = quote.value + quote.callFee + quote.productFeeAmount + quote.gasFee;
+        address addressToTransfer = quote.rskRefundAddress;
+
+        emit PegOutUserRefunded(quoteHash, quote.rskRefundAddress, valueToTransfer);
+        _collateralManagement.slashPegOutCollateral(quote, quoteHash);
+
+        delete _pegOutQuotes[quoteHash];
+        _pegOutRegistry[quoteHash].completed = true;
+
+        (bool sent, bytes memory reason) = addressToTransfer.call{value: valueToTransfer}("");
+        if (!sent) {
+            revert Flyover.PaymentFailed(addressToTransfer, valueToTransfer, reason);
+        }
+    }
+
+    function hashPegOutQuote(
+        Quotes.PegOutQuote calldata quote
+    ) external view override returns (bytes32) {
+        return _hashPegOutQuote(quote);
+    }
+
+    function isQuoteCompleted(bytes32 quoteHash) external view override returns (bool) {
+        return _isQuoteCompleted(quoteHash);
+    }
+
+    function _hashPegOutQuote(
+        Quotes.PegOutQuote calldata quote
+    ) private view returns (bytes32) {
+        if (address(this) != quote.lbcAddress) {
+            revert Flyover.IncorrectContract(address(this), quote.lbcAddress);
+        }
+        return keccak256(Quotes.encodePegOutQuote(quote));
+    }
+
+    function _isQuoteCompleted(bytes32 quoteHash) private view returns (bool) {
+        return _pegOutRegistry[quoteHash].completed;
+    }
+
+    function _shouldPenalize(
+        Quotes.PegOutQuote storage quote,
+        bytes32 quoteHash,
+        bytes32 blockHash
+    ) private view returns (bool) {
+        bytes memory firstConfirmationHeader = _bridge.getBtcBlockchainBlockHeaderByHash(blockHash);
+        if(firstConfirmationHeader.length < 1) revert Flyover.InvalidBlockHeader(firstConfirmationHeader);
+
+        uint256 firstConfirmationTimestamp = BtcUtils.getBtcBlockTimestamp(firstConfirmationHeader);
+        uint256 expectedConfirmationTime = _pegOutRegistry[quoteHash].depositTimestamp +
+            quote.transferTime +
+            _btcBlockTime;
+
+        // penalize if the transfer was not made on time
+        if (firstConfirmationTimestamp > expectedConfirmationTime) {
+            return true;
+        }
+
+        // penalize if LP is refunding after expiration
+        if (block.timestamp > quote.expireDate || block.number > quote.expireBlock) {
+            return true;
+        }
+
+        return false;
+    }
+
+    function _validateBtcTxConfirmations(
+        Quotes.PegOutQuote storage quote,
+        bytes calldata btcTx,
+        bytes32 btcBlockHeaderHash,
+        uint256 partialMerkleTree,
+        bytes32[] calldata merkleBranchHashes
+    ) private view {
+        int256 confirmations = _bridge.getBtcTransactionConfirmations(
+            BtcUtils.hashBtcTx(btcTx),
+            btcBlockHeaderHash,
+            partialMerkleTree,
+            merkleBranchHashes
+        );
+        if (confirmations < 0) {
+            revert UnableToGetConfirmations(confirmations);
+        } else if (confirmations < int(uint256(quote.transferConfirmations))) {
+            revert NotEnoughConfirmations(int(uint256(quote.transferConfirmations)), confirmations);
+        }
+    }
+
+    function _validateBtcTxAmount(
+        BtcUtils.TxRawOutput[] memory outputs,
+        Quotes.PegOutQuote storage quote
+    ) private view {
+        uint256 requiredAmount = quote.value;
+        if (quote.value > _SAT_TO_WEI_CONVERSION && (quote.value % _SAT_TO_WEI_CONVERSION) != 0) {
+            requiredAmount = quote.value - (quote.value % _SAT_TO_WEI_CONVERSION);
+        }
+        uint256 paidAmount = outputs[_PAY_TO_ADDRESS_OUTPUT].value * _SAT_TO_WEI_CONVERSION;
+        if (paidAmount < requiredAmount) revert InsufficientAmount(requiredAmount, paidAmount);
+    }
+
+    function _validateBtcTxDestination(
+        BtcUtils.TxRawOutput[] memory outputs,
+        Quotes.PegOutQuote storage quote
+    ) private view {
+        bytes memory btcTxDestination = BtcUtils.outputScriptToAddress(
+            outputs[_PAY_TO_ADDRESS_OUTPUT].pkScript,
+            _mainnet
+        );
+        if (keccak256(quote.depositAddress) != keccak256(btcTxDestination)) {
+            revert InvalidDestination(quote.depositAddress, btcTxDestination);
+        }
+    }
+
+    function _validateBtcTxNullData(BtcUtils.TxRawOutput[] memory outputs, bytes32 quoteHash) private pure {
+        bytes memory scriptContent = BtcUtils.parseNullDataScript(outputs[_QUOTE_HASH_OUTPUT].pkScript);
+        uint256 scriptLength = scriptContent.length;
+
+        if (scriptLength != _QUOTE_HASH_SIZE + 1 || uint8(scriptContent[0]) != _QUOTE_HASH_SIZE) {
+            revert MalformedTransaction(scriptContent);
+        }
+
+        // shift the array to remove the first byte (the size)
+        for (uint8 i = 0 ; i < scriptLength - 1; ++i) {
+            scriptContent[i] = scriptContent[i + 1];
+        }
+        bytes32 txQuoteHash = abi.decode(scriptContent, (bytes32));
+        if (quoteHash != txQuoteHash) revert InvalidQuoteHash(quoteHash, txQuoteHash);
+    }
+}