Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

/**
 * @title YBZ.io - Decentralized Escrow Platform
 * @notice "Trustless. Transparent. Guaranteed."
 * @dev Main entry point for YBZ.io escrow system.
 *      Code is Law. Immutable Code is Reliable Law.
 * 
 * @author YBZ.io Team
 * @custom:website https://ybz.io
 * @custom:security-contact [email protected]
 * @custom:version 1.0.3
 * @custom:date 2025-10-18
 */

import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";
import "./interfaces/IYBZCore.sol";
import "./libraries/DealValidation.sol";

contract YBZCore is 
    AccessControl,
    ReentrancyGuard,
    Pausable,
    IYBZCore
{
    using SafeERC20 for IERC20;
    using DealValidation for *;
    
    // ============ Roles ============
    
    bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
    bytes32 public constant ARBITER_ROLE = keccak256("ARBITER_ROLE");
    
    // ============ Hardcoded Addresses (Ethereum Mainnet Only) ============
    
    /// @notice Chainlink ETH/USD price feed (Mainnet)
    address public constant CHAINLINK_ETH_USD = 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419;
    
    /// @notice USDT address (Mainnet)
    address public constant USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
    
    /// @notice USDC address (Mainnet)
    address public constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
    
    /// @notice Initial arbiters (hardcoded)
    address public constant ARBITER_1 = 0xB1BB66C47DEE78b91E8AEEb6E74e66e02CA34567;
    address public constant ARBITER_2 = 0xBf3a2c7c9bC27e3143dF965fFa80E421f5445678;

    // ============ State Variables ============
    
    /// @notice Deal counter
    uint256 private _dealIdCounter;
    
    /// @notice Stablecoin configuration
    struct StablecoinInfo {
        bool isActive;      // Whether this stablecoin is supported
        uint8 decimals;     // Token decimals (6 for USDT/USDC, 18 for DAI)
    }
    
    /// @notice All deals
    mapping(uint256 => Deal) private _deals;
    
    /// @notice Dispute resolutions
    mapping(uint256 => DisputeResolution) private _resolutions;
    
    /// @notice Supported stablecoins registry (replaces tokenWhitelist for ERC20)
    /// @dev address(0) is reserved for ETH (not a stablecoin)
    mapping(address => StablecoinInfo) public stablecoins;
    
    /// @notice List of all registered stablecoin addresses
    address[] public stablecoinList;
    
    /// @notice Accumulated platform fees by token (treasury balance)
    /// @dev token => accumulated fee amount
    mapping(address => uint256) public accumulatedFees;
    
    // ============ Fee Management (Integrated) ============
    
    /// @notice Default platform fee in basis points (100 = 1%)
    uint16 public defaultPlatformFeeBps;
    
    /// @notice Default arbiter fee in basis points (100 = 1%)
    uint16 public defaultArbiterFeeBps;
    
    /// @notice Maximum fee in basis points (1000 = 10%)
    uint16 public constant MAX_FEE_BPS = 1000;
    
    /// @notice Tiered fee structure: amount threshold => fee in bps
    mapping(uint256 => uint16) public tieredPlatformFees;
    
    /// @notice Array of tier thresholds for iteration
    uint256[] public tierThresholds;
    
    // ============ Treasury (Integrated) ============
    
    /// @notice Withdrawal destination address
    address public withdrawalAddress;
    
    
    // ============ Arbitration (Integrated) ============
    
    /// @notice Arbiter information
    struct ArbiterInfo {
        bool isActive;
        uint256 totalCases;
        uint256 resolvedCases;
        uint256 reputation; // 0-100 score (not used currently)
        uint16 arbiterFeeBps; // Individual arbiter fee in basis points (can be adjusted by admin)
        uint64 registeredAt;
    }
    
    /// @notice Registered arbiters
    mapping(address => ArbiterInfo) public arbiters;
    
    /// @notice List of all arbiter addresses
    address[] public arbiterList;
    
    // ============ Price Oracle (Integrated - Chainlink) ============
    
    /// @notice Chainlink ETH/USD price feed interface
    AggregatorV3Interface public ethUsdPriceFeed;
    
    /// @notice Cached ETH price (8 decimals)
    uint256 public cachedEthPrice;
    
    /// @notice Price cache timestamp
    uint256 public priceCacheTime;
    
    /// @notice Price cache duration (10 minutes)
    uint256 public constant PRICE_CACHE_DURATION = 10 minutes;
    
    /// @notice Minimum deal amount in USD (8 decimals: 2000_0000_0000 = $20.00)
    uint256 public constant MIN_DEAL_AMOUNT_USD = 20_0000_0000; // $20.00
    
    /// @notice Minimum platform fee in USD (8 decimals: 1000_0000_0000 = $10.00)
    uint256 public constant MIN_FEE_USD = 10_0000_0000; // $10.00
    
    /// @notice Minimum arbiter fee in USD (8 decimals: 5_0000_0000 = $5.00)
    uint256 public constant MIN_ARBITER_FEE_USD = 5_0000_0000; // $5.00
    
    /// @notice Maximum dispute cooldown period (24 hours)
    /// @dev Actual cooldown is dynamic: min(24 hours, confirmWindow / 2)
    /// @dev This prevents buyers from being locked out of disputes in short-term deals
    uint64 public constant MAX_DISPUTE_COOLDOWN = 24 hours;
    
    /// @notice Platform brand message for event marketing
    /// @dev Displayed in blockchain explorers for brand exposure
    string public constant PLATFORM_MESSAGE = "ybz.io - Escrow Layer";
    
    // ============ Events ============
    
    // Core Events (from IYBZCore interface)
    
    // Fee Management Events
    event FeeWithdrawn(address indexed token, address indexed recipient, uint256 amount);
    
    // Arbitration Events (important business operations)
    event ArbiterRegistered(address indexed arbiter, uint64 timestamp);
    event ArbiterRemoved(address indexed arbiter);
    
    // ============ Errors ============
    
    error DisputeCooldownActive(uint64 remainingTime);
    error InvalidFee();
    error InvalidThreshold();
    error TierAlreadyExists();
    error TierNotFound();
    error ArbiterNotFound();
    error ArbiterAlreadyExists();
    error ArbiterInactive();
    error InsufficientBalance();
    error InvalidPrice();
    
    // ============ Constructor ============
    
    /**
     * @notice Constructs the unified escrow contract
     * @param admin Admin address
     * @param withdrawalAddr Initial withdrawal address for fees
     * @dev Everything else is auto-configured (Chainlink, stablecoins, arbiters)
     */
    constructor(
        address admin,
        address withdrawalAddr
    ) {
        require(admin != address(0), "Invalid admin");
        require(withdrawalAddr != address(0), "Invalid withdrawal address");
        
        // Grant roles
        _grantRole(DEFAULT_ADMIN_ROLE, admin);
        _grantRole(OPERATOR_ROLE, admin);
        
        // Initialize fee structure
        defaultPlatformFeeBps = 100;  // 1%
        defaultArbiterFeeBps = 100;   // 1%
        
        // Initialize treasury
        withdrawalAddress = withdrawalAddr;
        
        // Auto-configure Chainlink price feed and stablecoins for mainnet
        if (block.chainid == 1) {
            // Ethereum Mainnet - Auto-configure everything
            ethUsdPriceFeed = AggregatorV3Interface(CHAINLINK_ETH_USD);
            
            // Register hardcoded arbiters (mainnet only)
            _registerArbiterInternal(ARBITER_1);
            _registerArbiterInternal(ARBITER_2);
            
            // Auto-register USDT
            stablecoins[USDT] = StablecoinInfo({
                isActive: true,
                decimals: 6
            });
            stablecoinList.push(USDT);
            
            // Auto-register USDC
            stablecoins[USDC] = StablecoinInfo({
                isActive: true,
                decimals: 6
            });
            stablecoinList.push(USDC);
        }
        // For other networks (testnet/localhost), use setManualPrice() for testing
        
        _dealIdCounter = 1; // Start from 1
    }
    
    // ============ Deal Creation ============
    
    /**
     * @notice Creates a new ETH escrow deal
     * @param seller Seller address
     * @param termsHash IPFS hash of deal terms
     * @param acceptWindow Time window for seller to accept (seconds)
     * @param submitWindow Time window for seller to submit work (seconds)
     * @param confirmWindow Time window for buyer to confirm (seconds)
     * @param preferredArbiter Optional: pre-select arbiter (must be active, or address(0) for random)
     * @return dealId New deal identifier
     */
    function createDealETH(
        address seller,
        bytes32 termsHash,
        uint64 acceptWindow,
        uint64 submitWindow,
        uint64 confirmWindow,
        address preferredArbiter
    ) external payable override nonReentrant whenNotPaused returns (uint256 dealId) {
        // Validate inputs
        DealValidation.validateCreateDeal(
            seller,
            msg.value,
            termsHash,
            acceptWindow,
            submitWindow,
            confirmWindow
        );
        
        if (msg.sender == seller) revert DealValidation.InvalidAddress();
        
        // Create deal
        dealId = _createDeal(
            msg.sender,
            seller,
            address(0), // ETH
            msg.value,
            termsHash,
            acceptWindow,
            submitWindow,
            confirmWindow,
            preferredArbiter
        );
        
        // Get created deal data for event
        Deal storage newDeal = _deals[dealId];
        
        emit DealCreated(
            dealId, 
            msg.sender, 
            seller, 
            address(0), 
            msg.value,
            newDeal.creationPriceUSD,
            newDeal.platformFeeBps,
            newDeal.arbiterFeeBps,
            termsHash, 
            acceptWindow, 
            submitWindow, 
            confirmWindow, 
            preferredArbiter, 
            PLATFORM_MESSAGE
        );
    }
    
    /**
     * @notice Creates a new ERC20 escrow deal (USDT/USDC only)
     * @param seller Seller address
     * @param token Token address (must be USDT or USDC)
     * @param amount Token amount
     * @param termsHash IPFS hash of deal terms
     * @param acceptWindow Time window for seller to accept (seconds)
     * @param submitWindow Time window for seller to submit work (seconds)
     * @param confirmWindow Time window for buyer to confirm (seconds)
     * @param preferredArbiter Optional: pre-select arbiter (must be active, or address(0) for random)
     * @return dealId New deal identifier
     * @dev Only stablecoins (USDT/USDC) are supported for ERC20 deals
     */
    function createDealERC20(
        address seller,
        address token,
        uint256 amount,
        bytes32 termsHash,
        uint64 acceptWindow,
        uint64 submitWindow,
        uint64 confirmWindow,
        address preferredArbiter
    ) external override nonReentrant whenNotPaused returns (uint256 dealId) {
        // Validate token is a supported stablecoin
        if (token == address(0)) revert DealValidation.InvalidAddress();
        
        StablecoinInfo memory stablecoin = stablecoins[token];
        require(stablecoin.isActive, "Token is not a supported stablecoin");
        
        // ===== Early USD Amount Check for Stablecoins (Gas Optimization) =====
        // Stablecoins are 1:1 USD, convert to 8 decimals for comparison
        // Formula: amount * 10^(8 - tokenDecimals)
        // Example: 100 USDT (6 decimals) = 100000000 → 10000000000 (8 decimals) = $100
        
        uint256 dealAmountUSD;
        if (stablecoin.decimals <= 8) {
            dealAmountUSD = amount * (10 ** (8 - stablecoin.decimals));
        } else {
            dealAmountUSD = amount / (10 ** (stablecoin.decimals - 8));
        }
        
        // Check minimum deal amount ($20 USD)
        require(dealAmountUSD >= MIN_DEAL_AMOUNT_USD, "Deal amount below $20 minimum");
        
        // Minimum fee ($10) will be enforced in _releaseFunds:
        // - If amount * 2% < $10 → charge $10
        // - If amount * 2% >= $10 → charge 2%
        // This way $20-$500 orders are accepted but pay $10 minimum
        
        // ===== End Early Check =====
        if (seller == address(0)) revert DealValidation.InvalidAddress();
        if (termsHash == bytes32(0)) revert DealValidation.InvalidTermsHash();
        if (acceptWindow < DealValidation.MIN_ACCEPT_WINDOW || acceptWindow > DealValidation.MAX_ACCEPT_WINDOW) {
            revert DealValidation.InvalidTimeWindow();
        }
        if (submitWindow < DealValidation.MIN_SUBMIT_WINDOW || submitWindow > DealValidation.MAX_SUBMIT_WINDOW) {
            revert DealValidation.InvalidTimeWindow();
        }
        if (confirmWindow < DealValidation.MIN_CONFIRM_WINDOW || confirmWindow > DealValidation.MAX_CONFIRM_WINDOW) {
            revert DealValidation.InvalidTimeWindow();
        }
        
        if (msg.sender == seller) revert DealValidation.InvalidAddress();
        
        // Transfer tokens to contract
        IERC20(token).safeTransferFrom(msg.sender, address(this), amount);
        
        // Create deal
        dealId = _createDeal(
            msg.sender,
            seller,
            token,
            amount,
            termsHash,
            acceptWindow,
            submitWindow,
            confirmWindow,
            preferredArbiter
        );
        
        // Get created deal data for event
        Deal storage newDeal = _deals[dealId];
        
        emit DealCreated(
            dealId, 
            msg.sender, 
            seller, 
            token, 
            amount,
            newDeal.creationPriceUSD,
            newDeal.platformFeeBps,
            newDeal.arbiterFeeBps,
            termsHash, 
            acceptWindow, 
            submitWindow, 
            confirmWindow, 
            preferredArbiter, 
            PLATFORM_MESSAGE
        );
    }
    
    /**
     * @notice Internal deal creation logic
     */
    function _createDeal(
        address buyer,
        address seller,
        address token,
        uint256 amount,
        bytes32 termsHash,
        uint64 acceptWindow,
        uint64 submitWindow,
        uint64 confirmWindow,
        address preferredArbiter
    ) internal returns (uint256 dealId) {
        dealId = _dealIdCounter++;
        
        // ============ Arbiter Validation ============
        
        address assignedArbiter = address(0);
        
        // If user pre-selects an arbiter, validate it
        if (preferredArbiter != address(0)) {
            require(
                _isActiveArbiter(preferredArbiter),
                "Preferred arbiter is not active"
            );
            assignedArbiter = preferredArbiter;
        }
        // If address(0), arbiter will be randomly assigned during dispute
        
        // ============ USD Amount Validation ============
        
        uint256 creationPriceUSD = 0;
        
        // Check if token is a stablecoin (registered in our system)
        StablecoinInfo memory stablecoin = stablecoins[token];
        
        if (stablecoin.isActive) {
            // ===== Stablecoin (USDT/USDC/DAI): Simple validation =====
            // Already validated in createDealERC20 (early check)
            // Just confirm minimum deal amount using dynamic decimals
            
            uint256 dealAmountUSD;
            if (stablecoin.decimals <= 8) {
                dealAmountUSD = amount * (10 ** (8 - stablecoin.decimals));
            } else {
                dealAmountUSD = amount / (10 ** (stablecoin.decimals - 8));
            }
            require(dealAmountUSD >= MIN_DEAL_AMOUNT_USD, "Deal amount below $20 minimum");
            
            // Fee will be enforced in _releaseFunds: max(amount * 2%, $10)
            // No rejection here - always accept if >= $20
            
            // creationPriceUSD = 0 for stablecoins
            
        } else {
            // ===== ETH: Query price ONCE and save (with 10-min cache) =====
            // Get ETH price and update cache if needed
            // If cache valid (<10 min): returns cached price (cheap)
            // If cache expired: queries Chainlink and updates cache (expensive, but helps next user)
            creationPriceUSD = _getEthPriceUSD();
            require(creationPriceUSD > 0, "Invalid price");
            
            // Calculate USD values using this single price query
            uint256 dealAmountUSD = (amount * creationPriceUSD) / 1e18;
            
            // Check minimum deal amount ($20 USD)
            require(dealAmountUSD >= MIN_DEAL_AMOUNT_USD, "Deal amount below $20 minimum");
            
        }
        
        // ============ End USD Validation ============
        
        // Get fee rates
        uint16 platformFeeBps = _getPlatformFeeBps(amount);
        
        // Get arbiter fee rate: use assigned arbiter's rate if pre-selected, otherwise default
        uint16 arbiterFeeBps;
        if (assignedArbiter != address(0)) {
            arbiterFeeBps = arbiters[assignedArbiter].arbiterFeeBps;
        } else {
            arbiterFeeBps = defaultArbiterFeeBps;
        }
        
        // Calculate deadlines
        uint64 now64 = uint64(block.timestamp);
        uint64 acceptDeadline = now64 + acceptWindow;
        uint64 submitDeadline = acceptDeadline + submitWindow;
        uint64 confirmDeadline = submitDeadline + confirmWindow;
        
        _deals[dealId] = Deal({
            buyer: buyer,
            seller: seller,
            token: token,
            amount: amount,
            creationPriceUSD: creationPriceUSD,
            platformFeeBps: platformFeeBps,
            arbiterFeeBps: arbiterFeeBps,
            termsHash: termsHash,
            deliveryHash: bytes32(0),
            acceptDeadline: acceptDeadline,
            submitDeadline: submitDeadline,
            confirmDeadline: confirmDeadline,
            acceptWindow: acceptWindow,
            submitWindow: submitWindow,
            confirmWindow: confirmWindow,
            createdAt: now64,
            submittedAt: 0,
            arbiter: assignedArbiter,
            status: DealStatus.Created,
            refundRequested: false,
            // Deadline proposal fields
            proposedSubmitWindow: 0,
            proposedConfirmWindow: 0,
            proposedBy: address(0),
            proposalAccepted: false
        });
    }
    
    // ============ Deal Workflow ============
    
    /**
     * @notice Seller accepts the deal
     * @param dealId Deal identifier
     */
    function acceptDeal(uint256 dealId) external override nonReentrant whenNotPaused {
        Deal storage deal = _deals[dealId];
        
        // Validations
        DealValidation.requireStatus(deal.status, DealStatus.Created);
        DealValidation.requireAuthorized(deal, msg.sender, false);
        DealValidation.requireDeadlineNotPassed(deal.acceptDeadline);
        
        // Update status
        deal.status = DealStatus.Accepted;
        
        emit DealAccepted(dealId, msg.sender, deal.submitDeadline);
    }
    
    /**
     * @notice Seller rejects the deal
     * @param dealId Deal identifier
     * @dev Only seller can reject, must be in Created status, refunds buyer
     */
    function rejectDeal(uint256 dealId) external override nonReentrant whenNotPaused {
        Deal storage deal = _deals[dealId];
        
        // Validations
        DealValidation.requireStatus(deal.status, DealStatus.Created);
        DealValidation.requireAuthorized(deal, msg.sender, false);
        
        // Update status
        deal.status = DealStatus.Cancelled;
        
        // Refund buyer (full amount, no fees)
        _transferFunds(deal.token, deal.buyer, deal.amount);
        
        emit DealRejected(dealId, msg.sender);
        
        // Clean up storage
        _closeDeal(dealId);
    }
    
    /**
     * @notice Seller submits work
     * @param dealId Deal identifier
     * @param deliveryHash IPFS hash of delivery proof
     */
    function submitWork(uint256 dealId, bytes32 deliveryHash) 
        external 
        override 
        nonReentrant 
        whenNotPaused 
    {
        Deal storage deal = _deals[dealId];
        
        // Validations
        DealValidation.requireStatus(deal.status, DealStatus.Accepted);
        DealValidation.requireAuthorized(deal, msg.sender, false);
        DealValidation.requireDeadlineNotPassed(deal.submitDeadline);
        
        if (deliveryHash == bytes32(0)) revert DealValidation.InvalidTermsHash();
        
        // Update deal
        deal.deliveryHash = deliveryHash;
        deal.submittedAt = uint64(block.timestamp);
        deal.status = DealStatus.Submitted;
        
        // Recalculate confirmDeadline based on actual submission time
        // This gives buyer full confirmWindow starting from NOW
        deal.confirmDeadline = uint64(block.timestamp) + deal.confirmWindow;
        
        emit WorkSubmitted(dealId, deliveryHash, deal.confirmDeadline);
    }
    
    /**
     * @notice Buyer approves and releases payment
     * @param dealId Deal identifier
     */
    function approveDeal(uint256 dealId) external override nonReentrant whenNotPaused {
        Deal storage deal = _deals[dealId];
        
        // Validations
        DealValidation.requireStatus(deal.status, DealStatus.Submitted);
        DealValidation.requireAuthorized(deal, msg.sender, true);
        DealValidation.requireDeadlineNotPassed(deal.confirmDeadline);
        
        // Mark as approved
        deal.status = DealStatus.Approved;
        
        // Release funds
        _releaseFunds(dealId, deal.seller, 100, 0);
        
        emit DealApproved(dealId, deal.seller, deal.amount);
        
        // Clean up storage
        _closeDeal(dealId);
    }
    
    /**
     * @notice Raises a dispute
     * @param dealId Deal identifier
     * @param evidenceHash IPFS hash of evidence
     * @dev Requires 24-hour cooldown after work submission to prevent malicious disputes
     */
    function raiseDispute(uint256 dealId, bytes32 evidenceHash) 
        external 
        override 
        nonReentrant 
        whenNotPaused 
    {
        Deal storage deal = _deals[dealId];
        
        // Can dispute in Accepted or Submitted states
        if (deal.status != DealStatus.Accepted && deal.status != DealStatus.Submitted) {
            revert DealValidation.InvalidStatus(deal.status, DealStatus.Submitted);
        }
        
        // Only buyer or seller can raise dispute
        if (msg.sender != deal.buyer && msg.sender != deal.seller) {
            revert DealValidation.Unauthorized();
        }
        
        // Enforce dynamic cooldown period after work submission
        if (deal.status == DealStatus.Submitted && deal.submittedAt > 0) {
            // Calculate cooldown based on total confirm time (fixed at submission)
            // cooldown = min(24h, confirmWindow / 2)
            uint64 totalConfirmTime = deal.confirmDeadline - deal.submittedAt;
            uint64 cooldownPeriod = totalConfirmTime < (MAX_DISPUTE_COOLDOWN * 2) 
                ? totalConfirmTime / 2 
                : MAX_DISPUTE_COOLDOWN;
            
            uint64 timeSinceSubmission = uint64(block.timestamp) - deal.submittedAt;
            if (timeSinceSubmission < cooldownPeriod) {
                uint64 remainingTime = cooldownPeriod - timeSinceSubmission;
                revert DisputeCooldownActive(remainingTime);
            }
        }
        
        // Clear any pending deadline proposal when dispute is raised
        if (deal.proposedBy != address(0)) {
            deal.proposedBy = address(0);
            deal.proposedSubmitWindow = 0;
            deal.proposedConfirmWindow = 0;
            deal.proposalAccepted = false;
        }
        
        // Select arbiter: use preferred arbiter if set, otherwise random
        address arbiter;
        if (deal.arbiter != address(0)) {
            // User pre-selected arbiter during deal creation
            arbiter = deal.arbiter;
            // Verify arbiter is still active
            require(_isActiveArbiter(arbiter), "Pre-selected arbiter is no longer active");
        } else {
            // No preferred arbiter, select randomly
            arbiter = _selectRandomArbiter();
            deal.arbiter = arbiter;
            // Update arbiter fee to match selected arbiter's rate
            deal.arbiterFeeBps = arbiters[arbiter].arbiterFeeBps;
        }
        
        deal.status = DealStatus.Disputed;
        
        // Register dispute (update arbiter stats)
        _registerDispute(dealId, msg.sender, arbiter);
        
        emit DisputeRaised(dealId, msg.sender, evidenceHash);
    }
    
    /**
     * @notice Resolves a dispute (arbiter only)
     * @param dealId Deal identifier
     * @param buyerRatio Buyer's share (0-100)
     * @param sellerRatio Seller's share (0-100)
     * @param evidenceHash Resolution evidence hash
     */
    function resolveDispute(
        uint256 dealId,
        uint8 buyerRatio,
        uint8 sellerRatio,
        bytes32 evidenceHash
    ) external override nonReentrant whenNotPaused {
        Deal storage deal = _deals[dealId];
        
        // Validations
        DealValidation.requireStatus(deal.status, DealStatus.Disputed);
        DealValidation.validateResolutionRatio(buyerRatio, sellerRatio);
        
        // Check if sender is authorized to resolve dispute
        bool isAssignedArbiter = (msg.sender == deal.arbiter);
        bool isOperator = hasRole(OPERATOR_ROLE, msg.sender);
        
        if (!isAssignedArbiter && !isOperator) {
            revert DealValidation.Unauthorized();
        }
        
        // If arbiter is resolving, verify they are still active
        // This prevents deactivated arbiters from resolving disputes
        // Operators can always resolve (emergency override)
        if (isAssignedArbiter && !isOperator) {
            require(
                _isActiveArbiter(msg.sender),
                "Arbiter has been deactivated"
            );
        }
        
        // Mark as resolved
        deal.status = DealStatus.Resolved;
        
        // Record resolution
        _resolutions[dealId] = DisputeResolution({
            arbiter: msg.sender,
            buyerRatio: buyerRatio,
            sellerRatio: sellerRatio,
            evidenceHash: evidenceHash,
            resolvedAt: uint64(block.timestamp),
            arbiterFee: (deal.amount * deal.arbiterFeeBps) / 10000
        });
        
        // Release funds according to ratio
        _releaseFunds(dealId, address(0), buyerRatio, sellerRatio);
        
        // Update arbiter statistics
        _resolveDisputeRecord(msg.sender);
        
        emit DisputeResolved(dealId, msg.sender, buyerRatio, sellerRatio, evidenceHash);
        
        // Clean up
        _closeDeal(dealId);
    }
    
    /**
     * @notice Auto-cancel if seller doesn't accept in time
     * @param dealId Deal identifier
     * @dev Anyone can trigger after acceptDeadline
     */
    function autoCancel(uint256 dealId) external override nonReentrant whenNotPaused {
        Deal storage deal = _deals[dealId];
        
        // Must be in Created status
        DealValidation.requireStatus(deal.status, DealStatus.Created);
        
        // Accept deadline must have passed
        DealValidation.requireDeadlinePassed(deal.acceptDeadline);
        
        // Update status
        deal.status = DealStatus.Cancelled;
        
        // Refund buyer (full amount, no fees)
        _transferFunds(deal.token, deal.buyer, deal.amount);
        
        emit DealFinalized(
            dealId, 
            deal.buyer, 
            msg.sender, 
            deal.amount, 
            DealStatus.Cancelled,
            PLATFORM_MESSAGE,
            "Accept timeout - seller did not respond"
        );
        
        // Clean up storage
        _closeDeal(dealId);
    }
    
    /**
     * @notice Cancel deal if seller accepted but didn't submit work
     * @param dealId Deal identifier
     * @dev Only buyer can trigger after submitDeadline
     */
    function cancelDeal(uint256 dealId) external override nonReentrant whenNotPaused {
        Deal storage deal = _deals[dealId];
        
        // Must be in Accepted status
        DealValidation.requireStatus(deal.status, DealStatus.Accepted);
        
        // Only buyer can cancel
        DealValidation.requireAuthorized(deal, msg.sender, true);
        
        // Submit deadline must have passed
        DealValidation.requireDeadlinePassed(deal.submitDeadline);
        
        deal.status = DealStatus.Cancelled;
        
        // Refund buyer
        _transferFunds(deal.token, deal.buyer, deal.amount);
        
        emit DealFinalized(
            dealId, 
            deal.buyer, 
            msg.sender, 
            deal.amount, 
            DealStatus.Cancelled,
            PLATFORM_MESSAGE,
            "Submit timeout - seller did not deliver"
        );
        
        _closeDeal(dealId);
    }
    
    /**
     * @notice Auto-refund (buyer can trigger after submit deadline)
     * @param dealId Deal identifier
     * @dev Removed whenNotPaused to allow fund release during pause
     */
    function autoRefund(uint256 dealId) external override nonReentrant {
        Deal storage deal = _deals[dealId];
        
        DealValidation.requireStatus(deal.status, DealStatus.Accepted);
        DealValidation.requireAuthorized(deal, msg.sender, true);
        DealValidation.requireDeadlinePassed(deal.submitDeadline);
        
        deal.status = DealStatus.Cancelled;
        
        // Refund buyer
        _transferFunds(deal.token, deal.buyer, deal.amount);
        
        emit DealFinalized(
            dealId, 
            deal.buyer, 
            msg.sender, 
            deal.amount, 
            DealStatus.Cancelled,
            PLATFORM_MESSAGE,
            "Auto-refund - submit timeout"
        );
        
        _closeDeal(dealId);
    }
    
    /**
     * @notice Buyer requests mutual refund (e.g., seller can't fulfill)
     * @param dealId Deal identifier
     * @dev Seller can approve with approveRefund()
     */
    function requestRefund(uint256 dealId) external override nonReentrant whenNotPaused {
        Deal storage deal = _deals[dealId];
        
        // Can request refund in Accepted or Submitted states
        if (deal.status != DealStatus.Accepted && deal.status != DealStatus.Submitted) {
            revert DealValidation.InvalidStatus(deal.status, DealStatus.Accepted);
        }
        
        // Only buyer can request refund
        DealValidation.requireAuthorized(deal, msg.sender, true);
        
        // Mark as refund requested
        deal.refundRequested = true;
        
        emit RefundRequested(dealId, msg.sender);
    }
    
    /**
     * @notice Seller approves buyer's refund request
     * @param dealId Deal identifier
     * @dev Triggers full refund to buyer (no fees)
     */
    function approveRefund(uint256 dealId) external override nonReentrant whenNotPaused {
        Deal storage deal = _deals[dealId];
        
        // Must have refund request pending
        require(deal.refundRequested, "No refund request");
        
        // Can approve refund in Accepted or Submitted states
        if (deal.status != DealStatus.Accepted && deal.status != DealStatus.Submitted) {
            revert DealValidation.InvalidStatus(deal.status, DealStatus.Accepted);
        }
        
        // Only seller can approve
        DealValidation.requireAuthorized(deal, msg.sender, false);
        
        // Update status
        deal.status = DealStatus.Cancelled;
        
        // Full refund to buyer (no fees - mutual agreement)
        _transferFunds(deal.token, deal.buyer, deal.amount);
        
        emit DealFinalized(
            dealId, 
            deal.buyer, 
            msg.sender, 
            deal.amount, 
            DealStatus.Cancelled,
            PLATFORM_MESSAGE,
            "Mutual agreement - seller approved refund"
        );
        
        _closeDeal(dealId);
    }
    
    /**
     * @notice Emergency fund release during contract pause
     * @param dealId Deal identifier
     * @dev Only admin can trigger, refunds to buyer as safest option
     */
    function emergencyRelease(uint256 dealId) 
        external 
        override
        nonReentrant 
        whenPaused 
        onlyRole(DEFAULT_ADMIN_ROLE) 
    {
        Deal storage deal = _deals[dealId];
        
        // Can only release if not already finalized
        require(
            deal.status != DealStatus.Closed && 
            deal.status != DealStatus.Approved,
            "Already finalized"
        );
        
        deal.status = DealStatus.Cancelled;
        
        // Emergency refund to buyer (safest option during emergency)
        _transferFunds(deal.token, deal.buyer, deal.amount);
        
        emit DealFinalized(
            dealId, 
            deal.buyer, 
            msg.sender, 
            deal.amount, 
            DealStatus.Cancelled,
            PLATFORM_MESSAGE,
            "Emergency release during pause"
        );
        
        _closeDeal(dealId);
    }
    
    /**
     * @notice Auto-release (anyone can trigger after confirm deadline)
     * @param dealId Deal identifier
     * @dev Removed whenNotPaused to allow fund release during pause
     */
    function autoRelease(uint256 dealId) external override nonReentrant {
        Deal storage deal = _deals[dealId];
        
        if (!DealValidation.canAutoRelease(deal)) {
            revert DealValidation.DeadlineNotReached();
        }
        
        deal.status = DealStatus.Approved;
        
        // Release to seller
        _releaseFunds(dealId, deal.seller, 100, 0);
        
        emit DealFinalized(
            dealId,
            deal.seller,
            msg.sender,
            deal.amount,
            DealStatus.Closed,
            PLATFORM_MESSAGE,
            "Auto-release - buyer did not respond in time"
        );
        
        _closeDeal(dealId);
    }
    
    // ============ Deadline Management ============
    
    /**
     * @notice Propose new deadline windows for a deal
     * @param dealId Deal identifier
     * @param newSubmitWindow New submit window in seconds
     * @param newConfirmWindow New confirm window in seconds
     * @dev Only buyer or seller can propose, must be in valid status
     */
    function proposeNewDeadline(
        uint256 dealId,
        uint64 newSubmitWindow,
        uint64 newConfirmWindow
    ) external override nonReentrant {
        Deal storage deal = _deals[dealId];
        
        // Validate deal exists
        require(deal.buyer != address(0), "Deal does not exist");
        
        // Only buyer or seller can propose
        require(
            msg.sender == deal.buyer || msg.sender == deal.seller,
            "Not authorized"
        );
        
        // Can only propose in active states
        require(
            deal.status == DealStatus.Accepted || 
            deal.status == DealStatus.Submitted,
            "Invalid status for deadline proposal"
        );
        
        // Validate new windows
        require(
            newSubmitWindow >= DealValidation.MIN_SUBMIT_WINDOW && 
            newSubmitWindow <= DealValidation.MAX_SUBMIT_WINDOW,
            "Invalid submit window"
        );
        require(
            newConfirmWindow >= DealValidation.MIN_CONFIRM_WINDOW && 
            newConfirmWindow <= DealValidation.MAX_CONFIRM_WINDOW,
            "Invalid confirm window"
        );
        
        // Cannot propose if already has pending proposal
        require(deal.proposedBy == address(0), "Proposal already pending");
        
        // Store proposal
        deal.proposedSubmitWindow = newSubmitWindow;
        deal.proposedConfirmWindow = newConfirmWindow;
        deal.proposedBy = msg.sender;
        deal.proposalAccepted = false;
        
        emit DeadlineProposed(dealId, msg.sender, newSubmitWindow, newConfirmWindow);
    }
    
    /**
     * @notice Accept deadline proposal from the other party
     * @param dealId Deal identifier
     * @dev Only the non-proposer can accept
     */
    function acceptDeadlineProposal(uint256 dealId) external override nonReentrant {
        Deal storage deal = _deals[dealId];
        
        // Validate deal exists
        require(deal.buyer != address(0), "Deal does not exist");
        
        // Must have pending proposal
        require(deal.proposedBy != address(0), "No proposal pending");
        
        // Cannot self-approve
        require(msg.sender != deal.proposedBy, "Cannot self-approve");
        
        // Must be the other party
        require(
            msg.sender == deal.buyer || msg.sender == deal.seller,
            "Not authorized"
        );
        
        // Update windows
        deal.submitWindow = deal.proposedSubmitWindow;
        deal.confirmWindow = deal.proposedConfirmWindow;
        
        // Recalculate deadlines if deal is in Submitted status
        if (deal.status == DealStatus.Submitted) {
            deal.confirmDeadline = uint64(block.timestamp) + deal.confirmWindow;
        }
        
        // Clear proposal
        deal.proposedBy = address(0);
        deal.proposedSubmitWindow = 0;
        deal.proposedConfirmWindow = 0;
        deal.proposalAccepted = true;
        
        emit DeadlineUpdated(dealId, deal.submitWindow, deal.confirmWindow, msg.sender);
    }
    
    /**
     * @notice Releases funds with fee distribution
     * @param dealId Deal identifier
     * @param primaryRecipient Primary recipient (if ratio is 100/0)
     * @param buyerRatio Buyer's share (0-100)
     * @param sellerRatio Seller's share (0-100)
     */
    function _releaseFunds(
        uint256 dealId,
        address primaryRecipient,
        uint8 buyerRatio,
        uint8 sellerRatio
    ) internal {
        Deal storage deal = _deals[dealId];
        
        // Calculate platform fee (percentage)
        uint256 platformFee = _calculatePlatformFee(deal.amount);
        
        // Enforce minimum fee ($10 USD)
        if (deal.creationPriceUSD > 0) {
            // ===== ETH: Use creation time price =====
            // Calculate fee USD value using CREATION time price
            uint256 feeUSD = (platformFee * deal.creationPriceUSD) / 1e18;
            
            // If fee < $10, adjust to minimum
            if (feeUSD < MIN_FEE_USD) {
                // Calculate minimum fee in ETH: ($10 * 1e18) / price
                platformFee = (MIN_FEE_USD * 1e18) / deal.creationPriceUSD;
            }
            
        } else {
            // ===== Stablecoin: 1:1 USD =====
            // Get stablecoin decimals for dynamic conversion
            StablecoinInfo memory stablecoin = stablecoins[deal.token];
            
            // Convert fee to USD (token decimals → 8 decimals)
            uint256 feeUSD;
            if (stablecoin.decimals <= 8) {
                feeUSD = platformFee * (10 ** (8 - stablecoin.decimals));
            } else {
                feeUSD = platformFee / (10 ** (stablecoin.decimals - 8));
            }
            
            // If fee < $10, adjust to minimum
            if (feeUSD < MIN_FEE_USD) {
                // Convert $10 (8 decimals) to token decimals
                if (stablecoin.decimals <= 8) {
                    platformFee = MIN_FEE_USD / (10 ** (8 - stablecoin.decimals));
                } else {
                    platformFee = MIN_FEE_USD * (10 ** (stablecoin.decimals - 8));
                }
            }
        }
        
        uint256 arbiterFee = 0;
        
        // Charge arbiter fee only if disputed
        if (deal.status == DealStatus.Resolved) {
            // Use the arbiter's individual fee rate stored in the deal
            arbiterFee = (deal.amount * deal.arbiterFeeBps) / 10000;
            
            // Enforce minimum arbiter fee ($5 USD)
            if (deal.creationPriceUSD > 0) {
                // ===== ETH: Use creation time price =====
                // Calculate arbiter fee USD value using CREATION time price
                uint256 arbiterFeeUSD = (arbiterFee * deal.creationPriceUSD) / 1e18;
                
                // If fee < $5, adjust to minimum
                if (arbiterFeeUSD < MIN_ARBITER_FEE_USD) {
                    // Calculate minimum fee in ETH: ($5 * 1e18) / price
                    arbiterFee = (MIN_ARBITER_FEE_USD * 1e18) / deal.creationPriceUSD;
                }
                
            } else {
                // ===== Stablecoin: 1:1 USD =====
                // Get stablecoin decimals for dynamic conversion
                StablecoinInfo memory stablecoin = stablecoins[deal.token];
                
                // Convert arbiter fee to USD (token decimals → 8 decimals)
                uint256 arbiterFeeUSD;
                if (stablecoin.decimals <= 8) {
                    arbiterFeeUSD = arbiterFee * (10 ** (8 - stablecoin.decimals));
                } else {
                    arbiterFeeUSD = arbiterFee / (10 ** (stablecoin.decimals - 8));
                }
                
                // If fee < $5, adjust to minimum
                if (arbiterFeeUSD < MIN_ARBITER_FEE_USD) {
                    // Convert $5 (8 decimals) to token decimals
                    if (stablecoin.decimals <= 8) {
                        arbiterFee = MIN_ARBITER_FEE_USD / (10 ** (8 - stablecoin.decimals));
                    } else {
                        arbiterFee = MIN_ARBITER_FEE_USD * (10 ** (stablecoin.decimals - 8));
                    }
                }
            }
        }
        
        uint256 netAmount = deal.amount - platformFee - arbiterFee;
        
        // Accumulate platform fee in contract (gas optimization)
        accumulatedFees[deal.token] += platformFee;
        
        // Send arbiter fee if applicable
        if (arbiterFee > 0 && deal.arbiter != address(0)) {
            _transferFunds(deal.token, deal.arbiter, arbiterFee);
        }
        
        // Distribute net amount
        if (buyerRatio == 100) {
            // Full refund to buyer or single recipient
            address recipient = primaryRecipient != address(0) ? primaryRecipient : deal.buyer;
            _transferFunds(deal.token, recipient, netAmount);
        } else if (sellerRatio == 100) {
            // Full payment to seller
            _transferFunds(deal.token, deal.seller, netAmount);
        } else {
            // Split according to ratio
            uint256 buyerAmount = (netAmount * buyerRatio) / 100;
            uint256 sellerAmount = netAmount - buyerAmount;
            
            if (buyerAmount > 0) {
                _transferFunds(deal.token, deal.buyer, buyerAmount);
            }
            
            if (sellerAmount > 0) {
                _transferFunds(deal.token, deal.seller, sellerAmount);
            }
        }
    }
    
    /**
     * @notice Transfers funds (ETH or ERC20)
     * @param token Token address (address(0) for ETH)
     * @param to Recipient address
     * @param amount Amount to transfer
     */
    function _transferFunds(address token, address to, uint256 amount) internal {
        if (amount == 0) return;
        
        if (token == address(0)) {
            // Transfer ETH
            (bool success, ) = to.call{value: amount}("");
            require(success, "ETH transfer failed");
        } else {
            // Transfer ERC20
            IERC20(token).safeTransfer(to, amount);
        }
    }
    
    /**
     * @notice Closes a deal and releases storage
     * @param dealId Deal identifier
     * @dev Deletes storage to get gas refund and prevent state bloat
     * @dev All events are preserved on-chain for audit trail
     */
    function _closeDeal(uint256 dealId) internal {        
        // Release storage to get gas refund (~15,000 gas)
        delete _deals[dealId];
        delete _resolutions[dealId];
        
        // Note: Events are preserved on-chain for historical audit
        // Storage cleanup doesn't affect event-based data retrieval
    }
    
    // ============ Admin Functions ============
    
    /**
     * @notice Adds a stablecoin to the supported list
     * @param token Stablecoin address (USDT, USDC, DAI, etc.)
     * @param decimals Token decimals (6 for USDT/USDC, 18 for DAI)
     * @dev Only admin can add stablecoins. Each stablecoin is assumed to be 1:1 USD pegged
     */
    function addStablecoin(address token, uint8 decimals) external onlyRole(DEFAULT_ADMIN_ROLE) {
        require(token != address(0), "Invalid token address");
        require(decimals > 0 && decimals <= 18, "Invalid decimals");
        require(!stablecoins[token].isActive, "Stablecoin already exists");
        
        stablecoins[token] = StablecoinInfo({
            isActive: true,
            decimals: decimals
        });
        
        stablecoinList.push(token);
    }
    
    /**
     * @notice Removes a stablecoin from the supported list
     * @param token Stablecoin address to remove
     * @dev Only admin can remove. This will prevent new deals but won't affect existing ones
     */
    function removeStablecoin(address token) external onlyRole(DEFAULT_ADMIN_ROLE) {
        require(stablecoins[token].isActive, "Stablecoin not found");
        
        stablecoins[token].isActive = false;
        
        // Remove from array
        for (uint256 i = 0; i < stablecoinList.length; i++) {
            if (stablecoinList[i] == token) {
                stablecoinList[i] = stablecoinList[stablecoinList.length - 1];
                stablecoinList.pop();
                break;
            }
        }
    }
    
    /**
     * @notice Updates a stablecoin's decimals (in case of error correction)
     * @param token Stablecoin address
     * @param decimals New decimals value
     */
    function updateStablecoinDecimals(address token, uint8 decimals) external onlyRole(DEFAULT_ADMIN_ROLE) {
        require(stablecoins[token].isActive, "Stablecoin not found");
        require(decimals > 0 && decimals <= 18, "Invalid decimals");
        
        stablecoins[token].decimals = decimals;
    }
    
    // ============ Fee Management (Admin) ============
    
    /**
     * @notice Update default platform fee rate
     */
    function updatePlatformFee(uint16 newFeeBps) external onlyRole(DEFAULT_ADMIN_ROLE) {
        if (newFeeBps > MAX_FEE_BPS) revert InvalidFee();
        defaultPlatformFeeBps = newFeeBps;
    }
    
    /**
     * @notice Update default arbiter fee rate
     * @dev This is the default rate for new arbiters and non-pre-selected arbiters
     */
    function updateDefaultArbiterFee(uint16 newFeeBps) external onlyRole(DEFAULT_ADMIN_ROLE) {
        if (newFeeBps > MAX_FEE_BPS) revert InvalidFee();
        defaultArbiterFeeBps = newFeeBps;
    }
    
    // ============ Arbitration Management (Admin) ============
    
    /**
     * @notice Register a new arbiter
     */
    function registerArbiter(address arbiter) external onlyRole(DEFAULT_ADMIN_ROLE) {
        _registerArbiterInternal(arbiter);
    }
    
    /**
     * @notice Deactivate an arbiter
     */
    function deactivateArbiter(address arbiter) external onlyRole(DEFAULT_ADMIN_ROLE) {
        if (arbiters[arbiter].registeredAt == 0) revert ArbiterNotFound();
        arbiters[arbiter].isActive = false;
        _revokeRole(ARBITER_ROLE, arbiter);
    }
    
    /**
     * @notice Activate an arbiter
     */
    function activateArbiter(address arbiter) external onlyRole(DEFAULT_ADMIN_ROLE) {
        if (arbiters[arbiter].registeredAt == 0) revert ArbiterNotFound();
        arbiters[arbiter].isActive = true;
        _grantRole(ARBITER_ROLE, arbiter);
    }
    
    /**
     * @notice Remove arbiter from registry
     */
    function removeArbiter(address arbiter) external onlyRole(DEFAULT_ADMIN_ROLE) {
        if (arbiters[arbiter].registeredAt == 0) revert ArbiterNotFound();
        require(
            arbiters[arbiter].totalCases == arbiters[arbiter].resolvedCases,
            "Arbiter has pending cases"
        );
        
        // Remove from array
        for (uint256 i = 0; i < arbiterList.length; i++) {
            if (arbiterList[i] == arbiter) {
                arbiterList[i] = arbiterList[arbiterList.length - 1];
                arbiterList.pop();
                break;
            }
        }
        
        _revokeRole(ARBITER_ROLE, arbiter);
        delete arbiters[arbiter];
        emit ArbiterRemoved(arbiter);
    }
    
    /**
     * @notice Update individual arbiter's fee rate
     * @param arbiter Arbiter address
     * @param feeBps New fee rate in basis points (e.g., 100 = 1%, 150 = 1.5%)
     * @dev Allows admin to incentivize good arbiters or penalize poor ones
     */
    function updateArbiterFee(address arbiter, uint16 feeBps) external onlyRole(DEFAULT_ADMIN_ROLE) {
        if (arbiters[arbiter].registeredAt == 0) revert ArbiterNotFound();
        if (feeBps > MAX_FEE_BPS) revert InvalidFee();
        
        arbiters[arbiter].arbiterFeeBps = feeBps;
    }
    
    /**
     * @notice Get all arbiters
     */
    function getAllArbiters() external view returns (address[] memory) {
        return arbiterList;
    }
    
    /**
     * @notice Check if a...

// [truncated — 61235 bytes total]

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "../interfaces/IYBZCore.sol";

/**
 * @title DealValidation
 * @notice Library for deal validation and state transition checks
 * @dev Gas-optimized validation logic extracted to library
 */
library DealValidation {
    
    /// @notice Minimum time windows (in seconds)
    /// @dev Flexible limits to accommodate various industries
    uint64 public constant MIN_ACCEPT_WINDOW = 1 hours;     // Min: 1 hour (quick response)
    uint64 public constant MIN_SUBMIT_WINDOW = 1 hours;     // Min: 1 hour (small tasks like translation)
    uint64 public constant MIN_CONFIRM_WINDOW = 1 hours;    // Min: 1 hour (quick verification)
    
    /// @notice Maximum time windows (in seconds)
    /// @dev Max limits prevent indefinite locks
    uint64 public constant MAX_ACCEPT_WINDOW = 30 days;     // Max: 30 days
    uint64 public constant MAX_SUBMIT_WINDOW = 180 days;    // Max: 6 months (supply chain, custom manufacturing)
    uint64 public constant MAX_CONFIRM_WINDOW = 30 days;    // Max: 30 days
    
    /// @notice Minimum deal amount (to prevent spam)
    uint256 public constant MIN_DEAL_AMOUNT = 0.001 ether;
    
    /// @notice Maximum fee in basis points (10%)
    uint16 public constant MAX_FEE_BPS = 1000;
    
    // ============ Errors ============
    
    error InvalidAmount();
    error InvalidAddress();
    error InvalidTimeWindow();
    error InvalidTermsHash();
    error InvalidStatus(IYBZCore.DealStatus current, IYBZCore.DealStatus required);
    error Unauthorized();
    error DeadlinePassed();
    error DeadlineNotReached();
    error InvalidRatio();
    
    // ============ Validation Functions ============
    
    /**
     * @notice Validates deal creation parameters
     * @param seller Seller address
     * @param amount Deal amount
     * @param termsHash Terms hash
     * @param acceptWindow Accept time window
     * @param submitWindow Submit time window
     * @param confirmWindow Confirm time window
     */
    function validateCreateDeal(
        address seller,
        uint256 amount,
        bytes32 termsHash,
        uint64 acceptWindow,
        uint64 submitWindow,
        uint64 confirmWindow
    ) internal pure {
        if (seller == address(0)) revert InvalidAddress();
        if (amount < MIN_DEAL_AMOUNT) revert InvalidAmount();
        if (termsHash == bytes32(0)) revert InvalidTermsHash();
        
        if (acceptWindow < MIN_ACCEPT_WINDOW || acceptWindow > MAX_ACCEPT_WINDOW) {
            revert InvalidTimeWindow();
        }
        if (submitWindow < MIN_SUBMIT_WINDOW || submitWindow > MAX_SUBMIT_WINDOW) {
            revert InvalidTimeWindow();
        }
        if (confirmWindow < MIN_CONFIRM_WINDOW || confirmWindow > MAX_CONFIRM_WINDOW) {
            revert InvalidTimeWindow();
        }
    }
    
    /**
     * @notice Validates state transition
     * @param currentStatus Current deal status
     * @param requiredStatus Required status for operation
     */
    function requireStatus(
        IYBZCore.DealStatus currentStatus,
        IYBZCore.DealStatus requiredStatus
    ) internal pure {
        if (currentStatus != requiredStatus) {
            revert InvalidStatus(currentStatus, requiredStatus);
        }
    }
    
    /**
     * @notice Checks if caller is authorized for the deal
     * @param deal Deal struct
     * @param caller Caller address
     * @param isBuyerRequired True if buyer authorization required
     */
    function requireAuthorized(
        IYBZCore.Deal memory deal,
        address caller,
        bool isBuyerRequired
    ) internal pure {
        address authorized = isBuyerRequired ? deal.buyer : deal.seller;
        if (caller != authorized) revert Unauthorized();
    }
    
    /**
     * @notice Checks if deadline has passed
     * @param deadline Deadline timestamp
     */
    function requireDeadlinePassed(uint64 deadline) internal view {
        if (block.timestamp <= deadline) revert DeadlineNotReached();
    }
    
    /**
     * @notice Checks if deadline has not passed
     * @param deadline Deadline timestamp
     */
    function requireDeadlineNotPassed(uint64 deadline) internal view {
        if (block.timestamp > deadline) revert DeadlinePassed();
    }
    
    /**
     * @notice Validates dispute resolution ratios
     * @param buyerRatio Buyer ratio (0-100)
     * @param sellerRatio Seller ratio (0-100)
     */
    function validateResolutionRatio(
        uint8 buyerRatio,
        uint8 sellerRatio
    ) internal pure {
        if (buyerRatio + sellerRatio != 100) revert InvalidRatio();
    }
    
    /**
     * @notice Checks if deal can be auto-cancelled (Created status only)
     * @param deal Deal struct
     * @dev Now only for Created status, Accepted uses cancelDeal()
     */
    function canAutoCancel(IYBZCore.Deal memory deal) internal view returns (bool) {
        // Can auto-cancel if Created and accept deadline passed
        return deal.status == IYBZCore.DealStatus.Created && 
               block.timestamp > deal.acceptDeadline;
    }
    
    /**
     * @notice Checks if deal can be auto-released
     * @param deal Deal struct
     */
    function canAutoRelease(IYBZCore.Deal memory deal) internal view returns (bool) {
        return deal.status == IYBZCore.DealStatus.Submitted && 
               block.timestamp > deal.confirmDeadline;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

/**
 * @title IYBZCore
 * @notice Interface for YBZ Escrow Core Contract
 * @dev Defines the core escrow functionality and data structures
 */
interface IYBZCore {
    
    /// @notice Deal lifecycle status
    enum DealStatus {
        Created,      // Deal created, waiting for seller acceptance
        Accepted,     // Seller accepted, waiting for work submission
        Submitted,    // Work submitted, waiting for buyer confirmation
        Disputed,     // Dispute raised, waiting for arbitration
        Approved,     // Deal approved, funds released
        Cancelled,    // Deal cancelled (timeout or manual cancellation)
        Resolved,     // Dispute resolved by arbitrator
        Closed        // Deal completed and storage cleaned
    }
    
    /// @notice Main deal structure
    struct Deal {
        address buyer;                  // Buyer address
        address seller;                 // Seller address
        address token;                  // Token address (address(0) for ETH)
        uint256 amount;                 // Total amount locked
        uint256 creationPriceUSD;       // Token price in USD at creation (8 decimals, for ETH only)
        uint16 platformFeeBps;          // Platform fee in basis points
        uint16 arbiterFeeBps;           // Arbiter fee in basis points (only charged if disputed)
        bytes32 termsHash;              // IPFS hash of deal terms
        bytes32 deliveryHash;           // IPFS hash of delivery proof
        uint64 acceptDeadline;          // Deadline for seller to accept
        uint64 submitDeadline;          // Deadline for seller to submit work
        uint64 confirmDeadline;         // Deadline for buyer to confirm (recalculated on submission)
        uint64 acceptWindow;            // Time window for accept (stored for reference)
        uint64 submitWindow;            // Time window for submit (stored for reference)
        uint64 confirmWindow;           // Time window for confirm (used to recalculate deadline)
        uint64 createdAt;               // Creation timestamp
        uint64 submittedAt;             // Work submission timestamp (0 if not submitted)
        address arbiter;                // Assigned arbiter address
        DealStatus status;              // Current deal status
        bool refundRequested;           // Buyer requested mutual refund
        // Deadline proposal fields
        uint64 proposedSubmitWindow;    // Proposed new submit window
        uint64 proposedConfirmWindow;   // Proposed new confirm window
        address proposedBy;             // Who proposed the change
        bool proposalAccepted;          // Whether proposal was accepted
    }
    
    /// @notice Dispute resolution data
    struct DisputeResolution {
        address arbiter;                // Arbiter who resolved the dispute
        uint8 buyerRatio;               // Percentage to buyer (0-100)
        uint8 sellerRatio;              // Percentage to seller (0-100)
        bytes32 evidenceHash;           // IPFS hash of arbitration evidence
        uint64 resolvedAt;              // Resolution timestamp
        uint256 arbiterFee;             // Fee paid to arbiter
    }
    
    // ============ Events ============
    
    event DealCreated(
        uint256 indexed dealId,
        address indexed buyer,
        address indexed seller,
        address token,
        uint256 amount,
        uint256 creationPriceUSD,
        uint16 platformFeeBps,
        uint16 arbiterFeeBps,
        bytes32 termsHash,
        uint64 acceptWindow,
        uint64 submitWindow,
        uint64 confirmWindow,
        address preferredArbiter,
        string platform
    );
    
    event DealAccepted(
        uint256 indexed dealId,
        address indexed seller,
        uint64 submitDeadline
    );
    
    event WorkSubmitted(
        uint256 indexed dealId,
        bytes32 deliveryHash,
        uint64 confirmDeadline
    );
    
    event DealApproved(
        uint256 indexed dealId,
        address indexed seller,
        uint256 amount
    );
    
    event DisputeRaised(
        uint256 indexed dealId,
        address indexed initiator,
        bytes32 evidenceHash
    );
    
    event DisputeResolved(
        uint256 indexed dealId,
        address indexed arbiter,
        uint8 buyerRatio,
        uint8 sellerRatio,
        bytes32 evidenceHash
    );
    
    event DealCancelled(
        uint256 indexed dealId,
        address indexed initiator,
        string reason
    );
    
    event DealFinalized(
        uint256 indexed dealId,
        address indexed recipient,
        address indexed initiator,
        uint256 amount,
        DealStatus finalStatus,
        string platform,
        string reason
    );
    
    event RefundRequested(
        uint256 indexed dealId,
        address indexed buyer
    );
    
    event DeadlineProposed(
        uint256 indexed dealId,
        address indexed proposer,
        uint64 newSubmitWindow,
        uint64 newConfirmWindow
    );
    
    event DeadlineUpdated(
        uint256 indexed dealId,
        uint64 submitWindow,
        uint64 confirmWindow,
        address indexed acceptedBy
    );
    
    event DealRejected(
        uint256 indexed dealId,
        address indexed seller
    );
    
    // ============ Core Functions ============
    
    function createDealETH(
        address seller,
        bytes32 termsHash,
        uint64 acceptWindow,
        uint64 submitWindow,
        uint64 confirmWindow,
        address preferredArbiter
    ) external payable returns (uint256 dealId);
    
    function createDealERC20(
        address seller,
        address token,
        uint256 amount,
        bytes32 termsHash,
        uint64 acceptWindow,
        uint64 submitWindow,
        uint64 confirmWindow,
        address preferredArbiter
    ) external returns (uint256 dealId);
    
    function acceptDeal(uint256 dealId) external;
    
    function rejectDeal(uint256 dealId) external;
    
    function submitWork(uint256 dealId, bytes32 deliveryHash) external;
    
    function approveDeal(uint256 dealId) external;
    
    function raiseDispute(uint256 dealId, bytes32 evidenceHash) external;
    
    function resolveDispute(
        uint256 dealId,
        uint8 buyerRatio,
        uint8 sellerRatio,
        bytes32 evidenceHash
    ) external;
    
    function autoCancel(uint256 dealId) external;
    
    function cancelDeal(uint256 dealId) external;
    
    function autoRefund(uint256 dealId) external;
    
    function requestRefund(uint256 dealId) external;
    
    function approveRefund(uint256 dealId) external;
    
    function autoRelease(uint256 dealId) external;
    
    function emergencyRelease(uint256 dealId) external;
    
    // ============ Deadline Management ============
    
    function proposeNewDeadline(
        uint256 dealId,
        uint64 newSubmitWindow,
        uint64 newConfirmWindow
    ) external;
    
    function acceptDeadlineProposal(uint256 dealId) external;
    
    // ============ View Functions ============
    
    function getDeal(uint256 dealId) external view returns (Deal memory);
    
    function getDisputeResolution(uint256 dealId) external view returns (DisputeResolution memory);
    
    function dealCount() external view returns (uint256);
    
    function isTokenWhitelisted(address token) external view returns (bool);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

// solhint-disable-next-line interface-starts-with-i
interface AggregatorV3Interface {
  function decimals() external view returns (uint8);

  function description() external view returns (string memory);

  function version() external view returns (uint256);

  function getRoundData(
    uint80 _roundId
  ) external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);

  function latestRoundData()
    external
    view
    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC1363} from "../../../interfaces/IERC1363.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC-20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    /**
     * @dev An operation with an ERC-20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.
     */
    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {
        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.
     */
    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {
        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     *
     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
     * only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
     * set here.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            safeTransfer(token, to, value);
        } else if (!token.transferAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferFromAndCallRelaxed(
        IERC1363 token,
        address from,
        address to,
        uint256 value,
        bytes memory data
    ) internal {
        if (to.code.length == 0) {
            safeTransferFrom(token, from, to, value);
        } else if (!token.transferFromAndCall(from, to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
     * once without retrying, and relies on the returned value to be true.
     *
     * Reverts if the returned value is other than `true`.
     */
    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            forceApprove(token, to, value);
        } else if (!token.approveAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            // bubble errors
            if iszero(success) {
                let ptr := mload(0x40)
                returndatacopy(ptr, 0, returndatasize())
                revert(ptr, returndatasize())
            }
            returnSize := returndatasize()
            returnValue := mload(0)
        }

        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        bool success;
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            returnSize := returndatasize()
            returnValue := mload(0)
        }
        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)

pragma solidity >=0.4.16;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.3.0) (utils/Pausable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    bool private _paused;

    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    /**
     * @dev The operation failed because the contract is paused.
     */
    error EnforcedPause();

    /**
     * @dev The operation failed because the contract is not paused.
     */
    error ExpectedPause();

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        if (paused()) {
            revert EnforcedPause();
        }
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        if (!paused()) {
            revert ExpectedPause();
        }
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,
 * consider using {ReentrancyGuardTransient} instead.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (access/AccessControl.sol)

pragma solidity ^0.8.20;

import {IAccessControl} from "./IAccessControl.sol";
import {Context} from "../utils/Context.sol";
import {IERC165, ERC165} from "../utils/introspection/ERC165.sol";

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```solidity
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```solidity
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}
 * to enforce additional security measures for this role.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address account => bool) hasRole;
        bytes32 adminRole;
    }

    mapping(bytes32 role => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with an {AccessControlUnauthorizedAccount} error including the required role.
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

    /// @inheritdoc IERC165
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual returns (bool) {
        return _roles[role].hasRole[account];
    }

    /**
     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`
     * is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`
     * is missing `role`.
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert AccessControlUnauthorizedAccount(account, role);
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleRevoked} event.
     */
    function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `callerConfirmation`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address callerConfirmation) public virtual {
        if (callerConfirmation != _msgSender()) {
            revert AccessControlBadConfirmation();
        }

        _revokeRole(role, callerConfirmation);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual returns (bool) {
        if (!hasRole(role, account)) {
            _roles[role].hasRole[account] = true;
            emit RoleGranted(role, account, _msgSender());
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Attempts to revoke `role` from `account` and returns a boolean indicating if `role` was revoked.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {
        if (hasRole(role, account)) {
            _roles[role].hasRole[account] = false;
            emit RoleRevoked(role, account, _msgSender());
            return true;
        } else {
            return false;
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)

pragma solidity >=0.6.2;

import {IERC20} from "./IERC20.sol";
import {IERC165} from "./IERC165.sol";

/**
 * @title IERC1363
 * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
 *
 * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
 * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
 */
interface IERC1363 is IERC20, IERC165 {
    /*
     * Note: the ERC-165 identifier for this interface is 0xb0202a11.
     * 0xb0202a11 ===
     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^
     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
     */

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @param data Additional data with no specified format, sent in call to `spender`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

import {IERC165} from "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /// @inheritdoc IERC165
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (access/IAccessControl.sol)

pragma solidity >=0.8.4;

/**
 * @dev External interface of AccessControl declared to support ERC-165 detection.
 */
interface IAccessControl {
    /**
     * @dev The `account` is missing a role.
     */
    error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);

    /**
     * @dev The caller of a function is not the expected one.
     *
     * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
     */
    error AccessControlBadConfirmation();

    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted to signal this.
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call. This account bears the admin role (for the granted role).
     * Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `callerConfirmation`.
     */
    function renounceRole(bytes32 role, address callerConfirmation) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)

pragma solidity >=0.4.16;

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)

pragma solidity >=0.4.16;

import {IERC165} from "../utils/introspection/IERC165.sol";

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)

pragma solidity >=0.4.16;

import {IERC20} from "../token/ERC20/IERC20.sol";