Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट · पाठ

पारदर्शी प्रॉक्सी पैटर्न और स्टोरेज लेआउट

Transparent Proxy पैटर्न, delegatecall द्वारा लॉजिक को स्टोरेज से अलग करने की प्रक्रिया और कॉन्ट्रैक्ट को सुरक्षित रूप से अपग्रेड करने के लिए आवश्यक स्टोरेज लेआउट नियम सीखें।

पाठ 4, कुल 4 में से13 चरण

पारदर्शी प्रॉक्सी पैटर्न और स्टोरेज लेआउट, CoddyKit पर Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

पुनरावलोकन: प्रॉक्सी क्यों

आपने UUPS और डायमंड मानक देखे हैं। दोनों एक मूलभूत विचार पर आधारित हैं: एक प्रॉक्सी स्टोरेज रखती है और कॉल को अलग तर्क (कार्यान्वयन) कॉन्ट्रैक्ट तक अग्रेषित करती है। अपग्रेड करने का अर्थ है प्रॉक्सी को नए तर्क की ओर इंगित करना।

delegatecall कैसे काम करता है

प्रॉक्सी के पीछे की मुख्य तकनीक delegatecall है। यह तर्क कॉन्ट्रैक्ट का कोड चलाती है, लेकिन प्रॉक्सी के स्टोरेज संदर्भ में, और प्रॉक्सी के msg.sender तथा बैलेंस का उपयोग करती है।

इसलिए स्टोरेज प्रॉक्सी में रहता है और व्यवहार कार्यान्वयन में।

न्यूनतम प्रॉक्सी फ़ॉलबैक

प्रॉक्सी अपनी fallback में असेंबली delegatecall का उपयोग करके हर अज्ञात कॉल को कार्यान्वयन तक अग्रेषित करती है।

fallback() external payable {
    address impl = _implementation();
    assembly {
        calldatacopy(0, 0, calldatasize())
        let ok := delegatecall(gas(), impl, 0, calldatasize(), 0, 0)
        returndatacopy(0, 0, returndatasize())
        switch ok
        case 0 { revert(0, returndatasize()) }
        default { return(0, returndatasize()) }
    }
}

फ़ंक्शन टकराव की समस्या

यदि प्रॉक्सी में स्वयं upgradeTo फ़ंक्शन हो और तर्क में भी उसी चयनकर्ता वाला फ़ंक्शन हो, तो कॉल अस्पष्ट हो जाती हैं। पारदर्शी प्रॉक्सी पैटर्न कॉल करने वाले के आधार पर मार्ग चुनकर इस समस्या को हल करता है।

प्रशासक बनाम उपयोगकर्ता मार्ग चयन

पारदर्शी प्रॉक्सी में प्रशासक पता प्रशासनिक फ़ंक्शन (जैसे अपग्रेड) को कॉल कर सकता है, लेकिन कार्यान्वयन तक नहीं पहुँच सकता। अन्य सभी कॉल हमेशा कार्यान्वयन तक अग्रेषित की जाती हैं। इससे टकराव समाप्त हो जाते हैं।

modifier ifAdmin() {
    if (msg.sender == _admin()) {
        _;
    } else {
        _fallback();
    }
}

स्टोरेज स्लॉट का टकराव

प्रॉक्सी और तर्क, दोनों एक ही स्टोरेज में लिखते हैं। यदि वे अलग-अलग वेरिएबल के लिए स्लॉट 0 का उपयोग करते, तो वे एक-दूसरे का डेटा बिगाड़ देते। टकराव से बचने के लिए प्रॉक्सी प्रशासक और कार्यान्वयन को निश्चित छद्म-यादृच्छिक स्लॉट (EIP-1967) में रखती हैं।

// EIP-1967 implementation slot
bytes32 internal constant _IMPL_SLOT =
    0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

कार्यान्वयन स्लॉट पढ़ना

प्रॉक्सी उस निश्चित स्लॉट को सीधे असेंबली से पढ़ती और लिखती है, इसलिए उसका तर्क वेरिएबल के साथ कभी टकराव नहीं होता।

function _implementation() internal view returns (address impl) {
    bytes32 slot = _IMPL_SLOT;
    assembly { impl := sload(slot) }
}

स्टोरेज लेआउट के नियम

तर्क को अपग्रेड करते समय आपको मौजूदा स्टोरेज वेरिएबल का क्रम और प्रकार बनाए रखना अनिवार्य है। नए वेरिएबल अंत में जोड़े जाते हैं।

मौजूदा वेरिएबल का क्रम कभी न बदलें
किसी वेरिएबल का प्रकार कभी न बदलें
पुराने वेरिएबल से पहले नया वेरिएबल कभी न डालें

स्टोरेज गैप

विरासत में लिए जा सकने वाले आधार कॉन्ट्रैक्ट भविष्य के वेरिएबल के लिए __gap ऐरे के माध्यम से स्थान आरक्षित रखते हैं, ताकि अपग्रेड के बाद आधार में फ़ील्ड जोड़ने पर चाइल्ड कॉन्ट्रैक्ट में टकराव न हो।

contract Base {
    uint256 public value;
    // reserve 50 slots for future use
    uint256[50] private __gap;
}

कंस्ट्रक्टर नहीं, आरंभकर्ता

कंस्ट्रक्टर केवल तर्क कॉन्ट्रैक्ट की अपनी तैनाती के समय चलते हैं, प्रॉक्सी के माध्यम से नहीं। अपग्रेड किए जा सकने वाले कॉन्ट्रैक्ट initialize फ़ंक्शन का उपयोग करते हैं, जिस पर ऐसी सुरक्षा होती है कि वह ठीक एक बार चले।

bool private _initialized;

function initialize(uint256 v) external {
    require(!_initialized, 'already init');
    _initialized = true;
    value = v;
}

पारदर्शी बनाम UUPS

पारदर्शी प्रॉक्सी में अपग्रेड तर्क प्रॉक्सी में ही रखा जाता है (तैनाती गैस अधिक, तर्क सरल)। UUPS में इसे कार्यान्वयन में रखा जाता है (प्रॉक्सी सस्ती, लेकिन हर संस्करण में अपग्रेड कोड शामिल करना अनिवार्य)। लागत और टीम के अनुशासन के आधार पर चुनाव करें।

त्वरित जाँच

प्रॉक्सी स्टोरेज की अपनी समझ जाँचें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन

आपने पारदर्शी प्रॉक्सी पैटर्न सीखा:

delegatecall प्रॉक्सी के स्टोरेज में तर्क चलाती है
प्रशासक और उपयोगकर्ता के आधार पर मार्ग चुनने से फ़ंक्शन टकराव से बचा जाता है
EIP-1967 के निश्चित स्लॉट और __gap ऐरे टकराव रोकते हैं
initialize का उपयोग करें, स्टोरेज लेआउट बनाए रखें और नए वेरिएबल अंत में जोड़ें

इन नियमों का पालन करने पर अपग्रेड सुरक्षित रहते हैं।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 12
पाठ: 48

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “पारदर्शी प्रॉक्सी पैटर्न और स्टोरेज लेआउट” पाठ निःशुल्क है?

हाँ—“पारदर्शी प्रॉक्सी पैटर्न और स्टोरेज लेआउट” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“पारदर्शी प्रॉक्सी पैटर्न और स्टोरेज लेआउट” में मैं क्या सीखूँगा?

Transparent Proxy पैटर्न, delegatecall द्वारा लॉजिक को स्टोरेज से अलग करने की प्रक्रिया और कॉन्ट्रैक्ट को सुरक्षित रूप से अपग्रेड करने के लिए आवश्यक स्टोरेज लेआउट नियम सीखें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।

“पारदर्शी प्रॉक्सी पैटर्न और स्टोरेज लेआउट” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

अपग्रेड किए जा सकने वाले कॉन्ट्रैक्ट क्यों
UUPS प्रॉक्सी प्रतिरूप लागू करना
Diamond मानक (बहु-फ़ैसेट प्रॉक्सी)
पारदर्शी प्रॉक्सी पैटर्न और स्टोरेज लेआउट

← Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट पर वापस जाएँ