स्मार्ट कॉन्ट्रैक्ट्स समझाए गए: वे कैसे काम करते हैं और क्यों महत्वपूर्ण हैं

स्मार्ट कॉन्ट्रैक्ट एक self-executing प्रोग्राम है जो blockchain पर स्टोर होता है और पूर्वनिर्धारित शर्तें पूरी होने पर किसी समझौते की शर्तों को अपने आप लागू करता है। पारंपरिक कॉन्ट्रैक्ट्स के विपरीत, जिन्हें लागू कराने के लिए वकीलों, अदालतों और बिचौलियों की जरूरत होती है, स्मार्ट कॉन्ट्रैक्ट्स कोड के आधार पर स्वायत्त रूप से चलते हैं — सबसे शाब्दिक अर्थ में "code is law"।

साधारण वैल्यू ट्रांसफर से आगे लगभग हर महत्वपूर्ण blockchain नवाचार की नींव स्मार्ट कॉन्ट्रैक्ट्स ही हैं: decentralized finance (DeFi), non-fungible tokens (NFTs), decentralized autonomous organizations (DAOs), token standards, gaming, और बहुत कुछ। आधुनिक क्रिप्टोकरेंसी इकोसिस्टम में काम करने वाले हर व्यक्ति के लिए स्मार्ट कॉन्ट्रैक्ट्स को समझना जरूरी है।

स्मार्ट कॉन्ट्रैक्ट्स के पीछे की अवधारणा

Nick Szabo की दृष्टि (1994)

"smart contract" शब्द 1994 में कंप्यूटर वैज्ञानिक और क्रिप्टोग्राफर Nick Szabo ने दिया था, blockchain के अस्तित्व में आने से कई साल पहले। Szabo ने स्मार्ट कॉन्ट्रैक्ट्स को इस तरह बताया: "a set of promises, specified in digital form, including protocols within which the parties perform on these promises."

उन्होंने वेंडिंग मशीन का उदाहरण दिया: आप तय रकम डालते हैं, विकल्प चुनते हैं, और मशीन अपने आप उत्पाद दे देती है। न सेल्सपर्सन, न बातचीत, न भरोसे की जरूरत — सिस्टम खुद लेनदेन लागू करता है। स्मार्ट कॉन्ट्रैक्ट्स इसी विचार को बहुत अधिक जटिल समझौतों तक बढ़ाते हैं।

सिद्धांत से वास्तविकता तक

हालांकि Szabo का विचार दूरदर्शी था, लेकिन इसे लागू करने की तकनीक तब तक उपलब्ध नहीं थी जब तक blockchain ने एक decentralized, tamper-proof execution environment नहीं दिया। Bitcoin में सीमित scripting language (Bitcoin Script) थी, जिसने basic conditional spending सक्षम किया — multi-signature requirements, time-locked transactions — लेकिन इसे जानबूझकर सीमित रखा गया था और यह Turing-complete नहीं था।

बड़ा breakthrough Ethereum के साथ आया, जिसे 2015 में Vitalik Buterin और अन्य लोगों ने लॉन्च किया। Ethereum को शुरू से ही एक "world computer" के रूप में डिजाइन किया गया था — arbitrary smart contract logic चलाने के लिए एक global, decentralized platform।

स्मार्ट कॉन्ट्रैक्ट्स कैसे काम करते हैं

Deployment

स्मार्ट कॉन्ट्रैक्ट की शुरुआत blockchain के लिए बनी किसी प्रोग्रामिंग भाषा में लिखे source code से होती है। Ethereum पर सबसे प्रमुख भाषा Solidity है, हालांकि Vyper (Python-जैसा syntax), Yul (low-level), और Fe जैसे विकल्प भी हैं।

deployment प्रक्रिया:

कोड लिखें: डेवलपर Solidity या किसी अन्य भाषा में स्मार्ट कॉन्ट्रैक्ट का logic लिखता है।
Compile: source code को bytecode में compile किया जाता है — low-level instructions जिन्हें Ethereum Virtual Machine (EVM) चला सकती है।
Deploy: bytecode को blockchain पर एक विशेष deployment transaction के रूप में भेजा जाता है। यह transaction एक unique address पर नया contract account बनाती है।
Immutable storage: deploy होने के बाद contract code blockchain पर स्थायी रूप से स्टोर हो जाता है। इसे बदला नहीं जा सकता (हालांकि proxy contracts के जरिए upgradeable patterns मौजूद हैं)।

Execution

जब कोई user या दूसरा contract किसी स्मार्ट कॉन्ट्रैक्ट से इंटरैक्ट करता है:

contract address पर encoded function call data के साथ transaction भेजी जाती है।
validator उस transaction को block में शामिल करता है।
Ethereum Virtual Machine (EVM) contract का bytecode execute करती है।
contract अपनी stored state पढ़ता है, computations करता है, और जरूरत के अनुसार state अपडेट करता है।
परिणाम (state changes, events, return values) blockchain पर रिकॉर्ड होते हैं।
user consumed computational resources के अनुपात में gas fees देता है।

Ethereum Virtual Machine (EVM)

EVM, Ethereum और EVM-compatible chains (BNB Smart Chain, Polygon, Avalanche C-Chain, Arbitrum, Optimism, और कई अन्य) पर स्मार्ट कॉन्ट्रैक्ट्स के लिए runtime environment है। इसकी मुख्य विशेषताएं:

Deterministic: समान inputs और state पर EVM हमेशा वही output देती है। यह जरूरी है क्योंकि हर node को स्वतंत्र रूप से वही परिणाम निकालना होता है।
Sandboxed: contracts isolation में चलते हैं और सीधे file system, network, या अन्य external resources एक्सेस नहीं कर सकते।
Metered: हर operation की gas cost होती है, जिससे infinite loops और denial-of-service attacks रुकते हैं।
Stack-based: EVM 256-bit word size वाली stack-based architecture का उपयोग करती है, जो cryptographic operations के लिए optimized है।

Gas और Execution Costs

Gas Ethereum में computational effort मापने की इकाई है। हर EVM operation (opcode) की fixed gas cost होती है:

Operation	Gas Cost
Addition (ADD)	3
Multiplication (MUL)	5
Storage write (SSTORE)	20,000 (new) / 5,000 (update)
External call (CALL)	2,600+
Contract creation (CREATE)	32,000+

Users एक gas limit (जितनी अधिकतम gas खर्च करने को तैयार हैं) और एक gas price (प्रति unit gas भुगतान) सेट करते हैं। अगर execution gas limit से आगे बढ़ती है, तो transaction revert हो जाती है लेकिन gas fee फिर भी कटती है। यह तंत्र infinite loops को रोकता है और computational work के लिए validators को भुगतान सुनिश्चित करता है।

स्मार्ट कॉन्ट्रैक्ट की संरचना

मुख्य घटकों को दिखाने के लिए यहां एक सरल Solidity स्मार्ट कॉन्ट्रैक्ट है:

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

contract SimpleEscrow {
    address public buyer;
    address public seller;
    uint256 public amount;
    bool public isComplete;

    event FundsDeposited(address indexed buyer, uint256 amount);
    event FundsReleased(address indexed seller, uint256 amount);

    constructor(address _seller) {
        buyer = msg.sender;
        seller = _seller;
    }

    function deposit() external payable {
        require(msg.sender == buyer, "Only buyer can deposit");
        require(amount == 0, "Already deposited");
        amount = msg.value;
        emit FundsDeposited(buyer, msg.value);
    }

    function confirmReceipt() external {
        require(msg.sender == buyer, "Only buyer can confirm");
        require(amount > 0, "No funds deposited");
        require(!isComplete, "Already completed");

        isComplete = true;
        payable(seller).transfer(amount);
        emit FundsReleased(seller, amount);
    }
}

यह कॉन्ट्रैक्ट कई महत्वपूर्ण अवधारणाएं दिखाता है:

State variables (buyer, seller, amount, isComplete) blockchain पर बनी रहती हैं।
Events (FundsDeposited, FundsReleased) logs emit करते हैं जिन्हें external applications मॉनिटर कर सकती हैं।
Access control (require statements) सुनिश्चित करता है कि केवल authorized पक्ष ही कुछ functions कॉल कर सकें।
Value transfer (transfer) addresses के बीच ETH भेजता है।
Immutable logic: deploy होने के बाद इन नियमों को कोई नहीं बदल सकता — यहां तक कि contract creator भी नहीं।

स्मार्ट कॉन्ट्रैक्ट प्लेटफॉर्म

हालांकि Ethereum ने स्मार्ट कॉन्ट्रैक्ट्स की शुरुआत की, अब कई प्लेटफॉर्म इन्हें सपोर्ट करते हैं:

EVM-Compatible Chains

ये chains वही EVM architecture उपयोग करती हैं और Solidity को सपोर्ट करती हैं:

BNB Smart Chain (BSC): कम fees, तेज blocks, ज्यादा centralized।
Polygon PoS: कम fees वाली Ethereum sidechain।
Avalanche C-Chain: high-throughput EVM chain with sub-second finality।
Arbitrum / Optimism: inherited Ethereum security के साथ Ethereum Layer 2 rollups।
Base: Optimism के OP Stack पर बनी Coinbase की Layer 2।

Non-EVM Platforms

Solana: smart contracts (जिन्हें "programs" कहा जाता है) के लिए Rust और C, unique parallel execution model के साथ।
Cardano: smart contracts के लिए Haskell-based Plutus, formal verification पर जोर।
Polkadot: अपने parachain ecosystem पर smart contracts के लिए ink! (Rust-based)।
Cosmos: Cosmos SDK chains पर CosmWasm (Rust-based) के जरिए smart contracts।
Near Protocol: sharded architecture के साथ Rust और AssemblyScript का उपयोग।
Tezos: formal verification क्षमताओं के साथ Michelson, एक low-level stack-based language, का उपयोग।

वास्तविक दुनिया में उपयोग

Decentralized Finance (DeFi)

पूरा DeFi इकोसिस्टम स्मार्ट कॉन्ट्रैक्ट्स पर चलता है:

Automated Market Makers (AMMs): Uniswap, Curve, और SushiSwap order books के बिना decentralized token exchanges बनाने के लिए smart contracts का उपयोग करते हैं। liquidity providers pools में token pairs जमा करते हैं, और एक mathematical formula कीमतें स्वतः तय करता है।
Lending protocols: Aave, Compound, और MakerDAO permissionless lending और borrowing सक्षम करने के लिए smart contracts उपयोग करते हैं। users collateral जमा करके उसके against उधार लेते हैं, और interest rates algorithmically तय होती हैं।
Stablecoins: DAI एक decentralized stablecoin है जो MakerDAO smart contracts में collateral जमा करके बनती है। collateral value गिरने पर सिस्टम liquidation स्वतः manage करता है।
Yield aggregators: Yearn Finance और ऐसे अन्य protocols returns optimize करने के लिए smart contracts से funds को अलग-अलग DeFi protocols में स्वतः स्थानांतरित करते हैं।

Non-Fungible Tokens (NFTs)

NFTs स्मार्ट कॉन्ट्रैक्ट्स होते हैं (आमतौर पर ERC-721 या ERC-1155 standard का पालन करते हुए) जो unique digital items के ownership को दर्शाते हैं। smart contract हर token की minting, transfer, और provenance tracking संभालता है।

Decentralized Autonomous Organizations (DAOs)

DAOs ऐसी organizations हैं जो पूरी तरह smart contracts द्वारा govern होती हैं। token holders proposals (fund allocation, parameter changes, strategic decisions) पर वोट करते हैं, और smart contract विजयी निर्णय अपने आप execute करता है। इससे पारंपरिक कॉर्पोरेट ढांचे के बिना decentralized governance संभव होती है।

Token Standards

स्मार्ट कॉन्ट्रैक्ट्स standardized token interfaces परिभाषित करते हैं:

ERC-20: Fungible tokens (हजारों cryptocurrencies में उपयोग)।
ERC-721: Non-fungible tokens (unique digital assets)।
ERC-1155: Multi-token standard (fungible और non-fungible दोनों)।
ERC-4626: yield-bearing assets के लिए tokenized vaults।

Insurance

Parametric insurance smart contracts पूर्वनिर्धारित शर्तें पूरी होने पर स्वतः भुगतान करते हैं — उदाहरण के लिए, flight delay insurance contract जो flight data में threshold से अधिक delay confirm होने पर payment ट्रिगर करता है।

Gaming और Metaverse

Blockchain games smart contracts का उपयोग in-game assets (items, characters, land) को tokens के रूप में manage करने के लिए करते हैं, जिन पर खिलाड़ियों का वास्तविक ownership होता है और जिन्हें वे गेम के बाहर स्वतंत्र रूप से trade कर सकते हैं।

स्मार्ट कॉन्ट्रैक्ट सुरक्षा

स्मार्ट कॉन्ट्रैक्ट सुरक्षा अत्यंत महत्वपूर्ण है क्योंकि deployed contracts वास्तविक मूल्य संभालते हैं, immutable होते हैं, और adversarial environment में काम करते हैं।

सामान्य कमजोरियां

Reentrancy: एक malicious contract पहली execution पूरी होने से पहले vulnerable contract में दोबारा call करता है, जिससे state में छेड़छाड़ होती है। 2016 DAO hack ने इसी कमजोरी का फायदा उठाया, $60 million मूल्य का ETH निकाला गया और इससे Ethereum/Ethereum Classic hard fork हुआ।

Integer overflow/underflow: Solidity 0.8.0 से पहले arithmetic operations में silent overflow या underflow हो सकता था, जिससे अप्रत्याशित व्यवहार होता था। आधुनिक Solidity में built-in overflow checks हैं।

Access control flaws: missing या गलत access controls unauthorized users को privileged functions (जैसे funds निकालना या ownership बदलना) कॉल करने देते हैं।

Oracle manipulation: external data (price feeds) पर निर्भर smart contracts का दुरुपयोग हो सकता है अगर oracle manipulate हो जाए। flash loan attacks अक्सर oracle vulnerabilities का उपयोग करके artificial price discrepancies बनाते हैं।

Front-running: pending transactions mempool में दिखती हैं, इसलिए adversaries higher gas fees के साथ competing transactions भेजकर victim की transaction से पहले execute कर सकते हैं और value निकाल सकते हैं। यह Miner/Maximum Extractable Value (MEV) का एक रूप है।

Logic errors: business logic में साधारण programming mistakes तब विनाशकारी हो सकती हैं जब contract लाखों डॉलर manage कर रहा हो।

सुरक्षा के सर्वोत्तम अभ्यास

Audits: smart contract review में विशेषज्ञ firms (Trail of Bits, OpenZeppelin, Consensys Diligence) द्वारा professional security audits।
Formal verification: गणितीय रूप से सिद्ध करना कि contract सभी संभावित inputs पर इच्छित तरीके से व्यवहार करता है।
Bug bounties: white-hat hackers को vulnerabilities exploit होने से पहले खोजने और रिपोर्ट करने के लिए प्रोत्साहित करना।
Testing: comprehensive unit tests, integration tests, और fuzzing (automated random input testing)।
Battle-tested libraries: security-critical code शुरू से लिखने के बजाय OpenZeppelin जैसी audited, open-source libraries का उपयोग।
Upgradeable patterns: proxy contracts का उपयोग जो state को बनाए रखते हुए logic अपडेट की अनुमति देते हैं, जिससे deployment के बाद bug fixes संभव होते हैं। इसका trade-off है: upgradeability safety बढ़ाती है लेकिन trustlessness घटाती है क्योंकि admin संभावित रूप से malicious बदलाव कर सकता है।

उल्लेखनीय exploits

Year	Incident	Amount Lost	Vulnerability
2016	The DAO	$60M	Reentrancy
2021	Poly Network	$611M	Access control (returned)
2022	Wormhole Bridge	$320M	Signature verification
2022	Ronin Bridge	$625M	Compromised validator keys
2023	Euler Finance	$197M	Donation attack (returned)

ये घटनाएं स्मार्ट कॉन्ट्रैक्ट सुरक्षा के महत्व को स्पष्ट करती हैं। जब seed phrase compromise होती है, तो सिर्फ एक wallet प्रभावित होता है। लेकिन जब smart contract exploit होता है, तो उस contract में funds जमा करने वाले सभी users अपनी assets खो सकते हैं।

स्मार्ट कॉन्ट्रैक्ट्स की सीमाएं

Oracle Problem

स्मार्ट कॉन्ट्रैक्ट्स केवल on-chain मौजूद डेटा तक पहुंच सकते हैं। वे native रूप से stock prices, weather conditions, या sports scores जैसे real-world data नहीं ला सकते। Oracles (जैसे Chainlink, Pyth, और API3) external data को on-chain feed करके यह gap भरते हैं, लेकिन वे trust dependency जोड़ते हैं — oracle centralization और संभावित failure का बिंदु बन जाता है।

दोधारी तलवार के रूप में Immutability

Immutability यह सुनिश्चित करती है कि contract rules मनमाने ढंग से नहीं बदले जा सकते, जो एक feature है। लेकिन इसका अर्थ यह भी है कि bugs patch नहीं किए जा सकते। user funds के साथ vulnerable contract deploy होने के बाद विकल्प सीमित हो सकते हैं: users को नए contract पर migrate करने के लिए मनाना, governance-based upgrades लागू करना (यदि contract सपोर्ट करता हो), या नुकसान स्वीकार करना।

Scalability Constraints

हर smart contract execution को network के हर node द्वारा दोहराना पड़ता है। इससे throughput सीमित होती है और complex computations महंगी हो जाती हैं। Layer 2 solutions इस समस्या को off-chain execution के जरिए हल करते हैं, जबकि base layer की security बनाए रखते हैं।

कानूनी अस्पष्टता

कई jurisdictions में स्मार्ट कॉन्ट्रैक्ट्स की कानूनी स्थिति अब भी अस्पष्ट है। कुछ क्षेत्रों (Arizona, Tennessee, और कई EU देशों) ने smart contracts को कानूनी रूप से बाध्यकारी मानने वाले कानून पारित किए हैं, लेकिन immutable code और mutable legal frameworks का मेल अब भी अनसुलझे तनाव पैदा करता है।

SafeSeed टूल

किसी भी smart contract से इंटरैक्ट करने से पहले सुनिश्चित करें कि आपका wallet सुरक्षित है। अपने Ethereum wallet के लिए cryptographically secure seed phrase बनाने हेतु SafeSeed Seed Phrase Generator का उपयोग करें। smart contracts उतने ही सुरक्षित होते हैं जितनी उन्हें उपयोग करने वाली private keys — यदि आपकी key compromise हो जाती है, तो attacker आपकी ओर से contract functions कॉल करके आपके tokens खाली कर सकता है।

FAQ

क्या smart contracts कानूनी रूप से बाध्यकारी होते हैं?

smart contracts की कानूनी स्थिति jurisdiction के अनुसार बदलती है। कुछ U.S. states (Arizona, Nevada, Tennessee) और अन्य देशों ने उन्हें कानूनी रूप से enforceable agreements के रूप में मान्यता देने वाले कानून बनाए हैं। हालांकि, अधिकांश jurisdictions में कानूनी ढांचा अभी विकसित हो रहा है। मुख्य अंतर यह है कि smart contract code के जरिए self-enforcing होता है — इसे कानूनी enforcement की आवश्यकता नहीं क्योंकि यह स्वचालित रूप से execute होता है। कानूनी मुद्दे तब आते हैं जब ऐसे विवाद हों जिनका code में पूर्वानुमान न हो या जहां real-world obligations शामिल हों।

क्या deploy होने के बाद smart contracts बदले जा सकते हैं?

स्टैंडर्ड smart contracts deployment के बाद immutable होते हैं — code बदला नहीं जा सकता। लेकिन developers proxy patterns उपयोग कर सकते हैं, जहां proxy contract calls को implementation contract पर delegate करता है जिसे बदला जा सकता है। इससे contract address और state को बनाए रखते हुए logic अपडेट संभव होते हैं। trade-off यह है कि upgrade authority trust assumption लाती है — upgrade key नियंत्रित करने वाला पक्ष सैद्धांतिक रूप से contract को malicious तरीके से बदल सकता है।

smart contract और regular program में क्या अंतर है?

regular program एक single server पर चलता है जिसे एक entity नियंत्रित करती है। smart contract हजारों nodes पर एक साथ चलता है, और हर node स्वतंत्र रूप से वही परिणाम compute और verify करता है। smart contracts transparent (कोई भी code पढ़ सकता है), immutable (deploy होने के बाद), और trustless (enforcement किसी एक party पर निर्भर नहीं) होते हैं। regular programs तेज, सस्ते और अधिक flexible होते हैं, लेकिन operator पर trust मांगते हैं।

smart contract deploy करने में कितना खर्च आता है?

deployment cost contract की complexity, उपयोग किए गए blockchain, और मौजूदा network congestion पर काफी निर्भर करती है। Ethereum mainnet पर एक simple token contract deploy करने में gas fees के रूप में लगभग $50-$500 लग सकते हैं, जबकि complex DeFi protocols में हजारों डॉलर खर्च हो सकते हैं। Arbitrum या Optimism जैसे Layer 2 networks ये लागत 10-100x तक घटा देते हैं। Solana जैसी कुछ chains में deployment cost बहुत कम होती है।

क्या smart contracts एक-दूसरे से इंटरैक्ट कर सकते हैं?

हाँ, इसे composability कहा जाता है और यह smart contracts की सबसे शक्तिशाली विशेषताओं में से एक है। contracts अन्य contracts पर functions कॉल कर सकते हैं, जिससे simple building blocks से complex applications बनती हैं। DeFi protocols अक्सर compose होते हैं — उदाहरण के लिए, एक yield aggregator एक ही transaction में lending protocols, DEXes, और staking contracts से इंटरैक्ट कर सकता है। इस composability को अक्सर "money legos" कहा जाता है।

smart contracts के लिए कौन-सी programming languages उपयोग होती हैं?

Solidity सबसे व्यापक रूप से उपयोग की जाने वाली smart contract language है, जो विशेष रूप से EVM के लिए बनाई गई है। Vyper EVM chains के लिए Python-प्रभावित विकल्प है, जो simplicity और auditability पर जोर देती है। Rust का उपयोग Solana (Anchor framework), Cosmos (CosmWasm), Near, और Polkadot (ink!) smart contracts में होता है। Move का उपयोग Aptos और Sui में होता है। Cairo का उपयोग StarkNet के zero-knowledge rollup में होता है। हर भाषा में expressiveness, safety, और performance के अलग trade-offs होते हैं।

अगर smart contract में bug हो तो क्या होता है?

यदि deployed smart contract में bug है, तो परिणाम severity और contract design पर निर्भर करते हैं। minor bugs असुविधा पैदा कर सकते हैं; critical bugs जमा किए गए सभी funds के नुकसान का कारण बन सकते हैं। यदि contract upgradeable proxy pattern उपयोग करता है, तो developers fix deploy कर सकते हैं। अगर नहीं, तो community को नया contract deploy करना पड़ सकता है और users को migrate करने के लिए मनाना पड़ता है। अत्यधिक मामलों में (जैसे 2016 DAO hack), नुकसान पलटने के लिए hard fork किया जा सकता है, हालांकि यह बहुत विवादास्पद और दुर्लभ है।

क्या smart contracts सिर्फ Ethereum पर होते हैं?

नहीं। हालांकि Ethereum ने smart contracts की शुरुआत की, अब कई blockchains इन्हें सपोर्ट करती हैं। BNB Smart Chain, Polygon, Avalanche, Arbitrum, Optimism, और Base सभी EVM-compatible smart contracts सपोर्ट करते हैं। Solana, Cardano, Polkadot, Cosmos, Near, Tezos, Algorand, और Tron अपनी execution environments और languages के साथ smart contracts सपोर्ट करते हैं। EVM एक de facto standard बन चुका है, और कई chains मौजूदा developer tools और ज्ञान का लाभ लेने के लिए EVM compatibility चुनती हैं।

स्मार्ट कॉन्ट्रैक्ट्स के पीछे की अवधारणा​

Nick Szabo की दृष्टि (1994)​

सिद्धांत से वास्तविकता तक​

स्मार्ट कॉन्ट्रैक्ट्स कैसे काम करते हैं​

Deployment​

Execution​

Ethereum Virtual Machine (EVM)​

Gas और Execution Costs​

स्मार्ट कॉन्ट्रैक्ट की संरचना​

स्मार्ट कॉन्ट्रैक्ट प्लेटफॉर्म​

EVM-Compatible Chains​

Non-EVM Platforms​

वास्तविक दुनिया में उपयोग​

Decentralized Finance (DeFi)​

Non-Fungible Tokens (NFTs)​

Decentralized Autonomous Organizations (DAOs)​

Token Standards​

Insurance​

Gaming और Metaverse​

स्मार्ट कॉन्ट्रैक्ट सुरक्षा​

सामान्य कमजोरियां​

सुरक्षा के सर्वोत्तम अभ्यास​

उल्लेखनीय exploits​

स्मार्ट कॉन्ट्रैक्ट्स की सीमाएं​

Oracle Problem​

दोधारी तलवार के रूप में Immutability​

Scalability Constraints​

कानूनी अस्पष्टता​

FAQ​

क्या smart contracts कानूनी रूप से बाध्यकारी होते हैं?​

क्या deploy होने के बाद smart contracts बदले जा सकते हैं?​

smart contract और regular program में क्या अंतर है?​

smart contract deploy करने में कितना खर्च आता है?​

क्या smart contracts एक-दूसरे से इंटरैक्ट कर सकते हैं?​

smart contracts के लिए कौन-सी programming languages उपयोग होती हैं?​

अगर smart contract में bug हो तो क्या होता है?​

क्या smart contracts सिर्फ Ethereum पर होते हैं?​

संबंधित गाइड्स​