ZYCORD दस्तावेज़
हिन्दी
Zycordदस्तावेज़नेटवर्क कैसे काम करता है
Zycord (ZCD) — नेटवर्क कैसे काम करता है

ऑफ़-चेन जोड़ा गया।
समानांतर में सत्यापित।
क्रम में कमिट।

हर बड़ा ब्लॉकचेन हर नोड से हर ट्रांज़ैक्शन को एक वैश्विक स्टेट के विरुद्ध दोबारा निष्पादित कराता है। Zycord निष्पादन को चेन से बाहर ले जाता है: भुगतान वॉलेट बनाता है, कॉन्ट्रैक्ट कॉल को कॉन्ट्रैक्ट का sequencer उपयोगकर्ता के हस्ताक्षरित intent से निष्पादित करता है, और दोनों ही स्थितियों में परिणाम उस सब के साथ पूरा पहुँचता है जो उसने पढ़ा और लिखा। कोई भी मशीन उसे केवल बाइट्स से जाँच लेती है, और एक ही लूप उसे कमिट कर देता है — या skip कर देता है, और जिसने उसके लिए deposit रखा था उससे शुल्क वसूलता है।

Three phases: construction by sequencers, parallel verification, sequential fold निर्माण — ऑफ़-चेन sequencers intent निष्पादित करते हैं और एक fill पर सह-हस्ताक्षर करते हैं वॉलेट Sequencer contract A Sequencer contract B Sequencer कॉन्ट्रैक्ट C सत्यापन — समानांतर, stateless हर नोड हर सर्टिफिकेट जाँचता है, हर कोर पर fold — अनुक्रमिक एक लूप, तुलना करता और जोड़ता है लागू या skip, कभी निष्पादन नहीं
साधारण सर्वर, web2, कोई consensus नहीं नेटवर्क में जुड़ने वाले हर कोर के साथ बढ़ता है एकमात्र दुर्लभ संसाधन

ट्रांज़ैक्शन एक सर्टिफिकेट है

यह यह नहीं कहता कि “इसे निष्पादित करो”। यह कहता है “मैंने यह पढ़ा, मैंने वह लिखा, और यह रहा प्रमाण”। कोई भी दोबारा गणना करके मिलान कर सकता है।

Certificate { chain_id: u64 // यह किस नेटवर्क के लिए है seq: u64 // जमाकर्ता का अपना काउंटर program: (type, body) // नेटिव ऑपरेशन, मशीन कॉल, fill, forced reads: [(slot, access, operand)] // मैंने क्या पढ़ा, और कैसे writes: [(slot, op, value)] // मैं क्या लिखता हूँ sigs: [(key, signature)] // खर्च करने का अधिकार deposit: (cell, amount, change) // इसके लिए कौन उत्तरदायी है ttl: height // यहाँ तक शामिल न हुआ तो समाप्त fee_bid: (seq_gas, par_gas) // दो बाज़ार }
Valid = बाइट्स का एक शुद्ध फलनहस्ताक्षर सत्यापित होते हैं, reads पर program का पुनः-निष्पादन ठीक-ठीक writes उत्पन्न करता है, और deposit सबसे बुरी स्थिति को ढकता है। न डिस्क, न इतिहास।
Applicable = स्थिति से तयजब सर्टिफिकेट की ब्लॉक में बारी आती है, तब क्या घोषित reads अब भी टिके हुए हैं?
ID में हस्ताक्षर शामिल नहींअलग nonce के साथ दोबारा हस्ताक्षर करने पर वही ID मिलती है। seen set नक़ल को पकड़ लेता है। किसी से दो बार शुल्क नहीं लिया जाता।
प्रति slot पहुँच के प्रकारEXACT मान को पिन करता है। GUARD सिर्फ़ इतना कहता है कि “balance ≥ x”। DELTA बिना पढ़े जोड़ता है। भुगतान और टिप आपस में क्रम-निरपेक्ष हैं और कभी टकराते नहीं।

दो क्रियाएँ, दो चरण

पूरा डिज़ाइन इन दो प्रश्नों को अलग करने का ही है — और हर एक का उत्तर सबसे सस्ती जगह पर देने का।

समानांतर

क्या यह valid है?

उत्तर केवल सर्टिफिकेट को देखकर मिलता है। एक साथ हज़ारों, किसी भी मशीन पर।

  • सख़्त Ed25519 हस्ताक्षर सही निकलते हैं
  • पुनर्निष्पादन writes से मेल खाता है
  • deposit सबसे बुरी स्थिति को ढकता है
  • अमान्य: कभी किसी ईमानदार ब्लॉक में नहीं आता
अनुक्रमिक

क्या यह applicable है?

उत्तर ब्लॉक में सर्टिफिकेट की स्थिति पर मिलता है, बाइट्स की स्टेट तालिका से तुलना करके।

  • reads अब भी टिके हैं → writes कमिट हो जाते हैं
  • बासी read या overflow → skip, जमाकर्ता एक नियत शुल्क चुकाता है
  • deposit में धन नहीं या वह spent → drop, कोई शुल्क नहीं
  • हर हाल में ब्लॉक valid बना रहता है

चार परिणाम, और भुगतान कौन करता है

किसी सर्टिफिकेट में समस्या एक परिणाम है, ब्लॉक को अस्वीकार करने का कारण कभी नहीं। हर परिणाम का शुल्क उस पक्ष से लिया जाता है जिसने जोखिम चुना, और एक हस्ताक्षर से अधिकतम एक बार शुल्क लिया जाता है।

लागू (Applied)

हर घोषित read टिका रहता है, इसलिए writes दर्ज होते हैं और शुल्क वास्तविक लागत पर निपटता है: आधार शुल्क जलाया जाता है और प्राथमिकता शुल्क producer को दिया जाता है।

Forced-failed (forced विफल)

एक forced सर्टिफिकेट जिसकी कॉल revert हुई या जिसने अपनी सीमाएँ तोड़ीं। उसके भुगतानकर्ताओं से डेबिट होता है, बची रक़म उपयोगकर्ता को लौटती है, और कुछ नहीं लिखा जाता, और id को seen चिह्नित किया जाता है।

Drop हुआ (Dropped)

deposit cell में धन नहीं है या वह पहले ही spent है, इसलिए शुल्क लेने को कुछ नहीं है। सर्टिफिकेट ढोया जाता है पर उससे शुल्क नहीं लिया जाता, और उसे seen चिह्नित नहीं किया जाता।

जन्म से लेकर बहीखाते तक का प्रवाह

1

वॉलेट एक भुगतान बनाता है, या एक intent पर हस्ताक्षर करता है

भुगतान को किसी सर्वर की ज़रूरत नहीं: वॉलेट अपने पास के एक one-shot cell पर guard लगाता है, उससे डेबिट करता है, उसे spent चिह्नित करता है, प्राप्तकर्ता के नए पते में क्रेडिट करता है और बची रक़म अपने ही एक नए पते पर भेजता है। किसी sequenced कॉन्ट्रैक्ट को कॉल इसके बजाय एक हस्ताक्षरित intent है: क्या कॉल करना है, परिणाम पर सीमाएँ, sequencer को क्या भुगतान होगा, और वे one-shot भुगतानकर्ता पते जो उसे धन देते हैं।

2

sequencer निष्पादित करता है और पुष्टि करता है

वह intent को अपने दृष्टिकोण पर चलाता है — चेन का सिरा और वह हर fill जो वह पहले ही बना चुका है — मिलीसेकंडों में एक हस्ताक्षरित receipt से उत्तर देता है, और परिणाम को अपने शेष से deposit किए गए एक fill के रूप में प्रकाशित करता है। जो कॉल अलग-अलग sequencers से बँधे कॉन्ट्रैक्टों को पार करती है उस पर हर एक सह-हस्ताक्षर करता है और वह एक atomic fill के रूप में दर्ज होती है।

3

हर नोड समानांतर में सत्यापित करता है

हर सर्टिफिकेट पहुँचते ही, रिले किए जाने से पहले, उसके बाइट्स से जाँचा जाता है: हस्ताक्षर, घोषित reads के विरुद्ध पुनः-निष्पादन, deposit। न स्टेट, न इतिहास, कोई भी कोर, कोई भी मशीन।

अमान्य → त्याग दिया गया; किसी ब्लॉक के भीतर हो तो ब्लॉक को अमान्य बना देता है
4

producer क्रम तय करता है

एक proof-of-work माइनर valid सर्टिफिकेट चुनता है और ब्लॉक हल करता है; proof of stake पर switch के बाद, उस slot के लिए ड्रॉ में चुना गया staker इसके बजाय उस पर हस्ताक्षर करता है। उसे जो दिया जाता है उसमें से वह कुछ भी निष्पादित नहीं करता और TTL विंडो के भीतर देखी गई ids याद रखता है, क्योंकि किसी एक को दो बार शामिल करने से ब्लॉक invalid हो जाता है। अपने ब्लॉक के अंत में वह forced path से open intents निष्पादित कर सकता है।

5

अनुक्रमिक fold

पहले fills, pipeline क्रम में; फिर बाक़ी हर सर्टिफिकेट (deposit address, seq, id) के अनुसार; फिर forced सर्टिफिकेट id के अनुसार। producer इनमें से कुछ भी नहीं चुनता। हर सर्टिफिकेट के लिए: क्या घोषित reads अब भी टिके हैं?

लागू — writes दर्ज, आधार शुल्क जला, प्राथमिकता शुल्क producer को
skip — कुछ नहीं लिखा गया, deposit से skip शुल्क जला, ब्लॉक valid बना रहा

स्टेट: cells, पते, टाइप की गई पहुँच

cell किसी slot पर एक 256-बिट पूर्णांक है। अनुपस्थित cells शून्य के रूप में पढ़े जाते हैं। समवर्तिता रनटाइम पर खोजी नहीं जाती: वह घोषित की जाती है, slot दर slot।

टाइप की गई पहुँच

read या तो EXACT है, जो गणना को इनपुट देता है और cell के बदलने पर बासी पड़ जाता है, या एक guard — GUARD_GE, GUARD_LE, GUARD_EQ — जो कुछ नहीं लौटाता। write SET, DELTA_ADD, DELTA_SUB या MARK_SPENT है। केवल EXACT ही बासी पड़ता है, इसलिए एक slot पर guarded डेबिट और क्रेडिट आपस में क्रम-निरपेक्ष (commute) रहते हैं और केवल वास्तविक overdraft पर ही skip होते हैं।

one-shot और persistent पते

one-shot address एक ही बार ख़र्च होता है: जो सर्टिफिकेट उससे डेबिट करता है वह उसे स्थायी रूप से spent चिह्नित कर देता है। वॉलेट हर आने वाले भुगतान को एक नया पता देते हैं, जो बिना टकराव का रास्ता है। persistent address दोबारा इस्तेमाल हो सकता है — एक खाता — और माइनिंग इनाम उसी में होने चाहिए: one-shot address ख़र्च होते ही उसमें रखा हर इनाम जल जाता है, इसलिए नोड उसे भुगतान पते के रूप में अस्वीकार करता है। कॉन्ट्रैक्टों का अपना पता प्रकार है, जिसके लिए कोई कुंजी हस्ताक्षर नहीं कर सकती।

नेटिव एसेट, बिना मशीन के

ब्लॉक 0 से: अधिकतम 32 चालों वाला TRANSFER, आपूर्ति सीमा के साथ ISSUE, उसी सीमा से संरक्षित MINT, अधिकतम 64 one-shot पतों का RETIRE। किसी नए cell में क्रेडिट ही टिप है। एक ब्लॉक में दस हज़ार टिप दस हज़ार जोड़ हैं: शून्य टकराव, न sequencer, न मशीन।

मशीन और उसके sequencers

guarded deltas भुगतानों के टकराव को घोल देते हैं। जो बचता है वह ऐसा तर्क है जिसे यह तय करने के लिए कि क्या लिखना है, सटीक स्टेट पढ़नी पड़ती है — एक order book, एक market maker — और वहाँ कॉन्ट्रैक्ट अपना क्रमबद्धक (serializer) चुनता है।

cEVM

Ethereum वर्चुअल मशीन की एक बोली, इसलिए Solidity, उसके कंपाइलर और उसके ऑडिटर साथ चले आते हैं। storage घोषित होता है: SLOAD और SSTORE exact हैं, और छह नए opcodes guarded, क्रम-निरपेक्ष अनुशासन देते हैं। NUMBER और TIMESTAMP epoch beacon पढ़ते हैं, जो एक दिन तक स्थिर रहता है; जिन opcodes का कोई संदर्भ नहीं बचता उन्हें हटा दिया गया है। कोड सर्टिफिकेट में यात्रा करता है। delta-first ढंग से लिखे एक token, एक tip jar और एक escrow मशीन खुलने पर पहले से तैनात होते हैं।

sequenced या open

हर कॉन्ट्रैक्ट का रिकॉर्ड एक sequencer कुंजी का नाम देता है। यदि वह शून्य नहीं है, तो कॉन्ट्रैक्ट के exact path के लिए उस कुंजी का हस्ताक्षर चाहिए; यदि वह शून्य है, तो कोई भी उसे ले सकता है और कॉन्ट्रैक्ट केवल अपने कोड से सुरक्षित है। guarded deltas पर कभी रोक नहीं लगती: एक sequenced token अब भी किसी से भी हर हस्तांतरण स्वीकार करता है। एक directory बताती है कि हर sequencer कहाँ उत्तर देता है — खोज, प्राधिकरण नहीं।

Intents, fills और receipts

intent उपयोगकर्ता का पूरा प्राधिकरण है, अधिकतम 8 ब्लॉक की विंडो के लिए valid: sequencer यह बदल सकता है कि वह कब चले, यह कभी नहीं कि वह क्या करे। fill की id intent का हैश है, इसलिए एक intent के दो fills एक ही id साझा करते हैं और शुल्क केवल एक से लिया जा सकता है। receipt एक पूर्व-पुष्टि है, fill के लागू होने तक sequencer का वादा; एक-दूसरे का खंडन करने वाली दो receipts एक ऐसा प्रमाण हैं जिसे कोई भी बाइट्स से जाँच सकता है, और उपयोगकर्ता छोड़कर चले जाते हैं।

Pipelines, fence, co-sequencing

चेन हर sequencer और कॉन्ट्रैक्ट के लिए अंतिम लागू seq रखती है, और fill केवल अगले पर ही प्रवेश करता है, इसलिए एक pipeline उसी क्रम में कमिट होती है जिसमें उसके sequencer ने हस्ताक्षर किए। हर कॉन्ट्रैक्ट एक fence counter भी रखता है: उसकी स्टेट को set करने वाला forced सर्टिफिकेट, या sequencer का बदलाव, उसे आगे बढ़ाता है, और दरकिनार की गई स्टेट पर बना हर fill प्रवेश नहीं कर सकता — किसी से शुल्क नहीं लिया जाता, और sequencer दोबारा बनाता है। sequencers के आर-पार एक कॉल हर sequencer के हस्ताक्षर वाला एक fill है, रचना से ही atomic।

forced path: शामिल होना ही लागू होना है

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

हर ब्लॉक तीन वर्गों में fold होता है, ऐसे क्रम में जिसे producer नहीं चुनता

Fold order within a block: fills, then every other certificate, then forced certificates fold क्रम Fills pipeline क्रम में हर skip का भुगतान एक sequencer करता है बाक़ी हर सर्टिफिकेट deposit address, seq, id के अनुसार हर skip का भुगतान जमाकर्ता करता है Forced सर्टिफिकेट producer द्वारा निष्पादित, id के अनुसार अधिकतम 16; विफलता भी दर्ज होती है

उपयोगकर्ता एक open intent पर हस्ताक्षर करता है — ऐसा intent जिसमें किसी sequencer का नाम नहीं, जिसे उपयोगकर्ता के अपने one-shot भुगतानकर्ता पते धन देते हैं — और उसे नेटवर्क पर रिले करता है। producer, जिसके पास अपने ब्लॉक के अंत की स्टेट है, अपनी चुनी हुई open intents को उस स्टेट पर निष्पादित करता है और परिणामों को ब्लॉक के अंतिम सर्टिफिकेट के रूप में जोड़ देता है। न कोई कतार है, न lease, न कोटा, न समय-सीमा। intent का भुगतान शुल्क को ढकता है, इसलिए producer उतना ही कमाता है जितना एक sequencer कमाता।

यह fence को आगे बढ़ाता है

जो forced सर्टिफिकेट किसी कॉन्ट्रैक्ट की स्टेट के किसी cell को set करता है वह उस कॉन्ट्रैक्ट के fence counter को आगे बढ़ाता है, इसलिए उसके द्वारा दरकिनार की गई स्टेट पर बना हर fill दोबारा बनाया जाता है। जो केवल पढ़ता है, guard लगाता है या deltas जोड़ता है वह fence को नहीं छूता, और विफल होने वाला भी नहीं। sequencer की केवल latency घटती-बढ़ती है, और कुछ नहीं जाता।

रचना से सीमित

प्रति ब्लॉक अधिकतम 16 forced सर्टिफिकेट, हर एक के पास अधिकतम 4,000 derivation इकाइयों का समानांतर बजट (200,000 मशीन gas): genesis की समानांतर सीमा का अधिकतम एक तिहाई। कॉन्ट्रैक्ट लेखकों के लिए नियम यह है कि निकासी उस बजट में समा जाए।

कौन क्या करता है

सुरक्षा के लिए कोई भूमिका आवश्यक नहीं है। अगर हर sequencer ग़ायब हो जाए, तो कॉन्ट्रैक्ट अपनी delta विधियों और forced path के माध्यम से जीवित रहते हैं, जिसके द्वारा उपयोगकर्ता निकासी करते हैं और किसी कॉन्ट्रैक्ट को नए sequencer से बाँधा जा सकता है।

वॉलेट

करता है
भुगतानों को सर्टिफिकेट के रूप में बनाता है; कॉन्ट्रैक्टों के लिए intents पर हस्ताक्षर करता है
देखता है
वह सार्वजनिक स्टेट जिसे उसे पढ़ना है
भरोसा करता है
किसी पर नहीं

Sequencer

करता है
अपने कॉन्ट्रैक्टों के लिए intents निष्पादित करता है, receipts पर हस्ताक्षर करता है, fills प्रकाशित करता है
किस बात के लिए भरोसा
केवल जीवंतता के लिए। अगर वह झूठ बोले, तो उसका fill skip हो जाता है और उसका अपना deposit भुगतान करता है
कमाता है
अपने ही एप्लिकेशन का order flow, खुलकर

सत्यापन करने वाला नोड

करता है
हर सर्टिफिकेट को उसके बाइट्स से जाँचता है, आगे भेजता है, सिंक करता है
चाहिए
कोर। स्टेट केवल fold चलाने के लिए
लागत
सत्यापन उसके हर कोर पर फैलता है; fold मेमोरी पर एक लूप है

Block producer

करता है
RandomX से माइन करता है, valid सर्टिफिकेट का क्रम तय करता है, अपने ब्लॉक के अंत में open intents निष्पादित करता है
देखता है
बाइट्स और स्टेट, अर्थ नहीं
कमाता है
सब्सिडी का 94%, साथ ही जो लागू होता है उसके प्राथमिकता शुल्क

कॉन्ट्रैक्ट लेखक

करता है
हर slot को exact या guarded घोषित करता है; एक sequencer चुनता है, या कोई नहीं
पाता है
समानांतरता, प्रति slot वैकल्पिक
उपयोगकर्ताओं के प्रति दायित्व
एक निकासी जो forced बजट में समा जाए

नेटवर्क: दो gas बाज़ार

जो चेन हर चीज़ का शुल्क एक ही नीलामी में लेती है, वह एक प्रूफ़ सत्यापन को एक स्टेट राइट से मुक़ाबले में उतार देती है। यहाँ हर संसाधन का अपना दाम है।

Parallel gas

सत्यापन का दाम चुकाता है: हस्ताक्षर, बाइट्स, derivation इकाइयाँ — भारी प्रूफ़, पोस्ट-क्वांटम योजनाएँ।

नेटवर्क में जुड़ने वाले हर कोर और GPU के साथ आपूर्ति बढ़ती है। लक्ष्य और सीमा उनके अनुक्रमिक समकक्षों के 3× पर स्थिर। ऊँची सीमा, कम दाम।

Sequential gas

fold का दाम चुकाता है: reads, writes, spent-registry प्रविष्टियाँ, seen-set प्रविष्टियाँ। वह एकमात्र लूप जिसे हर नोड क्रम में चलाता है।

दुर्लभ। लचीला: लक्ष्य दिन में एक बार लागू हुए gas के अनुसार 1.6M और 5.12M के बीच खिसकता है; नरम सीमा लक्ष्य का 2×, कठोर सीमा 4×। कोई वोट नहीं करता।

Eras: आज क्या चलता है, और बाद में क्या आता है

Era एक रिलीज़ में कंपाइल की गई ऊँचाई है, या चेन पर मापी गई कोई शर्त। किसी द्वार से नीचे का ब्लॉक जो वह ढोता है जिसे द्वार सक्षम करता है, अमान्य है; नया Era कभी किसी पुराने ब्लॉक का अर्थ नहीं बदलता।

Era 0 — माइन करें और भुगतान करें

ब्लॉक 0, 7 अक्टूबर 2026 से सक्रिय। Nakamoto नियमों के तहत proof of work, नेटिव एसेट, one-shot और persistent पते, दो शुल्क बाज़ार, 94/3/3 सब्सिडी बँटवारा और treasury, जो जमा होती जाती है और जिससे कोई सर्टिफिकेट डेबिट नहीं कर सकता; ख़र्च का रास्ता, यदि कोई हो, बाद के किसी अपग्रेड से आएगा, ऊँचाई 259,200 से पहले नहीं।

Era 1 — मशीन

ऊँचाई 80,640, लगभग 4 नवंबर 2026, लॉन्च बाइनरी में। cEVM और उसकी मानक लाइब्रेरी, sequencer और admin वाले कॉन्ट्रैक्ट रिकॉर्ड, intents, fills और co-sequencing, directory, और forced path।

Era 2 — proof of stake

Bonding epoch 182 पर, लगभग 7 अप्रैल 2027 को, खुलती है: stake को bond, unbond या किसी pool को delegate किया जाता है, न्यूनतम 1,000 ZCD के bond से। जब सक्रिय stake 30 epochs तक आपूर्ति का 10% रखता है, और अधिकतम epoch 273 से, 90 epochs का एक ramp शुरू होता है: ब्लॉक अब भी माइन होते हैं, और हर एक पर stake के अनुपात में ड्रॉ से चुने गए एक staker का हस्ताक्षर भी होता है, जो producer के हिस्से का k/180 लेता है। इसकी अपनी रिलीज़, hard fork द्वारा।

Switch (संक्रमण)

Gate पार करने वाले 90वें epoch के बाद वाले epoch का पहला ब्लॉक — उसके 90% ब्लॉक हस्ताक्षरित, सक्रिय stake आपूर्ति का कम से कम 10%। माइनिंग समाप्त होती है; ड्रॉ में चुना गया staker हर 5-सेकंड slot पर हस्ताक्षर करता है, और 17,280 slots का एक epoch उतना ही देता है जितना पहले एक दिन देता था। एक ब्लॉक गहराई से अंतिम होता है, 120 ब्लॉक या 10 मिनट। केवल equivocation (एक slot के लिए दोहरा हस्ताक्षर) दंडित होता है, और delegator कभी नहीं।

पूर्ण सत्यापन से आगे

एक दिशा, विनिर्देश नहीं। जब दैनिक मात्रा उतने के क़रीब पहुँचे जितना एक साधारण नोड सत्यापित करता है, तो कोई बाद का Era हर नोड के बजाय हर सर्टिफिकेट को सत्यापित करने के लिए stakes के एक उपसमुच्चय का ड्रॉ कर सकता है, जबकि स्टेट और fold एक ही रहते हैं और हर सर्टिफिकेट atomic रहता है। तब तक हर नोड सब कुछ सत्यापित करता है।

Era S — गोपनीय भुगतान

छिपी हुई राशियाँ और एक-बार इस्तेमाल होने वाले पते, केवल स्वतंत्र ऑडिट और एक प्रतिकूल (adversarial) सार्वजनिक testnet के बाद। v2 प्रोटोकॉल का हिस्सा नहीं: यह अपनी अलग विशिष्टि के तहत आएगा।

ऊपर से देखा गया नेटवर्क

चार परतें जो आपस में नहीं मिलतीं: कौन बनाता है, कौन सत्यापित करता है, कौन क्रम तय करता है, और वह दरवाज़ा जिसे कोई बंद नहीं कर सकता। हर एक एक अलग संसाधन के साथ बढ़ती है।

ऑफ़-चेन

वॉलेट और sequencers

साधारण web2: websockets, कतारें, autoscaling। वॉलेट भुगतान ख़ुद बनाते हैं; sequencers intents निष्पादित करते हैं और मिलीसेकंडों में उत्तर देते हैं। जीवंतता के लिए भरोसेमंद, सुरक्षा के लिए कभी नहीं, और कभी डेटा के संरक्षक नहीं — स्टेट हमेशा केवल चेन से दोबारा बनाई जा सकती है।

समानांतर

रिले और सत्यापन

हर नोड हर सर्टिफिकेट को रिले करने से पहले उसके बाइट्स से जाँचता है। ब्लॉक एक हेडर और हैशों की एक सूची के रूप में यात्रा करते हैं जिनमें से अधिकांश प्राप्तकर्ता के पास पहले से होते हैं; bodies चेन डेटा हैं। नोड सबसे बड़ी दावा की गई ऊँचाई की ओर नहीं, बल्कि सबसे अधिक सत्यापित work की ओर सिंक करता है।

अनुक्रमिक

Producer और fold

एक proof-of-work माइनर सर्टिफिकेटों को क्रमित करता है और ब्लॉक हल करता है, या, proof of stake पर switch के बाद, उस slot के लिए ड्रॉ में चुना गया staker उस पर हस्ताक्षर करता है; हर नोड fold चलाता है, जो तुलना करता है, जोड़ता है और लिखता है। Fold का क्रम नियमों द्वारा तय है, इसलिए producer का एकमात्र विकल्प यह है कि क्या शामिल करे।

अनुक्रमिक

Forced path

open intents, जिन्हें producer अपने ब्लॉक के अंत में निष्पादित करता है। शामिल होना ही लागू होना है — यही वह तंत्र है जो नेटवर्क को किसी भी ऑपरेटर से, लेखक समेत, बचाए रखता है।