NEAR 白皮书
Statusgültigkeit und Datenverfügbarkeit
Die Kernidee bei Sharded blockchains ist, dass die meisten Teilnehmer, die bzw Durch die Nutzung des Netzwerks können Blöcke in allen Shards nicht validiert werden. Also wann immer Jeder Teilnehmer muss mit einem bestimmten Shard interagieren, was ihm im Allgemeinen nicht möglich ist Laden Sie den gesamten Verlauf des Shards herunter und validieren Sie ihn. Der Partitionierungsaspekt des Shardings birgt jedoch ein erhebliches Potenzial Problem: ohne den gesamten Verlauf einer bestimmten Datei herunterzuladen und zu validieren Shard Der Teilnehmer kann nicht unbedingt sicher sein, dass der Staat mit dem 5Dieser Abschnitt, mit Ausnahme von Unterabschnitt 2.5.3, wurde zuvor unter https://near.ai/ veröffentlicht. shard2. Wenn Sie es schon einmal gelesen haben, fahren Sie mit dem nächsten Abschnitt fort.
Ihre Interaktion ist das Ergebnis einer gültigen Folge von Blöcken und dieser Folge der Blöcke ist tatsächlich die kanonische Kette im Shard. Ein Problem, das nicht der Fall ist existieren in einem nicht fragmentierten blockchain. Wir werden zunächst eine einfache Lösung für dieses vorgeschlagene Problem vorstellen durch viele Protokolle und analysieren Sie dann, wie diese Lösung kaputt gehen kann und was Es wurden Versuche unternommen, das Problem anzugehen. 2.1 Rotation der Validatoren Die naive Lösung zur Staatsgültigkeit ist in Abbildung 5 dargestellt: Nehmen wir an, wir nehmen an dass das gesamte System in der Größenordnung von Tausenden validators hat, davon nicht mehr als 20 % sind böswillig oder werden auf andere Weise scheitern (z. B. indem sie es nicht tun). online, um einen Block zu erstellen). Wenn wir dann 200 validators abtasten, ist die Wahrscheinlichkeit von mehr als 1 3 Aus praktischen Gründen kann davon ausgegangen werden, dass der Wert null ist. Abbildung 5: Probenahme validators 1 3 ist ein wichtiger Schwellenwert. Es gibt eine Familie von Konsensprotokollen, genannt BFT Konsensprotokolle, die dies für weniger als 1 garantieren 3 von Teilnehmer scheitern, entweder durch einen Absturz oder durch ein Verhalten, das gegen die Regeln verstößt Protokoll wird der Konsens erzielt. Mit dieser Annahme ehrlicher validator Prozent, wenn der aktuelle Satz von Die naive Lösung geht davon aus, dass validators in einem Shard uns einen Block geben dass der Block gültig ist und dass er auf dem aufbaut, was die validators glaubten die kanonische Kette für diesen Shard, als sie mit der Validierung begannen. Die validators lernte die kanonische Kette aus dem vorherigen Satz von validators, die von demselben Annahme, die auf dem Block aufgebaut ist, der der Kopf der kanonischen Kette war davor. Durch Induktion ist die gesamte Kette gültig, und da keine Menge von validators An jedem Punkt, an dem Gabeln hergestellt werden, ist die naive Lösung auch sicher, dass der Strom vorhanden ist Kette ist die einzige Kette im Shard. Eine Visualisierung finden Sie in Abbildung 6.
Abbildung 6: Ein blockchain, bei dem jeder Block über einen BFT-Konsens abgeschlossen wird Diese einfache Lösung funktioniert nicht, wenn wir davon ausgehen, dass die validators möglich sind adaptiv korrumpiert, was keine unvernünftige Annahme ist6. Adaptiv Die Beschädigung eines einzelnen Shards in einem System mit 1000 Shards ist deutlich günstiger als das gesamte System zu beschädigen. Daher nimmt die Sicherheit des Protokolls linear mit der Anzahl der Shards ab. Um Gewissheit über die Gültigkeit zu haben Um einen Block zu erstellen, müssen wir wissen, dass es zu keinem Zeitpunkt in der Geschichte einen Shard im System gibt eine Mehrheit der validators konspiriert; Mit adaptiven Gegnern haben wir das nicht mehr solche Gewissheit. Wie wir in Abschnitt 1.5 besprochen haben, können konspirative validators Ausübung ausüben zwei grundlegende böswillige Verhaltensweisen: Forks erstellen und ungültige Blöcke erzeugen. Schädliche Forks können dadurch bekämpft werden, dass Blöcke mit der Beacon-Kette vernetzt werden, die im Allgemeinen für eine deutlich höhere Sicherheit ausgelegt ist die Scherbenketten. Das Erzeugen ungültiger Blöcke ist jedoch ein wesentlich größerer Aufwand herausforderndes Problem, das es zu bewältigen gilt. 2.2 Staatliche Gültigkeit Betrachten Sie Abbildung 7, in der Shard Nr. 1 beschädigt ist und ein böswilliger Akteur produziert ungültiger Block B. Angenommen, in diesem Block B wurden 1000 tokens aus dem Nichts geprägt Luft auf Alices Konto. Der böswillige Akteur erstellt dann einen gültigen Block C (in a (das Gefühl, dass die Transaktionen in C korrekt angewendet werden) auf B, was verschleiert den ungültigen Block B und initiiert eine Shard-übergreifende Transaktion zu Shard Nr. 2 überweist diese 1000 tokens auf Bobs Konto. Von diesem Moment an ist das falsch Die erstellten tokens befinden sich auf einem ansonsten vollständig gültigen blockchain in Shard Nr. 2. Einige einfache Ansätze zur Lösung dieses Problems sind: 6Lesen dies Artikel für Details auf wie adaptiv Korruption kann sein getragen aus: https://medium.com/nearprotocol/d859adb464c8. Für mehr Details auf adaptiv Korruption, lesen https://github.com/ethereum/wiki/wiki/Sharding-FAQ# Was sind die Sicherheitsmodelle, nach denen wir arbeiten?Abbildung 7: Eine Shard-übergreifende Transaktion aus einer Kette, die einen ungültigen Block hat 1. Für validators von Shard Nr. 2, um den Block zu validieren, von dem aus die Transaktion erfolgt wird eingeleitet. Dies wird auch im obigen Beispiel nicht funktionieren, da Block C scheint völlig gültig zu sein. 2. Damit validators in Shard Nr. 2 eine große Anzahl von Blöcken vor dem Block validieren, von dem aus die Transaktion initiiert wird. Natürlich, z Eine beliebige Anzahl von Blöcken N wird vom empfangenden Shard des Böswilligen validiert validators können N+1 gültige Blöcke zusätzlich zu dem ungültigen Block erstellen, den sie verwenden produziert. Eine vielversprechende Idee zur Lösung dieses Problems wäre die Anordnung von Shards in einer ungerichteter Graph, in dem jeder Shard mit mehreren anderen Shards verbunden ist, und Lassen Sie nur Cross-Shard-Transaktionen zwischen benachbarten Shards zu (z. B. so geht's). Das Sharding von Vlad Zamfir funktioniert im Wesentlichen7, und eine ähnliche Idee wird bei Kadena verwendet Chainweb [1]). Wenn eine Shard-übergreifende Transaktion zwischen Shards erforderlich ist keine Nachbarn, eine solche Transaktion wird über mehrere Shards geleitet. In diesem Design Es wird erwartet, dass ein validator in jedem Shard alle Blöcke in seinem Shard validiert sowie alle Blöcke in allen benachbarten Shards. Betrachten Sie die folgende Abbildung mit 10 Shards, von denen jeder vier Nachbarn hat und keine zwei Shards, die mehr erfordern mehr als zwei Hops für eine Shard-übergreifende Kommunikation, wie in Abbildung 8 dargestellt. Shard Nr. 2 validiert nicht nur seine eigene blockchain, sondern auch blockchains von alle Nachbarn, einschließlich Shard #1. Wenn es sich also um einen böswilligen Akteur auf Shard Nr. 1 handelt versucht, einen ungültigen Block B zu erstellen und dann Block C darauf aufzubauen und eine Cross-Shard-Transaktion initiieren, eine solche Cross-Shard-Transaktion wird nicht durchgeführt durch, da Shard Nr. 2 die gesamte Geschichte von Shard Nr. 1 validiert hat führt dazu, dass der ungültige Block B identifiziert wird. 7Lesen Sie hier mehr über das Design: https://medium.com/nearprotocol/37e538177ed9
Abbildung 8: Eine ungültige Cross-Shard-Transaktion in einem Chainweb-ähnlichen System entdeckt werden Während das Korrumpieren eines einzelnen Shards kein brauchbarer Angriff mehr ist, ist das Korrumpieren eines Shards kein brauchbarer Angriff mehr Wenig Scherben bleiben ein Problem. In Abbildung 9 korrumpiert ein Gegner beide Shards
1 und Shard #2 führen erfolgreich eine Cross-Shard-Transaktion zu Shard #3 aus
mit Mitteln aus einem ungültigen Block B: Abbildung 9: Eine ungültige Cross-Shard-Transaktion in einem Chainweb-ähnlichen System nicht erkannt werden Shard Nr. 3 validiert alle Blöcke in Shard Nr. 2, jedoch nicht in Shard Nr. 1, und hat keine Möglichkeit, den bösartigen Block zu erkennen. Es gibt zwei Hauptrichtungen zur ordnungsgemäßen Lösung der Staatsvalidität: Fischer
und kryptografische Rechennachweise. 2.3 Fischer Die Idee hinter dem ersten Ansatz ist die folgende: Immer wenn ein Blockheader angezeigt wird wird zwischen Ketten zu irgendeinem Zweck kommuniziert (z. B. zur Vernetzung mit dem B. einer Beacon-Kette oder einer Cross-Shard-Transaktion), gibt es einen Zeitraum während womit jeder ehrliche validator einen Beweis dafür liefern kann, dass der Block ungültig ist. Da Es gibt verschiedene Konstruktionen, die sehr prägnante Beweise dafür ermöglichen, dass es sich um Blöcke handelt ungültig, sodass der Kommunikationsaufwand für die empfangenden Knoten viel geringer ist als das Erhalten eines vollständigen Blocks. Mit diesem Ansatz, solange es mindestens einen ehrlichen validator in der Shard, das System ist sicher. Abbildung 10: Fischer Dies ist der vorherrschende Ansatz (neben der Behauptung, dass das Problem nicht existiert) unter den heute vorgeschlagenen Protokollen. Dieser Ansatz hat jedoch zwei Hauptnachteile: 1. Der Herausforderungszeitraum muss für den ehrlichen validator ausreichend lang sein Um zu erkennen, dass ein Block erstellt wurde, laden Sie ihn herunter, überprüfen Sie ihn vollständig und bereiten Sie ihn vor die Challenge, wenn der Block ungültig ist. Die Einführung eines solchen Zeitraums würde verlangsamen die Cross-Shard-Transaktionen erheblich. 2. Die Existenz des Challenge-Protokolls schafft einen neuen Angriffsvektor wenn bösartige Knoten mit ungültigen Herausforderungen spammen. Eine naheliegende Lösung Dieses Problem besteht darin, die Herausforderer dazu zu bringen, einen bestimmten Betrag an tokens einzuzahlen werden zurückgegeben, wenn die Challenge gültig ist. Dies ist nur eine Teillösung, wie es heißt könnte für den Angreifer immer noch von Vorteil sein, das System zu spammen (und zu verbrennen). der Einlagen) mit ungültigen Anfechtungen, beispielsweise zur Verhinderung der gültigenHerausforderung von einem ehrlichen validator vom Durchgehen. Diese Angriffe sind sogenannte Trauerattacken. Eine Möglichkeit, den letztgenannten Punkt zu umgehen, finden Sie in Abschnitt 3.7.2. 2.4 Prägnante, nicht interaktive Wissensargumente Die zweite Lösung für die Beschädigung mehrerer Shards besteht darin, kryptografische Konstruktionen zu verwenden, mit denen man beweisen kann, dass eine bestimmte Berechnung (z. B (z. B. die Berechnung eines Blocks aus einer Reihe von Transaktionen) wurde korrekt durchgeführt. Es gibt solche Konstruktionen, z.B. zk-SNARKs, zk-STARKs und einige andere, und einige werden heute aktiv in blockchain-Protokollen für private Zahlungen verwendet, vor allem ZCash. Das Hauptproblem bei solchen Grundelementen besteht darin, dass sie sind notorisch langsam zu berechnen. Z.B. Coda-Protokoll, das zk-SNARKs verwendet Insbesondere um zu beweisen, dass alle Blöcke in blockchain gültig sind, in einem Aus den Interviews geht hervor, dass die Erstellung eines Beweises 30 Sekunden pro Transaktion dauern kann (Diese Zahl ist wahrscheinlich mittlerweile kleiner). Interessanterweise muss ein Beweis nicht von einer vertrauenswürdigen Partei berechnet werden Der Beweis bescheinigt nicht nur die Gültigkeit der Berechnung, für die er erstellt wurde, sondern auch die Gültigkeit des Beweises selbst. Daher kann die Berechnung solcher Beweise aufgeteilt werden unter einer Gruppe von Teilnehmern mit deutlich geringerer Redundanz, als es der Fall wäre notwendig, um eine vertrauenswürdige Berechnung durchzuführen. Es ermöglicht auch Teilnehmern die zk-SNARKs berechnen, um auf spezieller Hardware zu laufen, ohne die zu reduzieren Dezentralisierung des Systems. Die Herausforderungen von zk-SNARKs sind neben der Leistung: 1. Abhängigkeit von weniger erforschten und weniger bewährten kryptografischen Grundelementen; 2. „Giftiger Abfall“ – zk-SNARKs sind auf ein vertrauenswürdiges Setup angewiesen, in dem eine Gruppe vorhanden ist der Leute führt eine Berechnung durch und verwirft dann das Zwischenprodukt Werte dieser Berechnung. Wenn alle Verfahrensbeteiligten Absprachen treffen und die Zwischenwerte beibehalten, können gefälschte Beweise erstellt werden; 3. Zusätzliche Komplexität im Systemdesign; 4. zk-SNARKs funktionieren nur für eine Teilmenge möglicher Berechnungen, also ein Protokoll mit einer Turing-vollständigen smart contract-Sprache wäre dies nicht möglich SNARKs zum Beweis der Gültigkeit der Kette. 2.5 Datenverfügbarkeit Das zweite Problem, das wir ansprechen werden, ist die Datenverfügbarkeit. Im Allgemeinen Knoten Betrieb eines bestimmten blockchain sind in zwei Gruppen unterteilt: Vollständige Knoten, diejenigen, die jeden vollständigen Block herunterladen und jede Transaktion validieren, und Light Knoten, die nur Blockheader herunterladen und Merkle-Proofs für Teile verwenden des Zustands und der Transaktionen, an denen sie interessiert sind, wie in Abbildung 11 dargestellt.
Abbildung 11: Merkle-Baum Wenn nun die Mehrheit der vollständigen Knoten zusammenarbeitet, können sie einen Block erzeugen, gültig oder ungültig, und senden Sie seine hash an die Lichtknoten, geben Sie jedoch niemals den vollständigen Inhalt preis des Blocks. Es gibt verschiedene Möglichkeiten, wie sie davon profitieren können. Zum Beispiel, Betrachten Sie Abbildung 12: Abbildung 12: Problem mit der Datenverfügbarkeit Es gibt drei Blöcke: Der vorherige, A, wird von ehrlichen validators erzeugt; der Strom, B, hat validators, die konspirieren; und das nächste, C, wird ebenfalls produziert von ehrlichen validators (der blockchain ist in der unteren rechten Ecke abgebildet). Sie sind ein Händler. Die validators des aktuellen Blocks (B) empfangenen Blocks Ein aus den vorherigen validators berechneter Block, in dem Sie Geld erhalten,und habe Ihnen einen Header dieses Blocks mit einem Merkle-Beweis für den Zustand geschickt, in dem er sich befindet Sie haben Geld (oder einen Merkle-Nachweis einer gültigen Transaktion, die das Geld sendet). für dich). Im Vertrauen darauf, dass die Transaktion abgeschlossen ist, erbringen Sie den Service. Allerdings verteilen die validators niemals den gesamten Inhalt des Blocks B an irgendjemand. Daher können die ehrlichen validators von Block C den Block nicht abrufen, und sind entweder gezwungen, das System zum Stillstand zu bringen oder auf A aufzubauen, wodurch Sie als a benachteiligt werden Geldhändler. Wenn wir das gleiche Szenario auf Sharding anwenden, ergeben sich die Definitionen von vollständig und Light-Knoten gelten im Allgemeinen pro Shard: validators in jedem Shard-Download alle Blockieren Sie diesen Shard und validieren Sie jede Transaktion in diesem Shard, außer anderen Knoten im System, einschließlich derjenigen, die Snapshot-Shard-Ketten in den Status aufnehmen Beacon-Kette, laden Sie nur die Header herunter. So lauten die validators im Shard effektiv vollständige Knoten für diesen Shard, während andere Teilnehmer im System, einschließlich der Beacon-Kette, fungieren als Lichtknoten. Damit der oben besprochene Fisherman-Ansatz funktioniert, sind ehrliche validators erforderlich Sie müssen in der Lage sein, Blöcke herunterzuladen, die mit der Beacon-Kette vernetzt sind. Wenn böswillige validators einen Header eines ungültigen Blocks vernetzten (oder ihn dazu nutzten). eine Cross-Shard-Transaktion initiieren), aber niemals den Block verteilen, das ehrlich validators haben keine Möglichkeit, eine Herausforderung zu gestalten. Wir werden drei Ansätze zur Lösung dieses Problems behandeln, die sich ergänzen einander. 2.5.1 Sorgerechtsnachweise Das unmittelbarste zu lösende Problem ist, ob ein Block einmal verfügbar ist es wird veröffentlicht. Eine vorgeschlagene Idee besteht darin, so genannte Notare einzusetzen, die rotieren zwischen Shards häufiger als validators, deren einzige Aufgabe darin besteht, a herunterzuladen blockieren und bestätigen, dass sie es herunterladen konnten. Das können sie sein häufiger rotiert, da nicht der gesamte Bundesstaat heruntergeladen werden muss des Shards, im Gegensatz zu den validators, die seitdem nicht häufig rotiert werden können Sie müssen bei jeder Drehung den Status des Shards herunterladen, wie in der Abbildung dargestellt 13. Das Problem bei diesem naiven Ansatz ist, dass es unmöglich ist, ihn später zu beweisen ob der Notar den Block herunterladen konnte oder nicht, also ein Notar können sich dafür entscheiden, immer zu bestätigen, dass sie den Block auch ohne herunterladen konnten sogar versucht, es wiederzubekommen. Eine Lösung hierfür ist die Bereitstellung durch Notare einige Beweise oder eine gewisse Menge an tokens einzusetzen, die belegen, dass der Block vorhanden war heruntergeladen. Eine solche Lösung wird hier diskutiert: https://ethresear.ch/t/ 1-bit-aggregation-freundliche-custody-bonds/2236. 2.5.2 Löschcodes Wenn ein bestimmter Lichtknoten einen hash eines Blocks empfängt, um den Knoten zu erhöhen Wenn Sie sicher sind, dass der Block verfügbar ist, können Sie versuchen, einige zufällige herunterzuladen Stücke des Blocks. Dies ist keine vollständige Lösung, da es sich nicht um die Lichtknoten handelt Laden Sie gemeinsam den gesamten Block herunter, den die böswilligen Blockproduzenten auswählen können
Abbildung 13: Validatoren müssen den Status herunterladen und können daher nicht rotiert werden häufig um die Teile des Blocks zurückzuhalten, die von keinem Lichtknoten heruntergeladen wurden, Dadurch ist der Block immer noch nicht verfügbar. Eine Lösung besteht darin, eine Konstruktion namens Erasure Codes zu verwenden, um dies zu ermöglichen um den gesamten Block wiederherzustellen, auch wenn nur ein Teil des Blocks verfügbar ist, wie gezeigt auf Abbildung 14. Abbildung 14: Merkle tree basiert auf löschcodierten Daten Sowohl Polkadot als auch Ethereum Serenity haben Designs rund um diese Idee Bieten Sie Lichtknoten die Möglichkeit, einigermaßen sicher zu sein, dass die Blöcke verfügbar sind. Eine ausführliche Beschreibung des Ethereum Serenity-Ansatzes finden Sie in [2].2.5.3 Polkadots Ansatz zur Datenverfügbarkeit In Polkadot erstellt, wie in den meisten Shard-Lösungen, jeder Shard (Parachain genannt) einen Snapshot seiner Blöcke in der Beacon-Kette (Relay-Kette genannt). Angenommen, es gibt 2f + 1 validators in der Relaiskette. Die Blockproduzenten der Parachain-Blöcke, genannt Collatoren berechnen nach der Erstellung des Parachain-Blocks eine löschcodierte Version des Blocks, die aus 2f +1 Teilen besteht, sodass alle f-Teile ausreichen um den Block zu rekonstruieren. Anschließend verteilen sie einen Teil an jeden validator auf der Relaiskette. Eine bestimmte Relay-Kette validator würde sich nur an einer Relay-Kette anmelden Block, wenn sie ihren Teil für jeden Parachain-Block haben, auf den ein Snapshot erstellt wird ein solcher Relaiskettenblock. Wenn also ein Relay-Chain-Block Signaturen von 2f + 1 hat validators und solange jeweils nicht mehr als f von ihnen gegen das Protokoll verstoßen haben Der Parachain-Block kann durch Abrufen der Teile aus den validators rekonstruiert werden die dem Protokoll folgen. Siehe Abbildung 15. Abbildung 15: Datenverfügbarkeit von Polkadot 2.5.4 Langfristige Datenverfügbarkeit Beachten Sie, dass alle oben diskutierten Ansätze nur die Tatsache bestätigen, dass ein Block vorliegt wurde überhaupt veröffentlicht und ist jetzt verfügbar. Blöcke können später nicht mehr verfügbar sein Aus verschiedenen Gründen: Knoten gehen offline, Knoten löschen absichtlich historische Daten Daten und andere. Ein erwähnenswertes Whitepaper, das sich mit diesem Problem befasst, ist Polyshard [3], das Löschcodes verwendet, um Blöcke über Shards hinweg verfügbar zu machen, auch wenn es mehrere sind Shards verlieren ihre Daten vollständig. Leider erfordert ihr spezifischer Ansatz Alle Shards, um Blöcke von allen anderen Shards herunterzuladen, was unerschwinglich ist teuer. Die langfristige Verfügbarkeit ist kein so dringendes Problem: da kein Teilnehmer Es wird erwartet, dass das System in der Lage ist, alle Ketten in allen zu validieren
Shards, die Sicherheit des Shard-Protokolls muss so gestaltet sein So ist das System sicher, auch wenn einige alte Blöcke in einigen Shards beschädigt werden völlig nicht verfügbar.
状态有效性和数据可用性
分片 blockchain 的核心思想是大多数参与者操作或 使用网络无法验证所有分片中的块。因此，每当 任何参与者都需要与他们通常无法进行的特定分片进行交互 下载并验证分片的整个历史记录。 然而，分片的分区方面带来了巨大的潜力 问题：没有下载和验证特定的整个历史记录 分片参与者不一定能确定分片的状态 5 除第 2.5.3 小节外，本节先前发布于 https://near.ai/ 碎片2。如果您之前阅读过，请跳至下一部分。
它们相互作用是一些有效的块序列的结果，并且这种序列 区块确实是分片中的规范链。一个不存在的问题 存在于非分片 blockchain 中。 我们首先将针对已提出的这个问题提出一个简单的解决方案 通过许多协议，然后分析这个解决方案如何破坏以及什么 已经尝试解决这个问题。 2.1 验证者轮换 状态有效性的朴素解决方案如图 5 所示：假设我们假设 整个系统有数千个 validator 的数量级，其中 不超过 20% 是恶意的或会失败（例如未能 在线生成区块）。那么如果我们采样 200 validators，概率 超过 1 个 3 出于实际目的，失败可以假设为零。 图5： 采样 validators 1 3是一个重要的门槛。有一系列共识协议，称为 BFT 共识协议，保证只要少于 1 3 个 参与者失败了，要么是崩溃了，要么是以某种违反规则的方式行事 协议，达成共识。 假设诚实的 validator 百分比，如果当前集合 分片中的 validators 为我们提供了一些块，天真的解决方案假设 该块是有效的，并且它是建立在 validator 所认为的基础上的 当他们开始验证时该分片的规范链。 validators 从前一组 validator 中学习了规范链，它们由相同的 假设建立在作为规范链头部的区块之上 在那之前。通过归纳，整个链都是有效的，并且因为没有 validator 集合 在任何产生分叉的点，简单的解决方案也可以确定当前 chain 是分片中唯一的链。可视化见图 6。
图6： 每个区块都通过 BFT 共识最终确定的 blockchain 如果我们假设 validators 可以是 自适应地损坏，这不是一个不合理的假设6。适应性地 损坏具有 1000 个分片的系统中的单个分片的成本要低得多 而不是破坏整个系统。因此，协议的安全性随着分片数量的增加而线性下降。确定其有效性 一个区块，我们必须知道，在历史上的任何时刻，系统中都没有分片 大多数 validator 串通一气；有了适应性强的对手，我们不再有 这样的确定性。正如我们在 1.5 节中讨论的，串通 validators 可以行使 两种基本的恶意行为：创建分叉和产生无效区块。 恶意分叉可以通过与信标链交叉链接的区块来解决，信标链通常被设计为具有比信标链更高的安全性 分片链。 然而，产生无效块是一个更严重的问题。 具有挑战性的问题需要解决。 2.2 状态有效性 考虑图 7，其中 Shard #1 已损坏并且恶意行为者产生了 无效区块 B。假设在该区块 B 中，有 1000 个 token 被铸造出来 爱丽丝账户上的空气。然后，恶意行为者会生成有效的区块 C（在 感觉 C 中的交易被正确应用）在 B 之上，混淆 无效块 B，并向分片 #2 发起跨分片交易 将这 1000 个 token 转入 Bob 的帐户。从这一刻起，不当行为 创建的 token 驻留在分片 #2 中完全有效的 blockchain 上。 解决这个问题的一些简单方法是： 6阅读 这个 文章 为了 详情 上 如何 适应性 腐败 可以 是 携带 输出： https://medium.com/nearprotocol/d859adb464c8. 对于 更多 详情 上 适应性 腐败， 读 https://github.com/ethereum/wiki/wiki/Sharding-FAQ# 我们正在使用什么安全模型图7： 来自具有无效块的链的跨分片交易 1. 对于分片 #2 的 validators 来验证交易所在的块 已启动。即使在上面的例子中这也不起作用，因为块 C 似乎是完全有效的。 2. 对于分片 #2 中的 validators，验证发起交易的区块之前的大量区块。自然地，对于 由接收分片验证的任意数量的块 N 恶意 validators 可以在无效块之上创建 N+1 个有效块 产生的。 解决这个问题的一个有前途的想法是将分片排列成 无向图，其中每个分片都连接到其他几个分片，以及 只允许相邻分片之间的跨分片交易（例如，这就是 Vlad Zamfir 的分片本质上是有效的7，Kadena 的分片也使用了类似的想法 Chainweb [1])。如果分片之间需要跨分片交易 不是邻居，此类事务通过多个分片路由。在这个设计中 每个分片中的 validator 预计会验证其分片中的所有块 以及所有相邻分片中的所有块。考虑下图 有 10 个分片，每个分片有 4 个邻居，并且没有两个分片需要更多 跨分片通信的跳数少于图 8 所示。 分片 #2 不仅验证其自己的 blockchain，还验证 blockchain 所有邻居，包括 1 号分片。因此，如果 Shard #1 上有恶意行为者 试图创建一个无效的块 B，然后在其上构建块 C 并发起跨分片交易，这样的跨分片交易不会走 自从分片 #2 将验证分片 #1 的整个历史以来， 会导致它识别无效的块B。 7在此处阅读有关设计的更多信息：https://medium.com/nearprotocol/37e538177ed9
图8： 类链网系统中无效的跨分片交易将 被发现 虽然破坏单个分片不再是一种可行的攻击，但破坏一个分片 碎片很少仍然是一个问题。在图 9 中，对手破坏了两个分片
1 和分片 #2 成功执行到分片 #3 的跨分片交易
来自无效区块 B 的资金： 图9： 类链网系统中无效的跨分片交易将 不被检测到 分片 #3 验证分片 #2 中的所有块，但不验证分片 #1 中的所有块，并且 无法检测恶意块。 妥善解决状态有效性有两个主要方向：
和计算的密码证明。 2.3 渔夫 第一种方法背后的想法如下：每当块头 出于任何目的（例如交叉链接到 信标链，或跨分片交易），有一段时间 任何诚实的 validator 都可以提供该块无效的证据。那里 是各种结构，可以非常简洁地证明这些块是 无效，因此接收节点的通信开销要小得多 比收到一个完整的块。 只要存在至少一个诚实的 validator ，就可以使用这种方法 分片，系统是安全的。 图10： 渔夫 这是当今提议的协议中的主要方法（除了假装问题不存在之外）。 然而，这种方法有两个 主要缺点： 1. 对于诚实的validator来说，挑战期需要足够长 识别一个块已生成，下载它，完全验证它，并准备 如果块无效则提出挑战。 引入这样一个时期将 显着减慢跨分片交易的速度。 2. 挑战协议的存在创造了新的攻击向量 当恶意节点发送带有无效挑战的垃圾邮件时。一个显而易见的解决方案 解决这个问题的方法是让挑战者存入一定数量的 token 如果挑战有效则返回。这只是部分解决方案，因为它 对于对手向系统发送垃圾邮件（并烧毁 存款）进行无效挑战，例如阻止有效的挑战来自诚实的 validator 的挑战。这些攻击是 称为悲伤攻击。 有关解决后一点的方法，请参阅第 3.7.2 节。 2.4 简洁的非交互式知识论证 多分片损坏的第二种解决方案是使用某种加密结构，允许人们证明某种计算（例如 因为从一组交易中计算一个块）被正确执行。 这种结构确实存在，例如zk-SNARKs、zk-STARKs 和其他一些， 有些目前在 blockchain 协议中积极用于私人支付， 最值得注意的是 ZCash。这些原语的主要问题是它们 众所周知，计算速度很慢。例如。 Coda 协议，使用 zk-SNARK 特别是为了证明 blockchain 中的所有块都是有效的，如 的采访表明，每笔交易可能需要 30 秒才能创建证明 （现在这个数字可能更小）。 有趣的是，证明不需要由受信任方计算，因为 该证明不仅证明了其所构建的计算的有效性，而且证明了 证明本身的有效性。因此，此类证明的计算可以分开 一组参与者之间的冗余度明显低于实际情况 执行一些无需信任的计算所必需的。它还允许参与者 他们计算 zk-SNARK 在特殊硬件上运行，而不降低 系统的去中心化。 除了性能之外，zk-SNARK 的挑战还包括： 1. 依赖于研究较少且测试较少的密码原语； 2.“有毒废物”——zk-SNARK 依赖于一个可信的设置，其中一个组 的人执行一些计算，然后丢弃中间结果 该计算的值。如果程序的所有参与者都串通 并保留中间值，可以创建假证明； 3. 系统设计引入额外的复杂性； 4. zk-SNARK 仅适用于可能计算的子集，因此协议 使用图灵完备的 smart contract 语言将无法使用 SNARKs 证明链的有效性。 2.5 数据可用性 我们要讨论的第二个问题是数据可用性。一般节点 操作特定的 blockchain 分为两组：完整节点， 那些下载每个完整区块并验证每笔交易的人，以及 Light 节点，仅下载区块头并使用 Merkle 证明作为部分的节点 他们感兴趣的状态和交易，如图 11 所示。
图11： 默克尔树 现在，如果大多数全节点串通，他们可以生成一个区块，有效或 无效，并将其 hash 发送到轻节点，但绝不泄露完整内容 块的。他们可以通过多种方式从中受益。例如， 考虑图 12： 图 12： 数据可用性问题 共有三个区块：前一个 A，是由诚实的 validators 产生的； 当前 B 有 validator 串通；下一个C也将被生产 由诚实的 validators 提供（blockchain 位于右下角）。 你是一个商人。当前块（B）接收块的validators 来自之前的 validator 的 A，计算出您收到资金的区块，并向您发送了该区块的标头，其中包含状态的 Merkle 证明 你有钱（或者发送这笔钱的有效交易的 Merkle 证明） 给你）。确认交易完成后，您即可提供服务。 然而，validators 永远不会将块 B 的全部内容分发给 任何人。因此，块 C 的诚实 validators 无法检索该块，并且 要么被迫停止系统，要么在 A 之上构建，剥夺你作为 金钱商人。 当我们将相同的场景应用于分片时，完整和分片的定义 轻节点通常适用于每个分片：每个分片中的 validators 每下载一次 阻止该分片并验证该分片中的每笔交易，但其他 系统中的节点，包括那些将分片链状态快照到 信标链，仅下载标头。因此分片中的 validator 是 该分片的有效完整节点，而系统中的其他参与者， 包括信标链，作为轻节点运行。 为了使我们上面讨论的渔夫方法发挥作用，诚实的validators 需要能够下载与信标链交叉链接的块。 如果恶意 validators 交叉链接无效块的标头（或使用它来 发起跨分片交易），但从未分发过区块，诚实的人 validators 无法制定挑战。 我们将介绍解决这个问题的三种方法，这些方法相互补充 彼此。 2.5.1 监护权证明 最迫切需要解决的问题是区块一次是否可用 它被出版了。 一个提议的想法是让所谓的公证人进行轮换 分片之间比 validators 更频繁，其唯一的工作就是下载 阻止并证明他们能够下载它。他们可以是 轮换更频繁，因为他们不需要下载整个状态 分片的，与 validator 不同，后者不能频繁轮换，因为它们 每次旋转时都必须下载分片的状态，如图所示 13. 这种幼稚方法的问题是无法在以后证明 公证人是否能够下载该块，因此公证人 可以选择始终证明他们能够下载该块而无需 甚至试图找回它。解决此问题的一种方法是公证人提供 一些证据或抵押一定数量的 token 来证明该区块是 下载了。这里讨论了一种这样的解决方案：https://ethresear.ch/t/ 1 位聚合友好托管债券/2236。 2.5.2 纠删码 当特定的轻节点收到一个区块的 hash 时，增加该节点的 确信该块可用，它可以尝试下载一些随机的 块的碎片。这不是一个完整的解决方案，因为除非轻节点 共同下载恶意区块生产者可以选择的整个区块
图 13： 验证者需要下载状态，因此无法轮换 经常 保留未由任何轻节点下载的块部分， 从而仍然使该块不可用。 一种解决方案是使用一种称为纠删码的结构来使其成为可能 即使只有部分块可用，也可以恢复整个块，如图所示 如图 14 所示。 图 14： Merkle tree 建立在纠删码数据之上 Polkadot 和 Ethereum Serenity 都围绕这个想法进行设计 为轻节点提供一种合理确信区块可用的方法。 Ethereum Serenity 方法在 [2] 中有详细描述。2.5.3 Polkadot 的数据可用性方法 在 Polkadot 中，与大多数分片解决方案一样，每个分片（称为平行链）将其块快照到信标链（称为中继链）。假设有 2f + 1 中继链上的 validators。平行链区块的区块生产者，称为 整理者，一旦生成了平行链区块，就计算该区块的纠删码版本，该版本由 2f +1 个部分组成，这样任何 f 个部分就足够了 重建块。然后，他们将一份零件分发给 validator 上的每个 validator 中继链。特定中继链 validator 只会在中继链上签名 块，如果它们对每个被快照的平行链块都有自己的部分 这样的中继链区块。因此，如果中继链区块具有来自 2f + 1 的签名 validators，只要不超过 f 个违反协议，每个 平行链区块可以通过从 validators 中获取部分来重建 遵循协议。见图 15。 图 15： Polkadot 的数据可用性 2.5.4 长期数据可用性 请注意，上面讨论的所有方法仅证明了以下事实：块 已全部发布，并且现已可用。块稍后可能会变得不可用 由于多种原因：节点离线、节点故意删除历史记录 数据等。 值得一提的解决此问题的白皮书是 Polyshard [3]， 它使用纠删码来使块可以跨分片使用，即使多个分片 分片完全丢失数据。不幸的是，他们的具体方法需要 所有分片从所有其他分片下载块，这是令人望而却步的 昂贵。 长期可用性并不是一个紧迫的问题：因为没有参与者 系统中预计能够验证所有链中的所有链
分片，分片协议的安全性需要这样设计 即使某些分片中的某些旧块变得如此，系统也是安全的 完全不可用。
Nightshade
3.1 Von Splitterketten bis hin zu Splitterbrocken Das Sharding-Modell mit Shard-Ketten und einer Beacon-Kette ist jedoch sehr leistungsfähig hat gewisse Komplexitäten. Insbesondere muss die Fork-Choice-Regel ausgeführt werden in jeder Kette separat, die Fork-Choice-Regel in den Shard-Ketten und das Beacon Die Kette muss unterschiedlich aufgebaut und separat getestet werden. In Nightshade modellieren wir das System als ein einzelnes blockchain, in dem jedes Der Block enthält logisch alle Transaktionen für alle Shards und ändert die Gesamtzustand aller Scherben. Physisch lädt jedoch kein Teilnehmer das herunter Vollständiger Zustand oder vollständiger logischer Block. Stattdessen nur jeder Teilnehmer des Netzwerks behält den Zustand bei, der den Shards entspricht, für die sie Transaktionen validieren, und die Liste aller Transaktionen im Block wird in physische Transaktionen aufgeteilt Chunks, ein Chunk pro Shard. Unter idealen Bedingungen enthält jeder Block genau einen Chunk pro Shard Block, der in etwa dem Modell mit Shard-Ketten entspricht, in dem die Shard-Ketten produzieren Blöcke mit der gleichen Geschwindigkeit wie die Beacon-Kette. Allerdings Aufgrund von Netzwerkverzögerungen könnten einige Chunks fehlen, also in der Praxis jeder Block enthält entweder einen oder keinen Chunk pro Shard. Einzelheiten dazu finden Sie in Abschnitt 3.3 Blöcke entstehen. Abbildung 16: Ein Modell mit Splitterketten auf der linken Seite und mit einer Kette auf der linken Seite Auf der rechten Seite sind die Blöcke in Stücke aufgeteilt
3.2 Konsens Die beiden vorherrschenden Konsensansätze in den blockchains sind heute die längste (oder schwerste) Kette, in der die Kette die meiste Arbeit oder den größten Anteil hat Es gilt als kanonisch, um es zu erstellen, und BFT, in dem für jeden Block einige Satz von validators erreichen einen BFT Konsens. In den kürzlich vorgeschlagenen Protokollen ist letzterer ein dominanterer Ansatz. da es sofortige Endgültigkeit bietet, während in der längsten Kette mehr Blöcke benötigt werden auf dem Block aufgebaut werden, um die Endgültigkeit zu gewährleisten. Oftmals für eine sinnvolle Sicherheit: Die Zeit, die benötigt wird, um eine ausreichende Anzahl von Blöcken zu erstellen, nimmt auf Reihenfolge der Stunden. Die Verwendung des BFT-Konsenses für jeden Block hat auch Nachteile, wie zum Beispiel: 1. BFT Konsens erfordert einen erheblichen Kommunikationsaufwand. Während Die jüngsten Fortschritte ermöglichen es, den Konsens in linearer Zeit in Zahlen zu erreichen der Teilnehmer (siehe z. B. [4]), ist der Overhead pro Block immer noch spürbar; 2. Es ist nicht möglich, dass alle Netzwerkteilnehmer am BFT teilnehmen. Konsens pro Block, daher erreicht normalerweise nur eine zufällig ausgewählte Teilmenge der Teilnehmer den Konsens. Eine zufällig ausgewählte Menge kann im Prinzip sein: adaptiv korrumpiert, und theoretisch kann eine Abzweigung erstellt werden. Das System Beides muss modelliert werden, um für ein solches Ereignis bereit zu sein, und somit still haben neben dem BFT-Konsens eine Fork-Choice-Regel oder sind so konzipiert, dass sie geschlossen werden in einem solchen Fall niedergeschlagen. Es ist erwähnenswert, dass einige Designs, wie z Algorand [5], reduzieren die Wahrscheinlichkeit einer adaptiven Korruption erheblich. 3. Am wichtigsten ist, dass das System blockiert, wenn 1 3 oder mehr aller Teilnehmer sind offline. Daher kann jeder vorübergehende Netzwerkfehler oder eine Netzwerkaufteilung das System vollständig zum Stillstand bringen. Im Idealfall muss das System weiterhin in der Lage sein funktionieren, solange mindestens die Hälfte der Teilnehmer online ist (am schwersten). Kettenbasierte Protokolle funktionieren auch dann weiter, wenn weniger als die Hälfte der Teilnehmer online ist, aber die Zweckmäßigkeit dieser Eigenschaft ist umstrittener innerhalb der Gemeinschaft). Ein Hybridmodell, bei dem der verwendete Konsens am stärksten ist Kette, aber einige Blöcke werden regelmäßig mit einem BFT Finalitäts-Gadget finalisiert, um die Vorteile beider Modelle beizubehalten. Solche BFT Endgültigkeits-Gadgets sind Casper FFG [6] verwendet in Ethereum 2.0 8, Casper CBC (siehe https://vitalik. ca/general/2018/12/05/cbc_casper.html) und GRANDPA (siehe https:// medium.com/polkadot-network/d08a24a021b5) verwendet in Polkadot. Nightshade verwendet den stärksten Kettenkonsens. Insbesondere wenn ein Block Der Produzent erzeugt einen Block (siehe Abschnitt 3.3), von dem er Signaturen sammeln kann andere Blockproduzenten und validators, die den vorherigen Block bestätigen. Siehe Abschnitt 3.8 für Einzelheiten, wie eine so große Anzahl von Signaturen aggregiert wird. Das Gewicht 8Sehen Sie sich auch die Whiteboard-Sitzung mit Justin Drake an, um einen detaillierten Überblick über Casper zu erhalten FFG und wie es in den GHOST-Konsens über die schwerste Kette integriert ist, finden Sie hier: https://www. youtube.com/watch?v=S262StTwkmoeines Blocks ist dann der kumulative Einsatz aller Unterzeichner, deren Unterschriften vorhanden sind im Block enthalten. Das Gewicht einer Kette ist die Summe der Blockgewichte. Zusätzlich zum schwersten Kettenkonsens verwenden wir ein Finalitäts-Gadget, das verwendet die Bescheinigungen zur Fertigstellung der Blöcke. Um die Komplexität des Systems zu reduzieren, Wir verwenden ein Finalitäts-Gadget, das die Fork-Choice-Regel in keiner Weise beeinflusst. und führt stattdessen nur zusätzliche Slashing-Bedingungen ein, so dass einmal ein Block vorhanden ist Durch das Finalitäts-Gadget finalisiert, ist eine Abzweigung unmöglich, es sei denn, es handelt sich um einen sehr großen Prozentsatz des Gesamteinsatzes wird gekürzt. Casper CBC ist so ein Endgültigkeits-Gadget, und wir derzeit Modell mit Blick auf Casper CBC. Wir arbeiten auch an einem separaten BFT-Protokoll namens TxFlow. Zur Zeit von Beim Schreiben dieses Dokuments ist unklar, ob TxFlow anstelle von Casper verwendet wird CBC. Wir stellen jedoch fest, dass die Wahl des Endgültigkeits-Gadgets weitgehend orthogonal zum Rest des Designs ist. 3.3 Blockproduktion In Nightshade gibt es zwei Rollen: Blockproduzenten und validators. Auf jeden Fall Punkt enthält das System w Blockproduzenten, w = 100 in unseren Modellen und wv validators, in unserem Modell v = 100, wv = 10.000. Das System ist Proof-of-Stake, Dies bedeutet, dass sowohl Blockproduzenten als auch validators über eine gewisse Anzahl interner verfügen Währung (bezeichnet als „tokens“) für einen Zeitraum gesperrt, der weit über den hinausgeht Zeit, die sie mit der Erfüllung ihrer Aufgaben zum Aufbau und zur Validierung der Kette verbringen. Wie bei allen Proof-of-Stake-Systemen sind nicht alle W-Blockproduzenten und nicht Alle wv validators sind unterschiedliche Entitäten, da dies nicht erzwungen werden kann. Jeder der w-Blockproduzenten und die wv validators haben jedoch eine separate Pfahl. Das System enthält n Shards, in unserem Modell ist n = 1000. Wie erwähnt in Abschnitt 3.1: In Nightshade gibt es keine Shard-Ketten, stattdessen erstellen alle Blockproduzenten und validators ein einziges blockchain, das wir als das bezeichnen Hauptkette. Der Zustand der Hauptkette ist in n Shards und jeden Block aufgeteilt Produzent und validator haben zu jedem Zeitpunkt nur eine Teilmenge von lokal heruntergeladen der Zustand, der einer Teilmenge der Shards entspricht, und nur verarbeiten und Validierung von Transaktionen, die diese Teile des Staates betreffen. Um ein Blockproduzent zu werden, sperrt ein Teilnehmer des Netzwerks einige große Blöcke Betrag von tokens (ein Einsatz). Die Wartung des Netzwerks erfolgt in Epochen, wobei eine Epoche ein Zeitraum in der Größenordnung von Tagen ist. Die Teilnehmer mit den w größten Einsätzen zu Beginn einer bestimmten Epoche sind der Block Produzenten für diese Epoche. Jedem Blockproduzenten sind SW-Shards zugewiesen (z. B sw = 40, was sww/n = 4 Blockproduzenten pro Shard ergeben würde. Der Block Der Produzent lädt den Status des Shards herunter, dem er vor der Epoche zugewiesen ist beginnt und sammelt im Laufe der Epoche Transaktionen, die sich auf diesen Shard auswirken. und wendet sie auf den Staat an. Für jeden Block b in der Hauptkette und für jeden Shard s gibt es einen davon s Blockproduzenten zugewiesen, die für die Produktion des Teils von b verantwortlich sind zur Scherbe. Der Teil von b, der sich auf Shard s bezieht, wird als Chunk bezeichnet und enthält die Liste der Transaktionen für den Shard, die in b aufgenommen werden sollen, sowie das MerkleWurzel des resultierenden Zustands. b wird letztendlich nur einen sehr kleinen Header von enthalten der Chunk, nämlich die Merkle-Wurzel aller angewendeten Transaktionen (siehe Abschnitt 3.7.1 für genaue Details) und die Merkle-Wurzel des Endzustands. Im weiteren Verlauf des Dokuments beziehen wir uns häufig auf den Blockproduzenten Das ist dafür verantwortlich, zu einem bestimmten Zeitpunkt einen Chunk für einen bestimmten Shard zu produzieren als Chunk-Produzent. Der Chunk-Produzent ist immer einer der Blockproduzenten. Die Blockproduzenten und die Chunk-Produzenten rotieren jeden Block entsprechend nach einem festen Zeitplan. Die Blockproduzenten haben einen Auftrag und produzieren wiederholt Blöcke in dieser Reihenfolge. Z.B. wenn es 100 Blockproduzenten gibt, der erste Block Der Hersteller ist für die Produktion der Blöcke 1, 101, 201 usw. verantwortlich, der zweite verantwortlich für die Produktion von 2, 102, 202 usw.). Da die Chunk-Produktion im Gegensatz zur Blockproduktion eine Wartung erfordert den Status, und für jeden Shard behalten nur sww/n-Blockproduzenten den Status bei Pro Shard rotieren dementsprechend nur die SWW/N-Blockproduzenten, um sie zu erstellen Brocken. Z.B. mit den oben genannten Konstanten mit vier zugewiesenen Blockproduzenten Jeder Shard und jeder Blockproduzent erstellt alle vier Blöcke einmal Chunks. 3.4 Sicherstellung der Datenverfügbarkeit Um die Datenverfügbarkeit sicherzustellen, verwenden wir einen ähnlichen Ansatz wie Polkadot beschrieben in Abschnitt 2.5.3. Sobald ein Blockproduzent einen Block produziert, erstellt er ihn eine löschcodierte Version davon mit einem optimalen (w, ⌊w/6 + 1⌋) Blockcode des Brocken. Anschließend senden sie einen Teil des löschcodierten Blocks (wir nennen solche Teile). Chunk-Teile oder nur Teile) an jeden Blockproduzenten. Wir berechnen einen Merkle-Baum, der alle Teile wie die Blätter und die enthält Der Header jedes Blocks enthält die Merkle-Wurzel dieses Baums. Die Teile werden über Onepart-Nachrichten an die validators gesendet. Jede solche Nachricht enthält den Chunk-Header, die Ordnungszahl des Teils und den Teilinhalt. Die Die Nachricht enthält auch die Signatur des Blockproduzenten, der sie erstellt hat Chunk und den Merkle-Pfad, um zu beweisen, dass der Teil dem Header entspricht und wird vom richtigen Blockproduzenten produziert. Sobald ein Blockproduzent einen Hauptkettenblock erhält, prüft er zunächst, ob dies der Fall ist Für jeden im Block enthaltenen Block gibt es einteilige Nachrichten. Wenn nicht, die Sperre wird erst verarbeitet, wenn die fehlenden Onepart-Nachrichten abgerufen wurden. Sobald alle einteiligen Nachrichten empfangen wurden, ruft der Blockproduzent die ab Die restlichen Teile werden von den Peers abgezogen und die Chunks rekonstruiert, die sie enthalten der Staat. Der Blockproduzent verarbeitet keinen Hauptkettenblock, wenn es sich um mindestens einen handelt Wenn ein im Block enthaltener Chunk nicht über die entsprechende Onepart-Nachricht verfügt, oder wenn für mindestens einen Shard, für den sie den Status aufrechterhalten, dies nicht der Fall ist den gesamten Block rekonstruieren. Damit ein bestimmter Block verfügbar ist, reicht es aus, dass ⌊w/6⌋+1 des Blocks Produzenten haben ihre Teile und bedienen sie. Also solange die Zahl der böswillige Akteure überschreiten nicht ⌊w/3⌋keine Kette, die mehr als einen halben Block hat Hersteller, die es bauen, können nicht verfügbare Teile haben.Abbildung 17: Jeder Block enthält einen oder keinen Chunk pro Shard und jeden Chunk ist löschcodiert. Jeder Teil des löschcodierten Blocks wird an eine bestimmte Adresse gesendet Blockproduzent über eine spezielle Onepart-Nachricht 3.4.1 Umgang mit faulen Blockproduzenten Wenn ein Blockproduzent einen Block hat, für den eine Onepart-Nachricht fehlt, wird er Vielleicht entscheiden Sie sich trotzdem dafür, ihn zu signieren, denn wenn der Block am Ende in der Kette landet, ist er es maximiert die Belohnung für den Blockproduzenten. Für den Block besteht kein Risiko Der Blockproduzent war nicht der einzige Blockproduzent, da es später unmöglich ist, zu beweisen, dass der Blockproduzent ihn nicht hatte die einteilige Nachricht. Um dies zu beheben, machen wir jeden Chunk zum Produzenten, wenn wir den Chunk erstellen Wählen Sie eine Farbe (Rot oder Blau) für jeden Teil des zukünftigen codierten Blocks und speichern Sie ihn die Bitmaske der zugewiesenen Farbe im Block, bevor er codiert wird. Jeweils ein Teil Die Nachricht enthält dann die dem Teil zugewiesene Farbe, und die Farbe wird verwendet, wenn Berechnen der Merkle-Wurzel der codierten Teile. Wenn der Chunk-Produzent abweicht Aus dem Protokoll lässt sich dies leicht beweisen, da dies bei der Merkle-Wurzel nicht der Fall ist entsprechen einteiligen Nachrichten oder den Farben in den einteiligen Nachrichten die der Merkle-Wurzel entsprechen, stimmt nicht mit der Maske im Block überein. Wenn ein Blockproduzent einen Block anmeldet, fügt er eine Bitmaske aller Blöcke hinzu rote Teile erhielten sie für die im Block enthaltenen Chunks. Veröffentlichung einer Eine falsche Bitmaske ist ein streichbares Verhalten. Wenn ein Blockproduzent keine erhalten hat Bei einer einzelnen Nachricht haben sie keine Möglichkeit, die Farbe der Nachricht zu kennen, und Daher besteht eine Wahrscheinlichkeit von 50 %, dass sie gekürzt werden, wenn sie versuchen, das Dokument blind zu unterschreiben blockieren. 3.5 Antrag auf Staatsübergang Die Chunk-Produzenten wählen lediglich aus, welche Transaktionen in den Chunk aufgenommen werden sollen Wenden Sie den Zustandsübergang nicht an, wenn sie einen Block erzeugen. Dementsprechend
Der Chunk-Header enthält die Merkle-Wurzel des merkelisierten Zustands wie zuvor Die Transaktionen im Block werden angewendet. Die Transaktionen werden nur angewendet, wenn ein vollständiger Block den Block enthält verarbeitet wird. Ein Teilnehmer bearbeitet einen Block nur, wenn 1. Der vorherige Block wurde empfangen und verarbeitet; 2. Für jeden Block behält der Teilnehmer nicht den Status bei, den er hat habe die einteilige Nachricht gesehen; 3. Für jeden Block behält der Teilnehmer den Status bei, den er hat volles Stück. Sobald der Block verarbeitet wird, für jeden Shard, für den der Teilnehmer zuständig ist behält den Zustand bei, wendet die Transaktionen an und berechnet den neuen Zustand ab dem Zeitpunkt, an dem die Transaktionen angewendet wurden, und sind danach zur Produktion bereit die Chunks für den nächsten Block, wenn sie einem Shard zugewiesen sind, da sie dies getan haben die Merkle-Wurzel des neuen merkelisierten Staates. 3.6 Shardübergreifende Transaktionen und Belege Wenn eine Transaktion mehr als einen Shard betreffen muss, muss sie nacheinander erfolgen wird in jedem Shard separat ausgeführt. Die vollständige Transaktion wird an den ersten Shard gesendet betroffen, und sobald die Transaktion im Chunk für diesen Shard enthalten ist, und Wird angewendet, nachdem der Block in einen Block eingefügt wurde, wird eine sogenannte Quittung generiert Transaktion, die an den nächsten Shard weitergeleitet wird, in dem die Transaktion ausgeführt werden muss ausgeführt werden. Wenn weitere Schritte erforderlich sind, erfolgt die Ausführung der Empfangstransaktion generiert eine neue Belegtransaktion und so weiter. 3.6.1 Lebensdauer der Quittungstransaktion Es ist wünschenswert, dass die Empfangstransaktion in dem Block angewendet wird, der unmittelbar auf den Block folgt, in dem sie generiert wurde. Die Quittungstransaktion ist nur generiert, nachdem der vorherige Block empfangen und von Blockproduzenten angewendet wurde die den ursprünglichen Shard verwalten und zum Zeitpunkt des bekannt sein müssen Der Block für den nächsten Block wird von den Blockproduzenten des Ziels erstellt Scherbe. Daher muss der Empfang vom Quell-Shard an den übermittelt werden Ziel-Shard in dem kurzen Zeitrahmen zwischen diesen beiden Ereignissen. Sei A der zuletzt produzierte Block, der eine Transaktion t enthält, die eine Quittung r generiert. Sei B der nächste produzierte Block (d. h. ein Block, der A als hat). sein vorheriger Block), den wir r enthalten wollen. Lass es in der Scherbe a und r sein in der Scherbe b. Die Lebensdauer des Belegs, ebenfalls in Abbildung 18 dargestellt, ist wie folgt: Erstellen und Aufbewahren der Belege. Der Chunk-Produzenten-CPA für Shard a empfängt den Block A, wendet die Transaktion t an und generiert die Quittung r. cpa Anschließend speichert es alle derart erstellten Belege in seinem indizierten internen persistenten Speicher nach der Quell-Shard-ID.Verteilen der Quittungen. Sobald CPA bereit ist, den Chunk zu produzieren Wenn Sie Shard a für Block B verwenden, rufen sie alle Belege ab, die durch die Anwendung der Transaktionen von Block A für Shard a generiert wurden, und fügen sie in den Block für Shrad ein a in Block B. Sobald ein solcher Block generiert ist, erzeugt cpa seinen Löschcode Version und alle zugehörigen Onepart-Nachrichten. cpa weiß, welche Blockproduzenten den vollständigen Status für welche Shards beibehalten. Für einen bestimmten Blockproduzenten bp cpa umfasst die Einnahmen, die aus der Anwendung von Transaktionen in Block A resultierten für Shard a, der einen der Shards hat, die bp als Ziel interessieren in der einteiligen Nachricht, als sie den Block für Shard a in Block B verteilten (siehe Abbildung 17, die die in der Onepart-Nachricht enthaltenen Quittungen zeigt). Erhalt der Quittungen. Denken Sie daran, dass die Teilnehmer (sowohl Blockproduzenten als auch validators) Blöcke erst verarbeiten, wenn sie einteilige Nachrichten haben für jeden im Block enthaltenen Block. Wenn also ein bestimmter Teilnehmer den Block B anwendet, verfügt er über alle entsprechenden Onepart-Nachrichten Chunks in B, und somit verfügen sie über alle eingehenden Belege, die die Shards enthalten Der Teilnehmer behält den Status als Ziel bei. Bei der Anwendung der Beim Zustandsübergang für einen bestimmten Shard wendet der Teilnehmer beide Quittungen an dass sie für den Shard in den Onepart-Nachrichten sowie allen gesammelt haben die im Chunk selbst enthaltenen Transaktionen. Abbildung 18: Die Lebensdauer einer Empfangstransaktion 3.6.2 Umgang mit zu vielen Belegen Es ist möglich, dass die Anzahl der Belege, die auf einen bestimmten Shard in einem abzielen Ein bestimmter Block ist zu groß, um verarbeitet zu werden. Betrachten Sie zum Beispiel Abbildung 19, in wobei jede Transaktion in jedem Shard eine Quittung generiert, die auf Shard 1 abzielt. Bis zum nächsten Block beträgt die Anzahl der Belege, die Shard 1 verarbeiten muss vergleichbar mit der Last, die alle Scherben zusammen während der Handhabung verarbeitet haben den vorherigen Block.
Abbildung 19: Wenn alle Belege auf denselben Shard abzielen, ist dies möglicherweise nicht der Fall die Fähigkeit, sie zu verarbeiten Um dieses Problem anzugehen, verwenden wir eine Technik, die der in QuarkChain 9 verwendeten ähnelt. Konkret gilt für jeden Shard der letzte Block B und der letzte Shard darin Es wird der Block erfasst, aus dem die Belege übernommen wurden. Wenn der neue Shard ist erstellt, die Quittung wird in der Reihenfolge zuerst aus den verbleibenden Shards in B angewendet, und dann in Blöcken, die auf B folgen, bis der neue Block voll ist. Unter normal Bei ausgeglichener Belastung kommt es in der Regel zu allen Einnahmen angewendet wird (und somit wird der letzte Shard des letzten Blocks aufgezeichnet jedes Stück), aber zu Zeiten, in denen die Last nicht ausgeglichen ist, und ein bestimmtes Da Shard überproportional viele Belege erhält, ist dies mit dieser Technik möglich unter Einhaltung der Beschränkungen für die Anzahl der enthaltenen Transaktionen verarbeitet werden. Beachten Sie, dass die Verzögerung abnimmt, wenn eine solche unausgeglichene Belastung über einen längeren Zeitraum anhält Die Belegerstellung bis zur Anwendung kann unbegrenzt weiter wachsen. Eins Eine Möglichkeit, das Problem zu lösen, besteht darin, jede Transaktion zu verwerfen, die eine Quittung für a erstellt Shard, dessen Verarbeitungsverzögerung eine bestimmte Konstante überschreitet (z. B. eine Epoche). Betrachten Sie Abbildung 20. Durch Block B kann der Shard 4 nicht alle Belege verarbeiten. es verarbeitet also nur Quittungsursprünge von bis zu Shard 3 in Block A und zeichnet es auf. In Block C sind die Belege bis Shard 5 in Block B enthalten, und Dann holt der Shard bei Block D auf und verarbeitet alle verbleibenden Belege Block B und alle Belege aus Block C. 3.7 Chunks-Validierung Ein für einen bestimmten Shard erstellter Chunk (oder ein für eine bestimmte Shard-Kette im Modell mit Shard-Ketten erstellter Shard-Block) kann nur von validiert werden 9Sehen Sie sich hier die Whiteboard-Folge mit QuarkChain an: https://www.youtube.com/watch? v=opEtG6NM4x4, in dem unter anderem der Ansatz für Cross-Shard-Transaktionen diskutiert wird DingeAbbildung 20: Verzögerte Belegverarbeitung Teilnehmer, die den Staat aufrechterhalten. Sie können Blockproduzenten sein, validators, oder nur externe Zeugen, die den Status heruntergeladen und den Shard darin validiert haben in dem sie Vermögenswerte speichern. In diesem Dokument gehen wir davon aus, dass die Mehrheit der Teilnehmer nicht speichern kann der Staat für einen großen Teil der Scherben. Es ist jedoch erwähnenswert, dass es Shard-blockchains gibt, die unter der Annahme entworfen wurden, dass Die meisten Teilnehmer verfügen über die Kapazität, den Zustand zu speichern und die meisten davon zu validieren die Shards, wie zum Beispiel QuarkChain. Da nur ein Bruchteil der Teilnehmer den Status hat, den Shard zu validieren Chunks ist es möglich, adaptiv nur die Teilnehmer zu korrumpieren, die das haben Zustand ändern und einen ungültigen Zustandsübergang anwenden. Es wurden mehrere Sharding-Designs vorgeschlagen, die alle paar validators abtasten Tage und innerhalb eines Tages jeder Block in der Shard-Kette, der mehr als 2/3 hat der diesem Shard zugewiesenen Signaturen der validators werden sofort berücksichtigt endgültig. Mit einem solchen Ansatz muss ein adaptiver Gegner nur 2n/3+1 korrumpieren der validators in einer Shard-Kette, um einen ungültigen Zustandsübergang anzuwenden, der, Auch wenn es wahrscheinlich schwer zu bewerkstelligen ist, ist das Sicherheitsniveau für die Öffentlichkeit nicht ausreichend blockchain. Wie in Abschnitt 2.3 besprochen, besteht der übliche Ansatz darin, nach der Erstellung eines Blocks für jeden Teilnehmer, der über den Status (ob) verfügt, ein bestimmtes Zeitfenster einzuräumen es ist ein Blockproduzent, ein validator oder ein externer Beobachter), um seine Gültigkeit in Frage zu stellen. Solche Teilnehmer werden Fischer genannt. Damit ein Fischer es kann Um einen ungültigen Block anzufechten, muss sichergestellt werden, dass ein solcher Block verfügbar ist sie. Die Datenverfügbarkeit in Nightshade wird in Abschnitt 3.4 erläutert. Sobald in Nightshade ein Block erstellt wurde, wurden die Chunks nicht validiert irgendjemand außer dem eigentlichen Chunk-Produzenten. Insbesondere der Blockproduzent schlug vor, dass der Block natürlich nicht den Status für die meisten Shards hatte, undkonnte die Chunks nicht validieren. Wenn der nächste Block produziert wird, enthält er Attestierungen (siehe Abschnitt 3.2) mehrerer Blockproduzenten und validators, aber da die Mehrheit der Blockproduzenten und validators den Status nicht aufrechterhalten Auch bei den meisten Shards sammelt ein Block mit nur einem ungültigen Chunk deutlich mehr als die Hälfte der Attestierungen und bleibt weiterhin am schwersten Kette. Um dieses Problem zu beheben, gestatten wir jedem Teilnehmer, den Status von beizubehalten Ein Shard, um in der Kette eine Herausforderung für jeden darin erzeugten ungültigen Chunk einzureichen Scherbe. 3.7.1 Staatliche Gültigkeitsherausforderung Sobald ein Teilnehmer feststellt, dass ein bestimmter Block ungültig ist, muss er einen Beweis dafür erbringen, dass der Block ungültig ist. Da die Mehrheit der Netzwerkteilnehmer den Zustand für den Shard, in dem sich der ungültige Chunk befindet, nicht aufrechterhalten Wenn der Beweis erstellt wird, muss er über ausreichende Informationen verfügen, um den Block zu bestätigen ungültig, ohne den Staat zu haben. Wir legen einen Grenzwert Ls für die Statusmenge (in Bytes) fest, die eine einzelne Transaktion umfasst kann kumulativ lesen oder schreiben. Jede Transaktion, die mehr als Ls berührt Zustand gilt als ungültig. Erinnern Sie sich aus Abschnitt 3.5 daran, dass der Chunk In einem bestimmten Block enthält B nur die anzuwendenden Transaktionen, jedoch nicht die neue Staatswurzel. Der im Block in Block B enthaltene Statusstamm ist der Status root, bevor Sie solche Transaktionen anwenden, aber nachdem Sie die Transaktionen angewendet haben der letzte Block im selben Shard vor dem Block B. Ein böswilliger Akteur Der Wunsch, einen ungültigen Zustandsübergang anzuwenden, würde einen falschen Zustandsstamm beinhalten in Block B entspricht das nicht der Zustandswurzel, die sich aus der Anwendung ergibt die Transaktionen im vorherigen Block. Wir erweitern die Informationen, die ein Chunk-Produzent in den Chunk einfügt. Anstatt nur den Status einzubeziehen, nachdem alle Transaktionen angewendet wurden, wird dieser stattdessen angezeigt Enthält eine Statuswurzel, nachdem jeder zusammenhängende Satz von Transaktionen angewendet wurde Lesen und schreiben Sie gemeinsam Ls Zustandsbytes. Mit diesen Informationen für die Fischer stellt eine Herausforderung dar, dass ein Zustandsübergang falsch angewendet wird reicht aus, um den ersten solchen ungültigen Zustandsstamm zu finden, und umfasst nur Ls Bytes davon Staaten, die von den Transaktionen zwischen dem letzten Stammstaat (der war) betroffen sind gültig) und die aktuelle Statuswurzel mit den Merkle-Beweisen. Dann jeder Teilnehmer kann die Transaktionen im Segment validieren und bestätigen, dass der Block vorhanden ist ungültig. Das Gleiche gilt, wenn der Blockproduzent versucht hat, lesende Transaktionen einzuschließen und mehr als Ls Statusbytes schreiben, für die Herausforderung reicht es aus, sie einzuschließen Die ersten Ls-Bytes berührt es mit den Merkle-Beweisen, was ausreichen wird Wenden Sie die Transaktionen an und bestätigen Sie, dass es einen Moment gibt, in dem ein Versuch dazu erfolgt Das Lesen oder Schreiben von Inhalten über Ls Bytes hinaus erfolgt.
3.7.2 Fischer und schnelle Cross-Shard-Transaktionen Wie in Abschnitt 2.3 besprochen, nehmen wir einmal an, dass die Shard-Chunks (oder Shard Blöcke im Modell mit Shard-Ketten) können ungültig sein und eine Herausforderung darstellen Dies wirkt sich negativ auf die Endgültigkeit und damit auf die Shard-übergreifende Kommunikation aus. In Insbesondere kann der Ziel-Shard einer Cross-Shard-Transaktion nicht sicher sein Der ursprüngliche Shard-Block oder -Block ist endgültig, bis der Herausforderungszeitraum abgelaufen ist (siehe Abbildung 21). Abbildung 21: Warten Sie den Herausforderungszeitraum ab, bevor Sie eine Quittung beantragen Die Art und Weise, es so anzugehen, dass die Cross-Shard-Transaktionen möglich sind Instantenious bedeutet, dass der Ziel-Shard nicht auf den Herausforderungszeitraum warten muss Nachdem die Quell-Shard-Transaktion veröffentlicht wurde, wenden Sie die Empfangstransaktion an sofort ausführen, aber dann den Ziel-Shard zusammen mit der Quelle zurücksetzen Shard, wenn sich später herausstellt, dass der ursprüngliche Chunk oder Block ungültig ist (siehe Abbildung). 22). Dies gilt ganz natürlich für das Nightshade-Design, in dem die Scherbe enthalten ist Ketten sind nicht unabhängig, stattdessen werden alle Shard-Blöcke veröffentlicht zusammen im selben Hauptkettenblock. Wenn sich herausstellt, dass ein Block ungültig ist, wird der Der gesamte Block mit diesem Block wird als ungültig betrachtet, ebenso alle darauf aufbauenden Blöcke oben drauf. Siehe Abbildung 23. Beide oben genannten Ansätze bieten Atomizität unter der Annahme, dass die Herausforderung besteht Der Zeitraum ist ausreichend lang. Wir verwenden den letzteren Ansatz, da die Bereitstellung schneller Cross-Shard-Transaktionen unter normalen Umständen die Unannehmlichkeiten überwiegt Der Ziel-Shard wird aufgrund eines ungültigen Zustandsübergangs in einem von ihnen zurückgesetzt die Quellsplitter, was ein äußerst seltenes Ereignis ist. 3.7.3 validators werden ausgeblendet Das Vorhandensein der Herausforderungen verringert bereits die Wahrscheinlichkeit erheblich Adaptive Korruption, da ein Block mit einem ungültigen Zustandsübergangsposten abgeschlossen werden mussAbbildung 22: Belege sofort anwenden und das Ziel zurücksetzen Kette, wenn die Quellkette einen ungültigen Block hatte Abbildung 23: Fischer-Herausforderung in Nightshade Der Herausforderungszeitraum, den der adaptive Gegner benötigt, um alle Teilnehmer zu korrumpieren die den Zustand des Shards beibehalten, einschließlich aller validators. Die Wahrscheinlichkeit eines solchen Ereignisses abzuschätzen ist äußerst komplex, da nein sharded blockchain ist schon so lange aktiv, dass ein solcher Angriff versucht werden kann. Wir argumentieren, dass die Wahrscheinlichkeit zwar äußerst gering, aber immer noch ausreichend ist groß für ein System, von dem erwartet wird, dass es mehrere Millionen Transaktionen ausführt Führen Sie ein weltweites Finanzgeschäft. Es gibt zwei Hauptgründe für diesen Glauben: 1. Die meisten validators der Proof-of-Stake-Ketten und Miner der
Der Anreiz für Proof-of-Work-Ketten besteht in erster Linie aus finanziellen Vorteilen. Wenn Ein adaptiver Gegner bietet ihnen mehr Geld als die erwartete Rendite Wenn man ehrlich vorgeht, kann man davon ausgehen, dass es viele validators gibt werde das Angebot annehmen. 2. Viele Unternehmen führen die Validierung von Proof-of-Stake-Ketten professionell durch Es wird erwartet, dass ein großer Prozentsatz der Anteile an jeder Kette liegen wird von solchen Einheiten. Die Anzahl solcher Entitäten ist für eine ausreichend klein adaptiver Gegner, um die meisten von ihnen persönlich kennenzulernen und zu haben gutes Verständnis für ihre Neigung, korrumpiert zu werden. Wir gehen einen Schritt weiter, um die Wahrscheinlichkeit der adaptiven Korruption zu verringern, indem wir verbergen, welche validators welchem Shard zugewiesen sind. Die Idee ist entfernt ähnlich der Art und Weise, wie Algorand [5] validators verbirgt. Es ist wichtig zu beachten, dass selbst wenn die validators verborgen sind, wie in Algorand oder wie unten beschrieben, ist die adaptive Korruption theoretisch immer noch möglich. Während Der adaptive Gegner kennt die Teilnehmer nicht, die erstellen oder validieren Ob ein Block oder ein Brocken, die Teilnehmer wissen selbst, dass sie etwas leisten werden eine solche Aufgabe erfüllen und einen kryptografischen Beweis dafür haben. So kann der Gegner Machen Sie ihre Korruptionsabsicht öffentlich und zahlen Sie an jeden Teilnehmer, der dies bereitstellt so ein kryptografischer Beweis. Wir stellen jedoch fest, dass der Gegner dies nicht tut Sie kennen die validators, die dem Shard zugewiesen sind, den sie beschädigen möchten haben keine andere Wahl, als ihre Absicht, einen bestimmten Shard zu beschädigen, zu verbreiten die gesamte Gemeinschaft. An diesem Punkt ist es für jeden Ehrlichen wirtschaftlich vorteilhaft Der Teilnehmer muss einen vollständigen Knoten hochfahren, der diesen Shard validiert, da ein Hoch vorliegt Wahrscheinlichkeit, dass ein ungültiger Block in diesem Shard erscheint, was eine Gelegenheit dazu darstellt Erstellen Sie eine Herausforderung und sammeln Sie die zugehörige Belohnung. Um die validators, die einem bestimmten Shard zugewiesen sind, nicht preiszugeben, tun wir dies Folgendes (siehe Abbildung 24): Verwenden Sie VRF, um die Zuweisung zu erhalten. Zu Beginn jeder Epoche validator verwendet eine VRF, um eine Bitmaske der Shards abzurufen, denen validator zugewiesen ist. Die Bitmaske jedes validator wird Sw-Bits haben (Definition siehe Abschnitt 3.3). von Sw). Der validator ruft dann den Status der entsprechenden Shards ab und Während der Epoche werden für jeden empfangenen Block die entsprechenden Blöcke validiert zu den Shards, denen validator zugewiesen ist. Melden Sie sich in Blöcken statt in Blöcken an. Da die Shard-Zuweisung verborgen ist, kann validator keine Chunks anmelden. Stattdessen wird immer das Ganze unterschrieben blockieren, sodass nicht verraten wird, welche Shards validiert werden. Insbesondere wenn validator einen Block empfängt und alle Blöcke validiert, erstellt er entweder eine Nachricht Dies bestätigt, dass alle Chunks in allen Shards, denen validator zugewiesen ist, vorhanden sind gültig (ohne in irgendeiner Weise anzugeben, um welche Shards es sich handelt) oder eine Nachricht darüber enthält einen Beweis für einen ungültigen Zustandsübergang, wenn ein Block ungültig ist. Siehe die Einzelheiten zur Aggregation solcher Nachrichten finden Sie in Abschnitt 3.8, in Abschnitt 3.7.4 die Details, wie verhindert werden kann, dass validators Nachrichten von huckepack nehmen andere validators und Abschnitt 3.7.5 für Einzelheiten zur Belohnung und Bestrafung validators, falls tatsächlich eine erfolgreiche ungültige Zustandsübergangsherausforderung stattfindet.Abbildung 24: Die validators in Nightshade verbergen 3.7.4 Commit-Reveal Eines der häufigsten Probleme mit validators besteht darin, dass ein validator das Herunterladen des Status und die tatsächliche Validierung der Chunks und Blöcke überspringen kann und stattdessen Beobachten Sie das Netzwerk, sehen Sie, was die anderen validators einreichen, und wiederholen Sie dies Nachrichten. Ein validator, der einer solchen Strategie folgt, bietet keinen Mehrwert Sicherheit für das Netzwerk, kassiert aber Belohnungen. Eine übliche Lösung für dieses Problem besteht darin, für jeden validator einen Beweis bereitzustellen dass sie den Block tatsächlich validiert haben, beispielsweise durch Bereitstellung einer eindeutigen Ablaufverfolgung Die Anwendung des Zustandsübergangs ist zwar nicht möglich, aber solche Nachweise erhöhen die Kosten erheblich der Validierung. Abbildung 25: Commit-Enthüllung
Stattdessen veranlassen wir, dass die validators zuerst auf das Validierungsergebnis übertragen werden (entweder die Nachricht, die die Gültigkeit der Chunks bestätigt, oder der Beweis einer Ungültigkeit Warten Sie einen bestimmten Zeitraum und zeigen Sie erst dann das tatsächliche Validierungsergebnis an, wie in Abbildung 25 dargestellt. Der Festschreibungszeitraum überschneidet sich nicht mit der Enthüllungszeitraum, und daher kann ein fauler validator keine ehrlichen validators kopieren. Darüber hinaus, wenn ein unehrlicher validator sich zu einer Nachricht verpflichtet hat, die dies bestätigt Gültigkeit der zugewiesenen Chunks, und mindestens ein Chunk war ungültig, sobald dies der Fall ist gezeigt, dass der Block ungültig ist, kann validator den Schrägstrich nicht vermeiden, da Wie wir in Abschnitt 3.7.5 zeigen, ist dies der einzige Weg, in einer solchen Situation nicht aufgeschlitzt zu werden besteht darin, eine Nachricht zu präsentieren, die einen Beweis für den ungültigen Zustandsübergang enthält entspricht dem Commit. 3.7.5 Umgang mit Herausforderungen Wie oben erläutert, sobald ein validator einen Block mit einem ungültigen Block empfängt, Sie bereiten zunächst einen Beweis für den ungültigen Zustandsübergang vor (siehe Abschnitt 3.7.1) und dann verpflichten Sie sich zu einem solchen Beweis (siehe 3.7.4) und offenbaren Sie nach einiger Zeit die Herausforderung. Sobald die aufgedeckte Herausforderung in einen Block aufgenommen wird, passiert Folgendes: 1. Alle Zustandsübergänge, die von dem Block aus stattgefunden haben, der die enthält ungültiger Block, bis der Block, in dem die aufgedeckte Herausforderung enthalten ist, abgerufen wird für nichtig erklärt. Der Zustand vor dem Block, der die offenbarte Herausforderung enthält gilt als derselbe wie der Zustand vor dem enthaltenen Block der ungültige Block. 2. Innerhalb einer bestimmten Zeitspanne muss jeder validator seine Bitmaske offenlegen der Shards, die sie validieren. Da die Bitmaske über ein VRF erstellt wird, wenn Sie wurden dem Shard zugewiesen, der den ungültigen Zustandsübergang „they“ hatte kann nicht umhin, es zu enthüllen. Alle validator, bei denen die Bitmaske nicht angezeigt wird Es wird davon ausgegangen, dass es dem Shard zugewiesen ist. 3. Jeder validator, der nach diesem Zeitraum dem Shard zugeordnet ist, das hat zu einem Validierungsergebnis für den Block geführt, der das enthält ungültiger Block und das ergab keinen Beweis für einen ungültigen Zustandsübergang das ihrem Commit entspricht, wird gestrichen. 4. Jeder validator erhält eine neue Shard-Zuweisung und eine neue Epoche wird geplant um nach einiger Zeit zu beginnen, die ausreicht, damit alle validators das herunterladen können Zustand, wie in Abbildung 26 dargestellt. Beachten Sie, dass die validators ab dem Moment die ihnen zugewiesenen Shards offenlegen Bis zum Beginn der neuen Epoche ist die Sicherheit des Systems verringert, da die Die Shard-Zuordnung wird enthüllt. Die Teilnehmer des Netzwerks müssen es behalten Beachten Sie dies bei der Nutzung des Netzwerks in diesem Zeitraum. 3.8 Signaturaggregation Damit ein System mit Hunderten von Shards sicher funktioniert, möchten wir Folgendes haben: Größenordnung von 10.000 oder mehr validators. Wie in Abschnitt 3.7 besprochen, wollen wir jedesAbbildung 26: Die Herausforderung meistern validator um im Durchschnitt ein Commit für eine bestimmte Nachricht und eine Signatur zu veröffentlichen einmal pro Block. Selbst wenn die Commit-Nachrichten gleich wären, wäre eine solche Aggregation möglich BLS-Signatur und deren Validierung wären unerschwinglich teuer gewesen. Aber Natürlich sind die Commit- und Reveal-Nachrichten bei allen validators nicht gleich. und daher brauchen wir eine Möglichkeit, solche Nachrichten und die Signaturen in einem zusammenzufassen Dies ermöglicht eine spätere schnelle Validierung. Der spezifische Ansatz, den wir verwenden, ist der folgende: Validatoren schließen sich Blockproduzenten an. Die Blockproduzenten sind bekannt einige Zeit vor Beginn der Epoche, da sie einige Zeit zum Herunterladen benötigen Zustand vor Beginn der Epoche, und im Gegensatz zu den validators sind es die Blockproduzenten nicht verborgen. Jeder Blockproduzent verfügt über v validator Slots. Validatoren reichen ein Off-Chain-Vorschläge an die Blockproduzenten, als einer ihrer v validators. Wenn ein Blockproduzent einen validator einschließen möchte, reicht er einen ein Transaktion, die die erste Off-Chain-Anfrage von validator enthält, und die Signatur des Blockproduzenten, die dafür sorgt, dass validator dem Blockproduzenten beitritt. Beachten Sie, dass die den Blockproduzenten zugewiesenen validators dies nicht unbedingt tun Validieren Sie dieselben Shards, für die der Blockproduzent Chunks produziert. Wenn ein validator wird angewendet, um mehrere Blockproduzenten zu verbinden, nur die Transaktion von Der erste Blockproduzent wird erfolgreich sein. Blockproduzenten sammeln Commits. Der Blockproduzent sammelt ständig die Commit- und Reveal-Nachrichten von den validators. Sobald eine bestimmte Anzahl solcher Nachrichten angesammelt ist, berechnet der Blockproduzent ein Merkle Baum dieser Nachrichten und sendet an jeden validator die Merkle-Wurzel und die Merkle Weg zu ihrer Botschaft. Der validator validiert den Pfad und meldet sich an die Merkle-Wurzel. Der Blockproduzent sammelt dann eine BLS-Signatur auf dem Merkle Root aus den validators und veröffentlicht nur die Merkle Root und die gesammelte Unterschrift. Der Blockproduzent unterzeichnet auch die Gültigkeit des Multisignatur mit einer günstigen ECDSA-Signatur. Wenn die Multisignatur dies nicht tut Wenn Sie mit dem übermittelten Merkle-Stamm oder der Bitmaske der teilnehmenden validators übereinstimmen, handelt es sich um ein streichbares Verhalten. Beim Synchronisieren der Kette ein Teilnehmer Sie können wählen, ob alle BLS-Signaturen der validators validiert werden sollen (was extrem teuer ist, da die öffentlichen Schlüssel der validators aggregiert werden müssen) oder nurdie ECDMA-Signaturen von den Blockproduzenten und verlassen sich darauf, dass die Der Blockproduzent wurde nicht angefochten und gekürzt. Verwendung von On-Chain-Transaktionen und Merkle-Beweisen für Herausforderungen. Es Es kann festgestellt werden, dass es keinen Wert hat, Nachrichten von validators preiszugeben, wenn nein Es wurde ein ungültiger Zustandsübergang erkannt. Nur die Nachrichten, die das tatsächliche enthalten Beweise für einen ungültigen Zustandsübergang müssen offengelegt werden, und zwar nur für solche Nachrichten Es muss gezeigt werden, dass sie mit dem vorherigen Commit übereinstimmen. Die Nachricht muss zu zwei Zwecken offengelegt werden: 1. Um den Rollback der Kette tatsächlich auf den Moment vor dem einzuleiten ungültiger Zustandsübergang (siehe Abschnitt 3.7.5). 2. Um zu beweisen, dass der validator nicht versucht hat, die Gültigkeit des zu bestätigen Ungültiger Block. In beiden Fällen müssen wir uns mit zwei Problemen befassen: 1. Der eigentliche Commit war nicht in der Kette enthalten, sondern nur die Merkle-Wurzel des Commit aggregiert mit anderen Nachrichten. Der validator muss das verwenden Merkle-Pfad, der vom Blockproduzenten bereitgestellt wird, und dessen ursprüngliches Commit beweisen, dass sie sich der Herausforderung gestellt haben. 2. Es ist möglich, dass alle dem Shard zugewiesenen validators ungültig sind Zustandsübergänge werden zufällig beschädigten Blockproduzenten zugewiesen zensieren sie. Um dies zu umgehen, erlauben wir ihnen, ihre Enthüllungen einzureichen als reguläre Transaktion in der Kette und umgeht die Aggregation. Letzteres ist nur für die Nachweise eines ungültigen Zustandsübergangs zulässig äußerst selten und sollte daher nicht zum Spam der Blöcke führen. Das letzte Problem, das angegangen werden muss, besteht darin, dass die Blockproduzenten dies können sich dafür entscheiden, nicht an der Nachrichtenaggregation teilzunehmen oder bestimmte validators absichtlich zu zensieren. Wir machen es wirtschaftlich unvorteilhaft, indem wir den Block herstellen Produzentenbelohnung proportional zur Anzahl der ihnen zugewiesenen validators. Wir Beachten Sie auch, dass sich die Blockproduzenten zwischen den Epochen weitgehend überschneiden (seit Es sind immer die Top-W-Teilnehmer mit dem höchsten Einsatz), die validators können Bleiben Sie weitgehend bei der Zusammenarbeit mit denselben Blockproduzenten und reduzieren Sie so das Risiko dass sie einem Blockproduzenten zugewiesen wurden, der sie in der Vergangenheit zensiert hat. 3.9 Snapshots-Kette Da die Blöcke in der Hauptkette sehr häufig produziert werden, ist das Herunterladen erforderlich Die vollständige Historie könnte sehr schnell teuer werden. Darüber hinaus seit jedem Block eine BLS-Signatur einer großen Anzahl von Teilnehmern enthält, allein die Aggregation der öffentlichen Schlüssel zur Überprüfung der Signatur könnte unerschwinglich werden auch teuer. Schließlich wird Ethereum 1.0 in absehbarer Zukunft wahrscheinlich einer bleiben einer der am häufigsten verwendeten blockchains und bietet eine sinnvolle Möglichkeit, Vermögenswerte von dort zu übertragen
In der Nähe von Ethereum ist eine Anforderung, und heute ist die Überprüfung von BLS-Signaturen erforderlich, um dies sicherzustellen Die Gültigkeit naher Blöcke auf der Seite von Ethereum ist nicht möglich. Jeder Block in der Nightshade-Hauptkette kann optional einen Schnorr enthalten Multisignatur im Header des letzten Blocks, der einen solchen Schnorr enthielt Multisignatur. Wir nennen solche Blöcke Snapshot-Blöcke. Der allererste Block von Jede Epoche muss ein Snapshot-Block sein. Während ich an einer solchen Multisignatur arbeitete, Die Blockproduzenten müssen auch die BLS-Signaturen der validators sammeln auf dem letzten Snapshot-Block und aggregieren Sie sie auf die gleiche Weise wie in beschrieben Abschnitt 3.8. Da die Menge der Blockproduzenten während der gesamten Epoche konstant ist, ist eine Validierung erforderlich Nur die ersten Snapshot-Blöcke in jeder Epoche sind ausreichend, vorausgesetzt, dass bei Nr weisen darauf hin, dass ein großer Prozentsatz der Blockproduzenten und validators zusammengearbeitet und erstellt haben eine Gabel. Der erste Block der Epoche muss für die Berechnung ausreichende Informationen enthalten die Blockproduzenten und validators für die Epoche. Wir nennen die Unterkette der Hauptkette, die nur den Snapshot enthält blockiert eine Snapshot-Kette. Das Erstellen einer Schnorr-Multisignatur ist ein interaktiver Prozess, aber da wir Es muss nur selten durchgeführt werden, egal wie ineffizient der Prozess ist wird genügen. Die Schnorr-Multisignaturen können einfach unter Ethereum validiert werden, Dadurch werden entscheidende Grundelemente für eine sichere Durchführung von Cross-blockchain bereitgestellt. Kommunikation. Für die Synchronisierung mit der Near-Kette muss lediglich der gesamte Snapshot heruntergeladen werden blockiert und bestätigt, dass die Schnorr-Signaturen korrekt sind (optional auch Überprüfung der einzelnen BLS-Signaturen der validators) und dann nur die Synchronisierung Hauptkettenblöcke vom letzten Snapshot-Block.
Nightshade
3.1 从分片链到分片块 具有分片链和信标链的分片模型非常强大，但是 具有一定的复杂性。特别需要执行分叉选择规则 分别在每个链中，分片链和信标中的分叉选择规则 链必须以不同的方式构建并单独测试。 在 Nightshade 中，我们将系统建模为单个 blockchain，其中每个 块逻辑上包含所有分片的所有交易，并更改 所有分片的完整状态。然而，实际上，没有参与者下载 完整状态或完整逻辑块。相反，网络的每个参与者仅 维护与验证交易的分片相对应的状态，并且块中所有交易的列表被分为物理部分 块，每个分片一个块。 在理想条件下，每个块每个分片仅包含一个块 块，它大致对应于分片链的模型，其中 分片链产生区块的速度与信标链相同。然而， 由于网络延迟，某些块可能会丢失，因此实际上每个块 每个分片包含一个或零个块。有关如何操作的详细信息，请参阅第 3.3 节 块被生产出来。 图 16： 左侧有分片链且其中一条链具有 块在右侧分成块
3.2 共识 今天 blockchain 达成共识的两种主要方法是 最长（或最重）的链，其中具有最多工作量或权益的链 用于构建它被认为是规范的，并且 BFT，其中每个块都有一些 validator 组达成 BFT 共识。 在最近提出的协议中，后者是更占主导地位的方法， 因为它提供了立即的最终性，而在最长的链中需要更多的块 构建在块的顶部以确保最终性。常常为了有意义的事 安全性 构建足够数量的区块所需的时间 时间顺序。 在每个区块上使用 BFT 共识也有缺点，例如： 1. BFT 共识涉及大量的沟通。同时 最近的进展允许在线性时间内达成数量上的共识 参与者的数量（例如 [4]），每个块的开销仍然是明显的； 2. 所有网络参与者都参与BFT是不可行的 每个区块达成共识，因此通常只有随机抽样的参与者子集才能达成共识。原则上，随机采样的集合可以是： 自适应损坏，理论上可以创建分叉。系统 要么需要建模才能为此类事件做好准备，因此仍然 除了 BFT 共识之外，还有一个分叉选择规则，或者被设计为关闭 在这样的事件中。值得一提的是，有些设计，比如 Algorand [5]，显着降低自适应损坏的概率。 3. 最重要的是，如果出现以下情况，系统就会停止运行 1 所有参与者中有 3 名或以上 离线。因此，任何临时的网络故障或网络分裂都可能导致系统完全瘫痪。理想情况下，系统必须能够持续 只要至少一半的参与者在线（最重的 即使不到一半的参与者在线，基于链的协议也会继续运行，但这种属性的可取性更有争议 社区内）。 一种混合模型，其中使用的共识是某种最重的共识 链，但一些块使用 BFT 最终性小工具定期完成，保持了两种模型的优点。这样的 BFT 最终性小工具是 Casper FFG [6] 用于 Ethereum 2.0 8，Casper CBC（请参阅 https://vitalik. ca/general/2018/12/05/cbc_casper.html）和 GRANDPA（参见 https:// medium.com/polkadot-network/d08a24a021b5) 用于 Polkadot。 Nightshade 采用最重链共识。 特别是当一个块 生产者生产一个区块（参见第 3.3 节），他们可以收集签名 其他区块生产者和 validator 证明前一个区块。参见部分 3.8 了解如何聚合如此大量的签名的详细信息。重量 8另请参阅 Justin Drake 的白板会议，深入了解 Casper FFG，以及它如何与 GHOST 最重链共识集成：https://www. youtube.com/watch?v=S262StTwkmo一个区块的总权益就是所有签名者的累积权益 包含在块中。链的权重是块权重的总和。 在最重链共识之上，我们使用了一个最终性小工具，该小工具使用 完成区块的证明。为了降低系统的复杂度， 我们使用一个最终性小工具，它不会以任何方式影响分叉选择规则， 相反，只引入额外的削减条件，这样一旦一个块被 由最终性小工具最终确定，除非有很大比例，否则分叉是不可能的 总股份被削减。 Casper CBC 就是这样一个最终结果小工具，我们 目前模型考虑的是 Casper CBC。 我们还致力于一个名为 TxFlow 的独立 BFT 协议。当时 撰写本文档时，尚不清楚是否会使用 TxFlow 来代替 Casper 加拿大广播公司。然而，我们注意到，最终性小工具的选择很大程度上与设计的其余部分正交。 3.3 区块生产 在 Nightshade 中有两个角色：区块生产者和 validators。 在任何 点系统包含 w 个区块生产者，在我们的模型中 w = 100，并且 wv validators，在我们的模型中 v = 100, wv = 10, 000。该系统是权益证明系统， 这意味着区块生产者和 validators 都有一定数量的内部 货币（称为“tokens”）锁定时间远远超过 他们花时间履行构建和验证链的职责。 与所有权益证明系统一样，并非所有 w 区块生产者也不是 所有 wv validator 都是不同的实体，因为无法强制执行。每个 然而，w 区块生产者和 wv validators 确实有一个单独的 股份。 系统包含 n 个分片，在我们的模型中 n = 1000。正如中提到的 第 3.1 节，在 Nightshade 中，没有分片链，而是所有区块生产者和 validator 都在构建一个 blockchain，我们将其称为 主链。主链的状态被分成n个分片，每个区块 生产者和 validator 在任何时刻都只在本地下载了一个子集 对应于分片的某个子集的状态，并且仅处理和 验证影响状态这些部分的交易。 要成为区块生产者，网络参与者需要锁定一些大的区块 数量 tokens（股份）。网络的维护是分周期完成的， 其中纪元是一段以天为单位的时间段。 参加者 在特定时期开始时，w 最大的赌注是区块 那个时代的生产者。每个区块生产者都被分配给 sw 分片（比如 sw = 40，这将使 sww/n = 每个分片有 4 个区块生产者）。街区 生产者下载纪元之前分配给他们的分片的状态 开始，并在整个纪元中收集影响该分片的交易， 并将它们应用到国家。 对于主链上的每个区块 b 和每个分片 s，都有一个 将区块生产者分配给 s，s 负责生产与 b 相关的部分 到碎片。 b 中与 shard s 相关的部分称为 chunk，包含 b 中包含的分片交易列表以及 merkle结果状态的根。 b 最终只会包含一个非常小的标头 块，即所有应用交易的 Merkle 根（参见部分 3.7.1 了解具体细节），以及最终状态的 merkle 根。 在文档的其余部分中，我们经常提到区块生产者 负责在特定时间为特定分片生成块 作为块生产者。区块生产者始终是区块生产者之一。 块生产者和块生产者根据以下方式轮换每个块： 到固定的时间表。区块生产者有订单并重复生产 按该顺序块。 例如。 如果有 100 个区块生产者，则第一个区块 生产者负责生产区块 1、101、201 等，第二个是 负责生产2、102、202等）。 由于块生产与块生产不同，需要维护 状态，对于每个分片，只有 sww/n 块生产者维护状态 每个分片，相应地只有那些 sww/n 块生产者轮流创建 大块。例如。上面的常量被分配给四个区块生产者 每个分片，每个块生产者将每四个块创建一次块。 3.4 确保数据可用性 为了确保数据可用性，我们使用类似于 Polkadot 的方法 2.5.3 节中描述。一旦区块生产者产生了一个区块，他们就会创建 它的纠删码版本，具有最佳 (w, ⌊w/6 + 1⌋) 块代码 块。 然后，他们发送一块纠删码块（我们称这些块为 块部分，或只是部分）到每个块生产者。 我们计算一棵默克尔树，其中包含作为叶子的所有部分，并且 每个块的标头包含该树的默克尔根。 这些部件通过 onepart 消息发送到 validators。每一条这样的消息 包含块头、部分序号和部分内容。的 消息还包含产生该区块的区块生产者的签名 chunk 和merkle路径来证明该部分对应于header 并由适当的区块生产者生产。 一旦区块生产者收到主链区块，他们首先检查是否 块中包含的每个块都有 onepart 消息。如果没有，则块 在检索到丢失的 onepart 消息之前不会进行处理。 一旦收到所有 onepart 消息，区块生产者就会获取 来自对等体的剩余部分并重建它们所持有的块 国家。 区块生产者不会处理主链区块，如果至少有一个 块中包含的块没有相应的 onepart 消息，或者如果对于至少一个分片，他们无法维护其状态 重建整个块。 对于可用的特定块，该块的 ⌊w/6⌋+1 就足够了 生产者有自己的部分并为他们服务。因此，只要数量 恶意行为者不超过⌊w/3⌋没有超过一半区块的链 构建它的生产者可能有不可用的块。图 17： 每个块包含每个分片一个或零个块，并且每个块 是擦除编码的。纠删码块的每个部分都被发送到指定的 区块生产者通过特殊的 onepart 消息 3.4.1 对付懒惰的区块生产者 如果区块生产者有一个区块缺少 onepart 消息，那么他们 可能会选择仍然在其上签名，因为如果该块最终在链上 将使区块生产者的奖励最大化。区块没有风险 生产者，因为事后无法证明区块生产者没有 onepart 消息。 为了解决这个问题，我们在创建块时让每个块生成器 为未来编码块的每个部分选择一种颜色（红色或蓝色），并存储 编码之前块中指定颜色的位掩码。每一个部分 然后消息包含分配给该部件的颜色，并且在以下情况下使用该颜色 计算编码部分的默克尔根。如果块生产者偏离 从协议中，可以很容易地证明这一点，因为默克尔根不会 对应于 onepart 消息，或者 onepart 消息中的颜色 对应于merkle根将与块中的掩码不匹配。 当区块生产者签署区块时，它们会包含所有区块的位掩码 他们收到的红色部分是块中包含的块。出版一个 不正确的位掩码是一种可削减的行为。如果区块生产者还没有收到 onepart 消息，他们无法知道消息的颜色，并且 因此，如果他们试图盲目地签署协议，就有 50% 的机会被削减 块。 3.5 状态转换申请 块生产者仅选择要包含在块中的交易，但是 当它们生成块时不应用状态转换。相应地，
块头包含之前默克尔化状态的默克尔根 应用块中的事务。 仅当包含该块的完整块时才应用事务 已处理。参与者仅处理一个块，如果 1. 前一个区块被接收并处理； 2.对于每个块，参与者不维护他们拥有的状态 看到了 onepart 消息； 3. 对于每个块，参与者确实维护状态，因为他们有 完整的块。 一旦块被处理，对于参与者的每个分片 维护状态，他们应用交易并计算新状态 在应用交易后，它们就准备好生产 下一个块的块（如果它们被分配给任何分片），因为它们有 新默克尔化状态的默克尔根。 3.6 跨分片交易和收据 如果一笔交易需要影响多个分片，则需要连续进行 在每个分片中单独执行。完整的交易被发送到第一个分片 受影响，并且一旦交易包含在此类分片的块中，并且 在块包含在块中之后应用，它会生成所谓的收据 交易，即路由到交易需要的下一个分片 被处决。如果需要更多步骤，则执行收据交易 生成新的收据交易等。 3.6.1 收据交易生命周期 理想的是，收据交易应用于紧随其生成的块之后的块中。收据交易仅 区块生产者收到并应用前一个区块后生成 维护原始分片，并且需要在 下一个块的块由目的地的块生产者生成 碎片。因此，收据必须从源分片传送到 这两个事件之间的短时间内的目标分片。 令 A 为最后产生的区块，其中包含生成收据 r 的交易 t。令 B 为下一个生成的块（即具有 A 的块） 它的前一个块）我们想要包含 r。设 t 在分片 a 中，r 为 在碎片 b. 收据的生命周期（也如图 18 所示）如下： 制作并保存收据。分片的块生产者 cpa a 接收区块 A，应用交易 t 并生成收据 r。注册会计师 然后将所有此类生成的收据存储在其索引的内部持久存储中 通过源分片 ID。分发收据。一旦 cpa 准备好生成块 块 B 的分片 a，它们获取通过应用分片 a 的块 A 中的交易而生成的所有收据，并将它们包含到 shrad 的块中 块 B 中的 a。一旦生成这样的块，cpa 就会生成其纠删码 版本和所有相应的 onepart 消息。 cpa 知道哪些区块生产者维护哪些分片的完整状态。对于特定的区块生产者 bp cpa 包括在 A 块中应用交易产生的收据 对于具有 bp 关心的任何分片作为其目的地的分片 a 当他们在块 B 中分发分片 a 的块时，在 onepart 消息中 （见图 17，显示了 onepart 消息中包含的收据）。 收到收据。请记住，参与者（区块生产者和 validators）在收到 onepart 消息之前不会处理区块 对于块中包含的每个块。因此，当任何特定参与者应用块 B 时，他们拥有对应于的所有 onepart 消息 B 中的块，因此它们拥有包含分片的所有传入收据 参与者将状态维持为目的地。 当应用 特定分片的状态转换，参与者应用两个收据 他们在 onepart 消息中为分片收集的信息，以及所有 包含在块本身中的事务。 图 18： 收据交易的生命周期 3.6.2 处理过多的收据 有可能针对某个特定分片的收据数量 特定块太大而无法处理。例如，考虑图 19， 每个分片中的每笔交易都会生成一个针对分片 1 的收据。 到下一个块时，分片 1 需要处理的收据数量为 与处理时所有碎片组合处理的负载相当 前一个块。
图 19： 如果所有收据都针对同一个分片，则该分片可能没有 处理它们的能力 为了解决这个问题，我们使用了类似于 QuarkChain 9 中使用的技术。 具体来说，对于每个分片，最后一个块 B 和该分片中的最后一个分片 s 记录应用收据的块。当新分片出现时 创建后，收据首先从 B 中的剩余分片中应用， 然后在 B 之后的块中，直到新块已满。正常情况下 负载均衡的情况下，一般会导致所有收据 正在应用（因此最后一个块的最后一个分片将被记录为 每个块），但在负载不平衡的时候，以及特定的 分片收到不成比例的大量收据，这种技术使他们能够 进行处理，同时遵守所包含交易数量的限制。 请注意，如果这种不平衡负载持续较长时间，则延迟 收据创建直到应用程序可以无限期地继续增长。一 解决这个问题的方法是删除任何创建收据的交易 处理延迟超过某个常量（例如一个时期）的分片。 考虑图 20。到了区块 B，分片 4 无法处理所有收据， 因此它只处理来自区块 A 中最多分片 3 的收据，并且 记录下来。在区块 C 中，包含区块 B 中最多分片 5 的收据，并且 然后到了块 D，分片赶上了，处理所有剩余的收据 B 块和 C 块的所有收据。 3.7 块验证 为特定分片生成的块（或在具有分片链的模型中为特定分片链生成的分片块）只能由 9查看 QuarkChain 的白板片段：https://www.youtube.com/watch? v=opEtG6NM4x4，其中讨论了跨分片交易的方法等 东西图 20： 延迟收据处理 维持状态的参与者。他们可以是区块生产者，validators， 或者只是下载状态并验证分片的外部见证人 他们存储资产。 在本文档中，我们假设大多数参与者无法存储 大部分分片的状态。不过值得一提的是， 存在分片 blockchain ，其设计假设为 大多数参与者确实有能力存储状态并验证大部分 分片，例如 QuarkChain。 由于只有一小部分参与者拥有验证分片的状态 块，有可能自适应地破坏具有 状态，并应用无效的状态转换。 提出了多重分片设计，每隔几次采样 validators 天，以及一天之内分片链中任何拥有超过 2/3 的区块 立即考虑分配给此类分片的 validator 的签名 最终。通过这种方法，自适应对手只需要破坏 2n/3+1 分片链中的 validators 来应用无效状态转换，其中， 虽然可能很难实现，但对于公众来说安全水平还不够 blockchain。 正如第 2.3 节中所讨论的，常见的方法是在为任何具有状态的参与者（无论是 它是一个区块生产者、validator 或外部观察者）来挑战其有效性。这些参与者被称为渔民。为了让渔民能够 挑战无效区块，必须确保这样的区块可供使用 他们。 Nightshade 中的数据可用性将在第 3.4 节中讨论。 在 Nightshade 中，一旦生成了一个块，这些块就不会被验证 除了实际的块生产者之外的任何人。特别是，区块生产者 建议该块自然不具有大多数分片的状态，并且无法验证这些块。当下一个区块产生时，它包含多个区块生产者和 validator 的证明（参见第 3.2 节）， 但由于大多数区块生产者和 validator 不维护状态 对于大多数分片来说，只有一个无效块的区块将收集超过一半的证明，并且将继续处于最重的状态 链。 为了解决这个问题，我们允许任何维持以下状态的参与者 一个分片，用于针对该分片中产生的任何无效块在链上提交挑战 碎片。 3.7.1 状态有效性挑战 一旦参与者检测到特定块无效，他们需要提供该块无效的证明。由于大多数网络参与者不维护无效块所在分片的状态 产生后，证明需要有足够的信息来确认该块是 无状态无效。 我们设置单个事务的状态量（以字节为单位）的限制 Ls 可以累积读取或写入。任何触及 Ls 以上的交易 状态被认为是无效的。请记住 3.5 节中的块 特定区块B中仅包含要应用的交易，但不包含 新的状态根。块B中的块包含的状态根是状态 在应用此类事务之前，但在应用事务之后 块 B 之前同一分片中的最后一个块。恶意行为者 希望应用无效的状态转换将包括不正确的状态根 在块 B 中，它与应用产生的状态根不对应 前一个块中的交易。 我们扩展块生产者在块中包含的信息。 它不是只包含应用所有事务后的状态，而是 在应用每个连续的交易集之后包括一个状态根 共同读取和写入 Ls 个字节的状态。 有了这些信息对于 渔夫提出了一个挑战，即状态转换应用不正确 足以找到第一个这样的无效状态根，并且只包含 Ls 字节 受最后一个状态根（之前是 valid）和带有默克尔证明的当前状态根。那么任意参与者 可以验证段中的事务并确认该块是 无效。 类似地，如果块生产者尝试包含读取的事务 并写入超过 Ls 个字节的状态，对于挑战来说，包含就足够了 它与默克尔证明接触的第一个 Ls 字节，这足以 应用交易并确认有一个时刻尝试 读取或写入的内容超出 Ls 字节。
3.7.2 渔民和快速跨分片交易 正如 2.3 节中所讨论的，一旦我们假设分片块（或分片 具有分片链的模型中的块）可能无效并带来挑战 期间，它会对最终结果产生负面影响，从而影响跨分片通信。在 特别是，任何跨分片交易的目标分片都无法确定 在挑战期结束之前，原始分片块或块是最终的 （见图 21）。 图 21： 在申请收据之前等待挑战期 以使得跨分片交易的方式来解决这个问题 Instantinious 是指目标分片不等待挑战期 源分片交易发布后，应用收据交易 立即，然后将目标分片与源分片一起回滚 如果后来发现原始块或块无效（见图 22）。这非常自然地适用于 Nightshade 设计，其中碎片 链不是独立的，而是分片块全部发布 一起在同一个主链区块中。如果发现任何块无效， 包含该块的整个块被认为是无效的，并且构建在其上的所有块 其顶部。见图 23。 上述两种方法都提供原子性，假设挑战 周期足够长。我们使用后一种方法，因为在正常情况下提供快速的跨分片交易比 由于其中之一的状态转换无效，目标分片回滚 源碎片，这是极其罕见的事件。 3.7.3 隐藏 validators 挑战的存在已经大大降低了 自适应损坏，因为要使用无效的状态转换后完成一个块图 22： 立即应用收据并回滚目的地 链如果源链有无效块 图 23： 茄属渔夫挑战 适应性对手需要腐蚀所有参与者的挑战期 维护分片的状态，包括所有 validator。 估计此类事件的可能性极其复杂，因为没有 sharded blockchain 已经存在足够长的时间来尝试任何此类攻击。我们认为这种可能性虽然极低，但仍然足够 对于预计执行数百万笔交易的系统来说很大 经营全球金融业务。 这种信念有两个主要原因： 1. 权益证明链的大多数 validator 和矿工
工作量证明链主要受到财务上行的激励。如果 适应性强的对手为他们提供的钱多于预期回报 从诚实经营的角度来看，可以合理地预期许多 validator 将接受该提议。 2. 许多实体对权益证明链进行专业验证，并且 预计任何连锁店的大部分股权都将被 来自此类实体。此类实体的数量对于 适应性强的对手能够亲自了解他们中的大多数人并拥有 很好地理解了他们的本性被腐蚀了。 我们通过隐藏哪些 validator 分配给哪个分片，进一步降低了自适应损坏的概率。这个想法是 与 Algorand [5] 隐藏 validators 的方式非常相似。 值得注意的是，即使 validator 被隐藏，如 Algorand 中所示 或者如下所述，自适应腐败在理论上仍然是可能的。同时 适应性对手不知道将创建或验证的参与者 一个块或一个块，参与者自己确实知道他们将执行 这样的任务并有它的密码证明。 这样，对手就可以 传播他们的腐败意图，并向任何愿意提供的参与者支付费用 这样的密码学证明。然而我们注意到，由于对手不 知道分配给他们想要破坏的分片的 validator，他们 别无选择，只能将他们破坏特定分片的意图传播给 整个社区。到那时，这对任何诚实的人来说都是经济上有利的 参与者启动一个验证该分片的完整节点，因为有一个很高的 该分片中出现无效块的机会，这是一个机会 创建挑战并收集相关奖励。 为了不泄露分配给特定分片的 validator，我们这样做 如下（见图 24）： 使用 VRF 获取任务。在每个纪元的开始 validator 使用 VRF 获取分配给 validator 的分片的位掩码。 每个 validator 的位掩码将具有 Sw 位（请参阅第 3.3 节了解定义 的 Sw）。然后 validator 获取相应分片的状态，并且 在收到的每个块的纪元期间验证对应的块 分配给 validator 的分片。 对块而不是块进行签名。由于分片分配是隐藏的，因此 validator 无法在块上签名。相反，它总是在整个 块，因此不会透露它验证的分片。具体来说，当 validator 接收到一个块并验证所有块时，它要么创建一条消息 证明 validator 分配到的所有分片中的所有块都是 有效（不以任何方式表明这些分片是什么），或者一条消息 如果任何块无效，则包含无效状态转换的证明。请参阅 有关如何聚合此类消息的详细信息，请参阅第 3.8 节，有关如何聚合此类消息的详细信息，请参阅第 3.7.4 节 有关如何防止 validators 捎带消息的详细信息 其他 validators，以及第 3.7.5 节了解如何奖励和惩罚的详细信息 validators 应该成功地发生无效状态转换挑战。图 24： 将 validator 隐藏在茄属植物中 3.7.4 提交-揭示 validators 的常见问题之一是 validator 可以跳过下载状态并实际验证块和块，而是 观察网络，查看其他 validator 提交的内容并重复他们的 消息。遵循这种策略的 validator 不提供任何额外的 网络安全，但收取奖励。 此问题的常见解决方案是为每个 validator 提供一个证明 他们实际上验证了该块，例如通过提供唯一的跟踪 应用状态转换，但这样的证明显着增加了成本 的验证。 图 25： 提交-揭示
相反，我们让 validators 首先提交验证结果（或者 证明块有效性的消息，或无效证明 状态转换），等待一定的时间，然后才显示实际的验证结果，如图25所示。提交时间与 揭示期，因此懒惰的 validator 无法模仿诚实的 validator。 此外，如果不诚实的 validator 提交了一条证明 分配的块的有效性，并且至少有一个块是无效的，一旦 显示该块无效，validator 无法避免削减，因为， 正如我们在第 3.7.5 节中所示，在这种情况下不被削减的唯一方法 是呈现一条消息，其中包含无效状态转换的证明 匹配提交。 3.7.5 应对挑战 如上所述，一旦 validator 接收到带有无效块的块， 他们首先准备无效状态转换的证明（参见第 3.7.1 节），然后 致力于这样的证明（见 3.7.4），并在一段时间后揭示挑战。 一旦揭示的挑战被包含在区块中，就会发生以下情况： 1. 从包含该块的块中发生的所有状态转换 无效块，直到包含所揭示的挑战的块得到 无效。包含已揭示挑战的区块之前的状态 被认为与包含该块的块之前的状态相同 无效块。 2. 在一定的时间内，每个 validator 必须揭示其位掩码 他们验证的分片的数量。由于位掩码是通过 VRF 创建的，如果 他们被分配到具有无效状态转换的分片，他们 无法避免暴露它。任何无法显示位掩码的 validator 假设已分配给分片。 3. 在这段时间内发现分配给分片的每个 validator， 确实提交了包含以下内容的块的某些验证结果 无效块并且没有揭示无效状态转换的证明 与他们的提交相对应的内容被削减。 4. 每个validator得到一个新的分片分配，并安排一个新的epoch 一段时间后开始，足以让所有 validator 下载 状态，如图 26 所示。 请注意，从 validator 显示分配给它们的分片那一刻起 直到新纪元开始，系统的安全性都会降低，因为 分片分配被揭示。网络参与者需要保留它 在此期间使用网络时请谨记。 3.8 签名聚合 为了让拥有数百个分片的系统能够安全运行，我们希望 10、000 或更多 validator 的顺序。正如第 3.7 节中所讨论的，我们希望每个图 26： 应对挑战 validator 发布对特定消息的提交和平均签名 每个块一次。即使提交消息相同，聚合这样的 BLS 签名并对其进行验证的成本将高得令人望而却步。但是 当然，validator 中的提交和显示消息并不相同， 因此我们需要某种方法来聚合这些消息和签名 以便稍后快速验证的方式。 我们使用的具体方法如下： 验证者加入区块生产者。区块生产者是已知的 在纪元开始之前的某个时间，因为他们需要一些时间来下载 纪元开始之前的状态，与 validator 不同，区块生产者是 没有隐藏。每个区块生产者都有 v 个 validator 插槽。验证者提交 向区块生产者提出链下提案，将其纳入其 v 之一 validators。如果区块生产者希望包含 validator，他们会提交 包含来自 validator 的初始链外请求的交易，以及 区块生产者的签名，使 validator 加入区块生产者。 请注意，分配给区块生产者的 validator 不一定是 验证区块生产者为其生成块的相同分片。 如果一个 validator 申请加入多个区块生产者，仅来自 第一个区块生产者将会成功。 区块生产者收集提交。区块生产者不断收集来自 validator 的提交和显示消息。一旦累积了一定数量的此类消息，区块生产者就会计算默克尔 这些消息的树，并向每个 validator 发送 merkle 根和 他们的消息的默克尔路径。 validator 验证路径并登录 默克尔根。然后，区块生产者在区块链上累积 BLS 签名 来自 validators 的 merkle 根，并且仅发布 merkle 根和 累计签名。区块生产者还签署了该区块的有效性 使用廉价的 ECDSA 签名进行多重签名。如果多重签名没有 匹配提交的默克尔根或参与的 validator 的位掩码，这是可削减的行为。同步链时，参与者 可以选择验证来自 validators 的所有 BLS 签名（这非常昂贵，因为它涉及聚合 validators 公钥），或者仅验证来自区块生产者的 ECDMA 签名，并依赖于以下事实： 区块生产者没有受到挑战和削减。 使用链上交易和默克尔证明来应对挑战。它 可以注意到，如果没有，那么泄露来自 validators 的消息是没有价值的。 检测到无效的状态转换。仅包含实际内容的消息 需要揭示无效状态转换的证明，并且仅针对此类消息 需要证明它们与之前的提交相匹配。该消息需要 被披露有两个目的： 1. 真正启动链回滚到之前的那一刻 无效状态转换（参见第 3.7.5 节）。 2. 证明 validator 并未试图证明该信息的有效性 无效块。 无论哪种情况，我们都需要解决两个问题： 1. 实际提交并未包含在链上，仅包含在链上的merkle根 提交与其他消息聚合。 validator 需要使用 区块生产者提供的默克尔路径及其原始承诺 证明他们致力于挑战。 2. 有可能分配给无效分片的所有validator 状态转换恰好被分配给损坏的区块生产者 正在审查他们。为了解决这个问题，我们允许他们提交他们的揭露 作为链上的常规交易并绕过聚合。 后者仅适用于无效状态转换的证明，即 极其罕见，因此不应导致垃圾邮件块。 需要解决的最后一个问题是区块生产者可以 选择不参与消息聚合或故意审查特定的 validator。我们通过制作区块使其在经济上处于不利地位 生产者奖励与分配给他们的 validator 数量成正比。我们 还请注意，由于纪元之间的区块生产者很大程度上相交（因为 它始终是拥有最高赌注的前 w 参与者），validators 可以 很大程度上坚持与相同的区块生产者合作，从而降低风险 被分配给过去审查过他们的区块生产者。 3.9 快照链 由于主链上的区块产生非常频繁，因此下载 完整的历史可能很快就会变得昂贵。而且，由于每 区块包含大量参与者的 BLS 签名，仅聚合公钥来检查签名可能会变得令人望而却步 也很贵。 最后，因为在任何可预见的未来 Ethereum 1.0 可能仍然是一个 最常用的 blockchain 中，有一种有意义的方式来转移资产
要求接近 Ethereum，今天验证 BLS 签名以确保 Ethereum 一侧的近块有效性是不可能的。 Nightshade 主链中的每个区块都可以选择包含 Schnorr 包含此类 Schnorr 的最后一个块的标头上的多重签名 多重签名。我们将此类块称为快照块。第一个块 每个纪元必须是一个快照块。在研究这样的多重签名时， 区块生产者还必须累积 validator 的 BLS 签名 在最后一个快照块上，并按照与中所述相同的方式聚合它们 第 3.8 节。 由于区块生产者集在整个时期内保持不变，因此验证 假设在没有任何情况下，只有每个时期中的第一个快照块就足够了 指出很大一部分区块生产者和 validator 串通并创建 叉子。 纪元的第一个块必须包含足以计算的信息 该纪元的区块生产者和 validators。 我们称主链中只包含快照的子链为 阻止快照链。 创建 Schnorr 多重签名是一个交互式过程，但由于我们 只需要很少执行，任何流程，无论效率如何低下 就足够了。 Schnorr 多重签名可以在 Ethereum 上轻松验证， 从而为执行跨blockchain的安全方式提供关键原语 沟通。 与近链同步只需下载所有快照 块并确认 Schnorr 签名正确（也可以选择验证 validator 的各个 BLS 签名），然后仅同步 主链区块来自最后一个快照区块。
Abschluss
In diesem Dokument haben wir Ansätze zum Erstellen von Shard-blockchains und besprochen deckte mit bestehenden Ansätzen zwei große Herausforderungen ab, nämlich die Zustandsvalidität und Datenverfügbarkeit. Anschließend präsentierten wir Nightshade, ein Sharding-Design Befugnisse NEAR Protokoll. Der Entwurf ist in Arbeit. Wenn Sie Kommentare, Fragen oder Feedback haben Zu diesem Dokument gehen Sie bitte zu https://near.chat.
结论
在本文档中，我们讨论了构建分片 blockchain 的方法和 克服了现有方法的两个主要挑战，即状态有效性 和数据可用性。然后我们提出了 Nightshade，一种分片设计 赋予 NEAR 协议权力。 设计正在进行中，如果您有意见、问题或反馈 对于本文档，请转至 https://near.chat.