Das NEAR-Whitepaper

著 Alex Skidanov and Illia Polosukhin · 2019

シャーディングの基本

シャーディングへの最も単純なアプローチから始めましょう。このアプローチでは、代わりに 1 つの blockchain を実行する場合は、複数を実行し、そのようなそれぞれを blockchain と呼びます。 「シャード」。各シャードには独自の validator のセットがあります。ここと以下で使用します 一般用語「validator」は、トランザクションを検証する参加者を指し、 Proof of Work などのマイニング、または投票ベースのいずれかによってブロックを生成します。 1このセクションは以前 https://near.ai/shard1. で公開されたものです。以前に読んだことがある方は、 次のセクションに進んでください。

機構。ここでは、シャードがそれぞれのシャードと通信しないと仮定します。 その他。 この設計は単純ではありますが、シャーディングにおける最初の主要な課題の概要を説明するには十分です。 1.1 バリデーターのパーティショニングとビーコンチェーン システムが 10 個のシャードで構成されているとします。最初の課題は、それぞれの シャードには独自の validator があり、各シャードの安全性は 10 倍低くなります。 チェーン全体。したがって、X validators の非シャード チェーンがハードフォークすることを決定した場合 シャード チェーンに分割し、X validator を 10 個のシャードに分割します。各シャードは現在 X/10 validator しかなく、1 つのシャードを破損する場合は破損するだけで済みます。 validator の総数の 5.1% (51% / 10) (図 1 を参照)、 図1: validator をシャード間で分割する ここで 2 番目の点がわかります。各シャードの validator を選択するのは誰ですか? validator の 5.1% を制御しても、validator の 5.1% がすべて制御されている場合にのみ有害です。 同じシャード内にあります。 validator が検証するシャードを選択できない場合 では、validator の 5.1% を管理する参加者がすべてを取得できる可能性は非常に低いです。 validator が同じシャード内にあるため、侵害する能力が大幅に低下します。 システム。 今日のほぼすべてのシャーディング設計は、何らかのランダム性のソースに依存しています。 validator をシャードに割り当てます。 blockchain のランダム性自体は非常に難しいトピックであり、このドキュメントの範囲外です。今のところ、あると仮定しましょう 使用できるランダム性のソース。 validator の課題については、 詳細についてはセクション 2.1 を参照してください。 ランダム性と validator 割り当ての両方で、次のような計算が必要です。 特定のシャードに固有です。その計算では、事実上すべての既存の 設計には、操作の実行を担当する別の blockchain があります。 ネットワーク全体のメンテナンスに必要です。ランダムに生成するだけでなく、番号を付けてシャードに validator を割り当てると、これらの操作は多くの場合、 シャードからの更新の受信とそれらのスナップショットの取得、処理が含まれます。 Proof-of-Stake システムでのステークとスラッシュ、およびその際のシャードのリバランス 機能がサポートされています。このようなチェーンは、Ethereum ではビーコン チェーン、リレーと呼ばれます。 PolkaDot のチェーンと Cosmos の Cosmos ハブ。 このドキュメントでは、このようなチェーンをビーコン チェーンと呼びます。 ビーコン チェーンの存在は、次の興味深いトピックにつながります。 二次シャーディング。 1.2 二次シャーディング シャーディングは、数に応じて無限に拡張できるソリューションとして宣伝されることがよくあります。 ネットワーク操作に参加しているノードの数。理論的には可能ですが、 このようなシャーディング ソリューション、ビーコンの概念を持つソリューションを設計する チェーンには無限の拡張性はありません。その理由を理解するには、ビーコンが チェーンは、validators を割り当てるなど、何らかの簿記計算を行う必要があります。 シャード、またはシャード チェーン ブロックのスナップショット。これは数に比例します。 システム内のシャードの数。ビーコン チェーン自体は単一の blockchain であるため、 計算は、それを操作するノードの計算能力によって制限されます。 シャードの数は当然限られています。 ただし、シャード化されたネットワークの構造により、乗算的な効果が得られます。 ノードの改善に影響します。任意の ネットワーク内のノードの効率が向上し、 トランザクション処理時間が短縮されます。 ビーコン チェーン内のノードを含め、ネットワークを運用しているノードが、 4 倍高速になると、各シャードは 4 倍多く処理できるようになります トランザクションが増加すると、ビーコン チェーンは 4 倍のシャードを維持できるようになります。 システム全体のスループットは 4 × 4 = 16 倍に増加します — したがって、二次シャーディングという名前が付けられます。 シャードの数を正確に測定することは困難です 現在は実行可能ですが、予見可能な将来にスループットが向上する可能性は低いです。 blockchain ユーザーのニーズは二次シャーディングの制限を超えるでしょう。 このような大量のシャードを安全に運用するには膨大な数のノードが必要です これは、すべてのノードを実行しているノードの数よりも桁違いに多い可能性があります。 今日はblockchainが結合されました。 1.3 状態シャーディング これまで、正確に何が分離され、何が分離されないのかをあまり明確に定義できませんでした ネットワークがシャードに分割されるとき。具体的には、blockchain 内のノード 3 つの重要なタスクを実行します。1) トランザクションを処理するだけでなく、 また、2) 検証されたトランザクションと完了したブロックを他のノードに中継する、および 3) ネットワーク台帳全体の状態と履歴を保存します。この3つそれぞれが タスクにより、ネットワークを運用するノードに対する要件が増大します。1. トランザクションを処理する必要があるため、より多くの計算能力が必要になります。 処理されるトランザクション数の増加。 2. トランザクションとブロックを中継する必要があるため、中継されるトランザクション数の増加に伴い、より多くのネットワーク帯域幅が必要になります。 3. データを保存する必要があるため、状態が大きくなるにつれて、より多くのストレージが必要になります。重要なのは、処理能力やネットワークとは異なり、ストレージ要件はトランザクション レート (処理されるトランザクションの数) に関係なく増加することです。 1 秒あたり) は一定のままです。 上記のリストから、ストレージ要件は次のように見えるかもしれません。 時間の経過とともに増加する唯一のものであるため、最も差し迫ったもの たとえ 1 秒あたりのトランザクション数が変わらなかったとしても、実際には 今日最も差し迫った要件は計算能力です。全体の状態 この記事の執筆時点では Ethereum は 100 GB で、ほとんどのノードで簡単に管理できます。 ただし、Ethereum が処理できるトランザクションの数は約 20、つまり注文数です。 多くの実際の使用例に必要な大きさよりも小さい。 Zilliqa は、処理をシャード化しますが、ストレージはシャード化しない最もよく知られたプロジェクトです。 処理のシャーディングは、各ノードが全体を持っているため、より簡単な問題です。 状態。コントラクトが自由に他のコントラクトを呼び出し、任意のデータを読み取ることができることを意味します。 blockchain から。確実に更新するには慎重なエンジニアリングが必要です 複数のシャードから状態の同じ部分を更新しても競合しません。で これらに関して、Zilliqa は比較的単純なアプローチを採用しています2。 処理をシャーディングせずにストレージをシャーディングすることが提案されましたが、 極めて珍しい。したがって、実際にはストレージのシャーディング、つまり状態シャーディングでは、 ほとんどの場合、処理のシャーディングとネットワークのシャーディングを意味します。 実際には、状態シャーディングの下で、各シャード内のノードがそれぞれのノードを構築します。 のローカル部分のみに影響を与えるトランザクションを含む独自の blockchain そのシャードに割り当てられているグローバル状態。 したがって、validator は シャードはグローバル状態のローカル部分を保存し、実行するだけで済みます。 したがって、中継されるのは、州の一部に影響を与えるトランザクションのみです。これ パーティションは、すべての計算能力、ストレージ、およびストレージの要件を直線的に削減します。 ネットワーク帯域幅は増加しますが、データの可用性やデータの可用性などの新たな問題が生じます。 クロスシャード トランザクションについては、以下で説明します。 1.4 クロスシャードトランザクション これまで説明したシャーディング モデルはあまり役に立ちません。 シャードは相互に通信できません。複数のシャードと同等です。 独立したblockchain。シャーディングが利用できない現在でも、 さまざまな blockchain 間の相互運用性に対する大きな需要があります。 ここでは、各参加者が 1 つのシャードにのみアカウントを持っている単純な支払いトランザクションのみを考えてみましょう。から送金したい場合は、 2彼らのアプローチに関する当社の分析はここでご覧いただけます: https://medium.com/nearprotocol/ 8f9efae0ce3b同じシャード内のアカウント間でトランザクションを処理できます。 完全にそのシャード内の validator によって行われます。ただし、シャードに存在するアリスの場合は、

1 は、validators ではなく、シャード #2 に存在するボブに送金したいと考えています。

シャード #1 (ボブのアカウントに入金することはできません) または validator シャード #2 (アリスの口座から引き落とすことはできません) は、全体を処理できます。 取引。 クロスシャード トランザクションには 2 つのアプローチがあります。 • 同期: クロスシャードトランザクションを実行する必要があるときは常に、 に関連する状態遷移を含む複数のシャード内のブロック トランザクションはすべて同時に生成され、複数のシャードの validator が連携してそのようなトランザクションを実行します。3 • 非同期: 複数のシャードに影響を与えるクロスシャードトランザクション これらのシャード内で非同期に実行され、「Credit」シャードが実行されます。 「デビット」シャードがその部分を実行したという十分な証拠が得られたら、その半分を返します。このアプローチは、次の理由によりより普及する傾向があります。 シンプルさとコーディネートのしやすさ。このシステムは現在、Cosmos、Ethereum セレニティ、ニア、嘉手納などで提案されています。これに関する問題 このアプローチは、ブロックが独立して生成される場合、複数のブロックのうちの 1 つが孤立する可能性がゼロではないため、 トランザクションは部分的にのみ適用されます。 2 つの要素を描いた図 2 を考えてみましょう。 両方でフォークが発生したシャードとシャード間のトランザクション それはブロックAとX’に対応して記録されました。チェーンA-Bの場合 および V'-X'-Y'-Z' は、対応するシャード内で正規になります。 取引は完全に完了しました。 A'-B'-C'-D' と V-X が正規になった場合、 その後、トランザクションは完全に放棄されますが、これは許容されます。しかし、もし、 たとえば、A-B と V-X が正規になり、トランザクションの一部が終了し、もう 1 つは破棄され、アトミック性の障害が発生します。私たち 第 2 部では、フォーク選択ルールとコンセンサスの変更について説明する際に、提案されたプロトコルでこの問題がどのように対処されるかを説明します。 シャード化プロトコル用に提案されたアルゴリズム。 チェーン間の通信は、シャード化された blockchain の外部でも役立つことに注意してください。 も。チェーン間の相互運用性は、多くのプロジェクトが抱える複雑な問題です。 解決しようとしています。シャード化された blockchains では、問題は多少簡単になります。 ブロック構造とコンセンサスはシャード間で同じであり、調整に使用できるビーコン チェーンがあります。ただし、シャード化された blockchain では、 すべてのシャード チェーンは同じですが、グローバル blockchains エコシステムでは さまざまなターゲット ユースケース、分散化を伴うさまざまな blockchain が多数あります そしてプライバシーの保証。 一連のチェーンが異なるプロパティを持つシステムを構築しますが、 十分に類似したコンセンサスとブロック構造を使用し、共通のビーコン チェーンを使用すると、異種の blockchain のエコシステムが可能になります。 3 ほとんどの 詳しい 提案 知られている に の 著者 の これ 文書 です マージ ブロック、 説明した ここで: https://ethresear.ch/t/ マージブロックと同期クロスシャード状態実行/1240図2: 非同期クロスシャードトランザクション 動作中の相互運用性サブシステム。このようなシステムには validator 回転機能が搭載されていない可能性が高いため、セキュリティを確保するために追加の対策を講じる必要があります。両方 Cosmos と PolkaDot は実質的にそのようなシステムです4 1.5 悪意のある行為 このセクションでは、validator に悪意を与える可能性がある敵対的な動作を確認します。 シャードを破壊できた場合は、実行してください。古典的なアプローチを確認します セクション 2.1 でシャードの破損を避けるため。 1.5.1 悪意のあるフォーク 一連の悪意のある validator がフォークの作成を試みる可能性があります。そうではないことに注意してください 基礎となるコンセンサスがBFTであるかどうかは関係なく、十分な数が破損します validators を使用すると、常にフォークを作成できるようになります。 ネットワーク全体の 50% 以上が破損するよりも、単一のシャードの 50% 以上が破損する可能性が大幅に高くなります (後で説明します)。 これらの確率については、セクション 2.1 で詳しく説明します)。セクション 1.4 で説明したように、 クロスシャードトランザクションには、複数のシャードにおける特定の状態変化が含まれます。 このような状態変更を適用するシャード内の対応するブロックは、 すべて完了している(つまり、対応する選択されたチェーンに表示されている) シャード)、またはすべてが孤立する(つまり、対応するシャードの選択されたチェーンに表示されない)。一般的にシャードが破損する可能性が高いため、 4Zaki Manian によるCosmos の記事を参照してください: https://forum.cosmos.network/ t/polkadot-vs-cosmos/1397/2 と、この文書の最初の著者によるツイートの嵐: 詳細な比較については、https://twitter.com/AlexSkidanov/status/1129511266660126720 二人のうち

無視できるものではありません。シャード validator 間でビザンチン的な合意に達した場合、または多くのブロックが合意に達した場合でも、フォークが発生しないと想定することはできません。 状態の変化とともにブロックの上に生成されます。 この問題には複数の解決策がありますが、最も一般的な解決策は時折発生するものです。 最新のシャード チェーン ブロックをビーコン チェーンに架橋します。 フォーク シャード チェーンの選択ルールは、常に次のチェーンを優先するように変更されます。 クロスリンクされ、シャード固有のフォーク選択ルールのみをブロックに適用します。 最後の相互リンク以降に公開されました。 1.5.2 無効なブロックの承認 validator のセットは、状態遷移関数を誤って適用するブロックを作成しようとする可能性があります。たとえば、アリスがいる状態から始めます。 には token が 10 個あり、ボブには token が 0 個ある場合、ブロックには次のようなトランザクションが含まれる可能性があります。 アリスからボブに 10 token を送信しますが、最終的にはアリスが次の状態になります。 図 3 に示すように、0 token 個で、ボブの token 個は 1000 個です。 図3: 無効なブロックの例 従来の非シャード blockchain では、そのような攻撃は不可能です。 ネットワークの参加者はすべてのブロックを検証し、そのようなブロックは 無効な状態遷移は他のブロックプロデューサーの両方によって拒否されます。 ブロックを作成しないネットワークの参加者。たとえ悪意があったとしても、 validators は、そのような無効なブロックの上に、次の速度よりも速くブロックを作成し続けます。 正直な validator は正しいチェーンを構築するため、無効なチェーンが含まれます。 ブロックが長くても、すべての参加者が blockchain は、いかなる目的であっても、すべてのブロックを検証し、すべてのブロックを破棄します 無効なブロックの上に構築されます。 図 4 には 5 つの validator があり、そのうち 3 つは悪意のあるものです。彼らは 無効なブロック A’ を作成し、その上に新しいブロックを構築し続けました それの。 2 つの正直な validator は A' を無効として破棄し、その上に構築していました図4: 非シャード blockchain で無効なブロックを作成しようとしました 既知の最後の有効なブロックを抽出し、フォークを作成します。数が少ないので 正直フォークの validator のチェーンは短くなります。ただし、クラシックな非シャード blockchain では、目的を問わず blockchain を使用するすべての参加者は、 受信したすべてのブロックを検証し、状態を再計算する責任があります。 したがって、blockchain に興味がある人は誰でも、A’ に気づくでしょう。 は無効であるため、B'、C'、および D' もすぐに破棄されます。 チェーン A-B を現在最長の有効なチェーンとして指定します。 ただし、シャード化された blockchain では、すべてのシャード上のすべてのトランザクションを検証できる参加者はいないため、それを確認する何らかの方法が必要です。 blockchain のシャードの履歴のポイントに無効なブロックは含まれていませんでした。 フォークとは異なり、ビーコン チェーンには検証する能力がないため、ビーコン チェーンへのクロスリンクは十分な解決策ではないことに注意してください。 ブロック。そのシャード内に十分な数の validator が存在することのみを検証できます。 ブロックに署名しました (したがって、その正確性が証明されました)。 この問題の解決策については、以下のセクション 2.2 で説明します。

Sharding-Grundlagen

Beginnen wir mit dem einfachsten Sharding-Ansatz. Bei diesem Ansatz statt Wenn wir einen blockchain ausführen, werden wir mehrere ausführen und jeden solchen blockchain a nennen „Scherbe“. Jeder Shard verfügt über einen eigenen Satz von validators. Hier und unten verwenden wir ein allgemeiner Begriff „validator“, der sich auf Teilnehmer bezieht, die Transaktionen verifizieren und Produzieren Sie Blöcke, entweder durch Mining, wie zum Beispiel beim Proof of Work, oder über eine abstimmungsbasierte Methode 1Dieser Abschnitt wurde zuvor unter https://near.ai/shard1. veröffentlicht. Wenn Sie ihn schon einmal gelesen haben, Fahren Sie mit dem nächsten Abschnitt fort.

Mechanismus. Nehmen wir zunächst an, dass die Shards niemals miteinander kommunizieren andere. Obwohl dieser Entwurf einfach ist, reicht er aus, um einige erste große Herausforderungen beim Sharding zu skizzieren. 1.1 Validator-Partitionierung und Beacon-Ketten Angenommen, das System besteht aus 10 Shards. Die erste Herausforderung besteht bei jedem darin Da der Shard seine eigenen validators hat, ist jeder Shard jetzt zehnmal weniger sicher als der gesamte Kette. Wenn sich also eine nicht-shardierte Kette mit X validators für einen Hard Fork entscheidet in eine Shard-Kette und teilt X validators auf 10 Shards auf, jetzt jeden Shard hat nur X/10 validators und die Beschädigung eines Shards erfordert nur eine Beschädigung 5,1 % (51 % / 10) der Gesamtzahl der validators (siehe Abbildung 1), Abbildung 1: Aufteilen der validators auf Shards Das bringt uns zum zweiten Punkt: Wer wählt validators für jeden Shard aus? Die Kontrolle von 5,1 % der validators ist nur dann schädlich, wenn alle diese 5,1 % der validators vorhanden sind befinden sich im selben Shard. Wenn validators nicht auswählen können, welchen Shard sie validieren sollen Es ist höchst unwahrscheinlich, dass ein Teilnehmer, der 5,1 % der validators kontrolliert, alle bekommt ihre validators im selben Shard, was ihre Fähigkeit, Kompromisse einzugehen, stark einschränkt das System. Heutzutage basieren fast alle Sharding-Designs auf einer Zufallsquelle Weisen Sie Shards validators zu. Zufälligkeit bei blockchain an sich ist ein sehr herausforderndes Thema und wird in diesem Dokument nicht behandelt. Nehmen wir zunächst einmal an, dass dies der Fall ist eine Zufallsquelle, die wir nutzen können. Wir werden die Aufgabe von validators behandeln Weitere Einzelheiten finden Sie in Abschnitt 2.1. Sowohl die Zufälligkeit als auch die validator-Zuweisung erfordern eine Berechnung, die nicht erfolgt spezifisch für einen bestimmten Shard. Für diese Berechnung sind praktisch alle vorhanden Designs verfügen über einen separaten blockchain, der mit der Durchführung von Vorgängen beauftragt ist für die Aufrechterhaltung des gesamten Netzwerks notwendig. Neben der ZufallsgenerierungNummern und Zuweisen von validators zu den Shards, diese Vorgänge oft auch Dazu gehören das Empfangen von Aktualisierungen von Shards, das Erstellen von Snapshots davon und die Verarbeitung Einsätze und Kürzungen in Proof-of-Stake-Systemen und die Neuausrichtung der Shards in diesem Fall Funktion wird unterstützt. Eine solche Kette wird in Ethereum, einem Relay, als Beacon-Kette bezeichnet Kette in PolkaDot und der Cosmos Hub in Cosmos. In diesem Dokument bezeichnen wir eine solche Kette als Beacon-Kette. Die Existenz der Beacon-Kette bringt uns zum nächsten interessanten Thema, dem Quadratisches Sharding. 1.2 Quadratisches Sharding Sharding wird oft als eine Lösung beworben, die mit der Zahl unendlich skaliert der am Netzwerkbetrieb beteiligten Knoten. Obwohl es theoretisch möglich ist Entwerfen Sie eine solche Sharding-Lösung, jede Lösung, die das Konzept eines Beacons hat Die Kette ist nicht unbegrenzt skalierbar. Um zu verstehen, warum, beachten Sie, dass das Beacon Die Kette muss einige Buchhaltungsberechnungen durchführen, z. B. die Zuweisung von validators Shards oder Snapshot-Shard-Chain-Blöcke, die proportional zur Anzahl sind von Shards im System. Da die Beacon-Kette selbst eine einzelne blockchain ist, mit Berechnung, die durch die Rechenkapazitäten der Knoten, die sie betreiben, begrenzt ist, die Anzahl der Shards ist natürlich begrenzt. Die Struktur eines Sharded-Netzwerks verleiht jedoch einen Multiplikativ Auswirkungen auf alle Verbesserungen an seinen Knoten haben. Betrachten Sie den Fall, in dem ein willkürlicher Die Effizienz der Knoten im Netzwerk wird verbessert, was dies ermöglicht ihnen schnellere Transaktionsverarbeitungszeiten. Wenn die Knoten, die das Netzwerk betreiben, einschließlich der Knoten in der Beacon-Kette, Wenn die Shards viermal schneller werden, kann jeder Shard viermal mehr verarbeiten Transaktionen und die Beacon-Kette wird in der Lage sein, viermal mehr Shards zu verwalten. Der Durchsatz im gesamten System erhöht sich um den Faktor 4 × 4 = 16 – daher der Name quadratisches Sharding. Es ist schwierig, eine genaue Messung der Anzahl der Scherben zu liefern heute machbar, aber es ist unwahrscheinlich, dass der Durchsatz in absehbarer Zukunft erreicht wird Die Anforderungen der blockchain-Benutzer werden über die Einschränkungen des quadratischen Shardings hinauswachsen. Die schiere Anzahl an Knoten, die erforderlich sind, um eine solche Menge an Shards sicher zu betreiben ist wahrscheinlich um Größenordnungen höher als die Anzahl der Knoten, die insgesamt betrieben werden blockchains heute zusammen. 1.3 State-Sharding Bisher haben wir nicht genau definiert, was genau getrennt ist und was nicht wenn ein Netzwerk in Shards unterteilt ist. Insbesondere Knoten im blockchain erfüllen drei wichtige Aufgaben: Sie verarbeiten nicht nur 1) Transaktionen, sie außerdem 2) validierte Transaktionen und abgeschlossene Blöcke an andere Knoten weiterleiten und 3) Speichern Sie den Status und den Verlauf des gesamten Netzwerk-Ledgers. Jeder dieser drei Aufgaben stellen eine wachsende Anforderung an die Knoten dar, die das Netzwerk betreiben:1. Die Notwendigkeit, Transaktionen zu verarbeiten, erfordert mehr Rechenleistung die erhöhte Anzahl der verarbeiteten Transaktionen; 2. Die Notwendigkeit, Transaktionen und Blöcke weiterzuleiten, erfordert mehr Netzwerkbandbreite mit der zunehmenden Anzahl weitergeleiteter Transaktionen; 3. Die Notwendigkeit, Daten zu speichern, erfordert mit dem Wachstum des Staates mehr Speicherplatz. Wichtig ist, dass im Gegensatz zur Rechenleistung und zum Netzwerk der Speicherbedarf wächst, selbst wenn die Transaktionsrate (Anzahl der verarbeiteten Transaktionen) steigt pro Sekunde) bleibt konstant. Aus der obigen Liste könnte es scheinen, dass der Speicherbedarf hoch wäre am dringendsten, da es das einzige ist, das im Laufe der Zeit erhöht wird Auch wenn sich die Anzahl der Transaktionen pro Sekunde nicht ändert, aber in der Praxis Die dringendste Anforderung ist heute die Rechenleistung. Der gesamte Staat Ethereum ist zum jetzigen Zeitpunkt 100 GB groß und kann von den meisten Knoten problemlos verwaltet werden. Aber die Anzahl der Transaktionen, die Ethereum verarbeiten kann, beträgt etwa 20, Bestellungen von Größenordnung kleiner als das, was für viele praktische Anwendungsfälle benötigt wird. Zilliqa ist das bekannteste Projekt, das die Verarbeitung, nicht aber die Speicherung shardt. Das Sharding der Verarbeitung ist ein einfacheres Problem, da jeder Knoten das Ganze hat Zustand, was bedeutet, dass Verträge sich frei auf andere Verträge berufen und beliebige Daten lesen können aus dem blockchain. Um Aktualisierungen sicherzustellen, ist eine sorgfältige Planung erforderlich Die Aktualisierung derselben Teile des Zustands durch mehrere Shards verursacht keinen Konflikt. In In dieser Hinsicht verfolgt Zilliqa einen relativ einfachen Ansatz2. Obwohl eine Aufteilung des Speichers ohne Aufteilung der Verarbeitung vorgeschlagen wurde, ist dies der Fall äußerst ungewöhnlich. In der Praxis erfolgt also das Sharding des Speichers oder State Sharding. Impliziert fast immer eine Aufteilung der Verarbeitung und eine Aufteilung des Netzwerks. Praktisch gesehen bauen beim State Sharding die Knoten in jedem Shard ihre eigenen auf besitzen blockchain, das Transaktionen enthält, die sich nur auf den lokalen Teil auswirken globalen Status, der diesem Shard zugewiesen ist. Daher sind die validators in der Shard muss nur seinen lokalen Teil des globalen Status speichern und nur ausführen. und als solche nur Weiterleitungstransaktionen, die sich auf ihren Teil des Staates auswirken. Dies Die Partition reduziert linear den Bedarf an Rechenleistung, Speicher usw Netzwerkbandbreite, bringt aber auch neue Probleme mit sich, wie z. B. Datenverfügbarkeit und Cross-Shard-Transaktionen, die wir beide im Folgenden behandeln werden. 1.4 Shardübergreifende Transaktionen Das bisher beschriebene Sharding-Modell ist nicht sehr nützlich, da es individuell ist Shards können nicht miteinander kommunizieren, sie sind nicht besser als mehrere unabhängige blockchains. Auch heute noch, wenn Sharding nicht verfügbar ist, gibt es eine großer Bedarf an Interoperabilität zwischen verschiedenen blockchains. Betrachten wir zunächst nur einfache Zahlungstransaktionen, bei denen jeder Teilnehmer ein Konto auf genau einem Shard hat. Wenn man Geld überweisen möchte 2Unsere Analyse ihres Ansatzes finden Sie hier: https://medium.com/nearprotocol/ 8f9efae0ce3bVon einem Konto zu einem anderen innerhalb desselben Shards kann die Transaktion verarbeitet werden vollständig von den validators in diesem Shard. Wenn jedoch Alice, liegt das auf Shard

1 möchte Geld an Bob senden, der sich auf Shard #2 befindet, und auch nicht an validators

auf Shard Nr. 1 (sie können Bobs Konto nicht gutschreiben) und auch nicht auf den validators Shard Nr. 2 (sie können Alices Konto nicht belasten) kann den gesamten Vorgang verarbeiten Transaktion. Es gibt zwei Familien von Ansätzen für Cross-Shard-Transaktionen: • Synchron: Wann immer eine Cross-Shard-Transaktion ausgeführt werden muss, die Blöcke in mehreren Shards, die Zustandsübergänge im Zusammenhang mit dem enthalten Transaktionen werden alle gleichzeitig erzeugt, und die validators mehrerer Shards arbeiten bei der Ausführung solcher Transaktionen zusammen.3 • Asynchron: eine Shard-übergreifende Transaktion, die mehrere Shards betrifft wird in diesen Shards asynchron ausgeführt, wobei der „Credit“-Shard ausgeführt wird seine Hälfte, sobald hinreichende Beweise dafür vorliegen, dass der „Debit“-Shard seinen Teil ausgeführt hat. Dieser Ansatz ist aufgrund seiner Tendenz häufiger anzutreffen Einfachheit und einfache Koordination. Dieses System wird heute in Cosmos, Ethereum Serenity, Near, Kadena und anderen vorgeschlagen. Ein Problem dabei Der Ansatz besteht darin, dass, wenn Blöcke unabhängig voneinander erstellt werden, eine Wahrscheinlichkeit ungleich Null besteht, dass einer der mehreren Blöcke verwaist wird und somit erstellt wird die Transaktion kam nur teilweise zustande. Betrachten Sie Abbildung 2, die zwei zeigt Shards, die beide auf einen Fork und eine Cross-Shard-Transaktion gestoßen sind das wurde entsprechend in den Blöcken A und X‘ aufgezeichnet. Wenn die Ketten A-B und V’-X’-Y’-Z’ sind in den entsprechenden Shards am Ende kanonisch Die Transaktion ist vollständig abgeschlossen. Wenn A’-B’-C’-D’ und V-X kanonisch werden, dann wird die Transaktion vollständig abgebrochen, was akzeptabel ist. Aber wenn, z Wenn beispielsweise A-B und V-X kanonisch werden, wird ein Teil der Transaktion abgeschlossen und ein anderer Teil abgebrochen, was zu einem Atomizitätsfehler führt. Wir Im zweiten Teil wird erläutert, wie dieses Problem in den vorgeschlagenen Protokollen angegangen wird, wobei Änderungen an den Fork-Choice-Regeln und dem Konsens behandelt werden Für Sharded-Protokolle vorgeschlagene Algorithmen. Beachten Sie, dass die Kommunikation zwischen Ketten außerhalb von Shard-blockchains nützlich ist auch. Die Interoperabilität zwischen Ketten ist ein komplexes Problem, das viele Projekte betrifft versuchen zu lösen. In Sharded-blockchains ist das Problem seitdem etwas einfacher Die Blockstruktur und der Konsens sind in allen Shards gleich und es gibt eine Beacon-Kette, die zur Koordination verwendet werden kann. In einem Shard blockchain jedoch Alle Shard-Ketten sind gleich, während sie im globalen blockchains-Ökosystem vorhanden sind Es gibt viele verschiedene blockchains mit unterschiedlichen Zielanwendungsfällen und Dezentralisierung und Datenschutzgarantien. Aufbau eines Systems, in dem eine Reihe von Ketten unterschiedliche Eigenschaften hat, aber Die Verwendung einer ausreichend ähnlichen Konsens- und Blockstruktur und eine gemeinsame Beacon-Kette könnten ein Ökosystem heterogener blockchains ermöglichen, die über eine verfügen 3Die die meisten detailliert Vorschlag bekannt zu die Autoren von dies Dokument ist Zusammenführen Blöcke, beschrieben hier: https://ethresear.ch/t/ merge-blocks-and-synchronous-cross-shard-state-execution/1240Abbildung 2: Asynchrone Cross-Shard-Transaktionen funktionierendes Interoperabilitätssubsystem. Es ist unwahrscheinlich, dass ein solches System über eine validator-Rotation verfügt, daher müssen einige zusätzliche Maßnahmen ergriffen werden, um die Sicherheit zu gewährleisten. Beides Cosmos und PolkaDot sind faktisch solche Systeme4 1.5 Böswilliges Verhalten In diesem Abschnitt werden wir untersuchen, welches gegnerische Verhalten schädliche validators auslösen kann Übung, wenn es ihnen gelingt, einen Splitter zu beschädigen. Wir werden klassische Ansätze überprüfen zur Vermeidung beschädigter Shards in Abschnitt 2.1. 1.5.1 Schädliche Forks Eine Reihe bösartiger validators könnte versuchen, einen Fork zu erstellen. Beachten Sie, dass dies nicht der Fall ist Es spielt keine Rolle, ob der zugrunde liegende Konsens BFT ist oder nicht, wodurch eine ausreichende Anzahl beschädigt wird von validators wird es immer möglich sein, einen Fork zu erstellen. Es ist deutlich wahrscheinlicher, dass mehr als 50 % eines einzelnen Shards beschädigt sind, als dass mehr als 50 % des gesamten Netzwerks beschädigt sind (wir werden es tun). Gehen Sie in Abschnitt 2.1 näher auf diese Wahrscheinlichkeiten ein. Wie in Abschnitt 1.4 besprochen, Shard-übergreifende Transaktionen beinhalten bestimmte Zustandsänderungen in mehreren Shards und die entsprechenden Blöcke in solchen Shards, die solche Zustandsänderungen anwenden müssen entweder alle abgeschlossen sein (d. h. in den ausgewählten Ketten auf der entsprechenden Seite erscheinen). Shards) oder alle verwaist sein (d. h. nicht in den ausgewählten Ketten auf ihren entsprechenden Shards erscheinen). Da im Allgemeinen die Wahrscheinlichkeit, dass Shards beschädigt werden, höher ist 4Siehe diesen Artikel von Zaki Manian aus Cosmos: https://forum.cosmos.network/ t/polkadot-vs-cosmos/1397/2 und dieser Tweet-Sturm vom Erstautor dieses Dokuments: https://twitter.com/AlexSkidanov/status/1129511266660126720 für einen detaillierten Vergleich der beiden

nicht vernachlässigbar ist, können wir nicht davon ausgehen, dass die Forks nicht stattfinden, selbst wenn ein byzantinischer Konsens unter den Shard-validators erreicht wurde oder viele Blöcke dies taten wird mit der Zustandsänderung oben auf dem Block erzeugt. Für dieses Problem gibt es mehrere Lösungen, die häufigste tritt gelegentlich auf Vernetzung des neuesten Shard-Chain-Blocks mit der Beacon-Kette. Die Gabel Die Auswahlregel in den Shard-Ketten wird dann dahingehend geändert, dass immer die entsprechende Kette bevorzugt wird vernetzt und wenden die Shard-spezifische Fork-Choice-Regel nur für Blöcke an, die vernetzt waren veröffentlicht seit der letzten Querverlinkung. 1.5.2 Ungültige Blöcke genehmigen Eine Gruppe von validators könnte versuchen, einen Block zu erstellen, der die Zustandsübergangsfunktion falsch anwendet. Beginnen wir zum Beispiel mit einem Zustand, in dem Alice Hat 10 tokens und Bob hat 0 tokens, könnte der Block eine Transaktion enthalten, die sendet 10 tokens von Alice an Bob, landet aber in einem Zustand, in dem sich Alice befindet 0 tokens und Bob hat 1000 tokens, wie in Abbildung 3 dargestellt. Abbildung 3: Ein Beispiel für einen ungültigen Block Bei einem klassischen Non-Sharded blockchain ist ein solcher Angriff nicht möglich, da alle Der Teilnehmer im Netzwerk validiert alle Blöcke und den Block damit ein ungültiger Zustandsübergang wird von beiden anderen Blockproduzenten abgelehnt und die Teilnehmer des Netzwerks, die keine Blöcke erstellen. Auch wenn das böswillig ist validators erstellen schneller weiterhin Blöcke auf einem solchen ungültigen Block Ehrliche validators bilden die richtige Kette und haben somit die Kette mit dem Ungültigen Block länger ist, spielt es keine Rolle, da jeder Teilnehmer, der den verwendet blockchain validiert für jeden Zweck alle Blöcke und verwirft alle Blöcke auf dem ungültigen Block aufgebaut. Auf der Abbildung 4 gibt es fünf validators, von denen drei böswillig sind. Sie erstellte einen ungültigen Block A‘ und fuhr dann mit dem Aufbau neuer Blöcke darüber fort davon. Zwei ehrliche validators verwarfen A‘ als ungültig und bauten darauf aufAbbildung 4: Versuchen Sie, einen ungültigen Block in einem nicht fragmentierten blockchain zu erstellen. des letzten ihnen bekannten gültigen Blocks, wodurch ein Fork entsteht. Da es weniger sind validators in der ehrlichen Gabelung, ihre Kette ist kürzer. Im klassischen Non-Sharded blockchain gilt dies jedoch für jeden Teilnehmer, der blockchain für einen beliebigen Zweck verwendet Verantwortlich für die Validierung aller empfangenen Blöcke und die Neuberechnung des Status. Daher würde jede Person, die Interesse an blockchain hat, feststellen, dass A‘ ungültig ist, und daher auch B‘, C‘ und D‘ sofort verwerfen und als solche übernehmen Kette A-B als aktuell längste gültige Kette. In einem Shard blockchain kann jedoch kein Teilnehmer alle Transaktionen auf allen Shards validieren, daher muss er eine Möglichkeit haben, dies zu bestätigen Zu jedem Zeitpunkt im Verlauf eines Shards des blockchain war kein ungültiger Block enthalten. Beachten Sie, dass im Gegensatz zu Forks die Vernetzung mit der Beacon-Kette keine ausreichende Lösung ist, da die Beacon-Kette nicht über die Kapazität zur Validierung verfügt Blöcke. Es kann nur validiert werden, dass sich in diesem Shard eine ausreichende Anzahl von validators befindet den Block unterzeichnet (und damit seine Richtigkeit bestätigt). Wir werden Lösungen für dieses Problem im folgenden Abschnitt 2.2 diskutieren.

状態の有効性とデータの可用性

シャード化された blockchains の中心的な考え方は、ほとんどの参加者が操作または ネットワークを使用すると、すべてのシャード内のブロックを検証できません。このように、いつでも 参加者は通常はできない特定のシャードと対話する必要があります シャードの履歴全体をダウンロードして検証します。 ただし、シャーディングのパーティショニングの側面により、大きな可能性が高まります。 問題: 特定の履歴全体をダウンロードして検証しないと 参加者は、シャードの状態がどのような状態であるかを必ずしも確信できるわけではありません。 5このセクションは、サブセクション 2.5.3 を除き、https://near.ai/ で以前に公開されました。 シャード2。すでに読んでいる場合は、次のセクションに進んでください。

それらの相互作用は、ブロックの有効なシーケンスの結果であり、そのシーケンスは of block は確かにシャード内の正規チェーンです。そうならない問題 シャード化されていない blockchain に存在します。 まず、この問題に対して提案されている簡単な解決策を紹介します。 多くのプロトコルで解析し、このソリューションがどのように壊れるか、何が壊れるかを分析します。 それに対処する試みがなされてきました。 2.1 バリデーターのローテーション 状態の妥当性に対する素朴な解決策を図 5 に示します。 システム全体には数千個の validator があり、そのうち 悪意のあるもの、またはそうでなければ失敗するものは 20% 未満です (たとえば、 オンラインでブロックを生成します)。次に、200 validator をサンプリングすると、確率は 1つ以上の 実用的な目的での 3 つの失敗はゼロであると想定できます。 図5: validators をサンプリングしています 1 3 は重要なしきい値です。と呼ばれるコンセンサスプロトコルのファミリーがあります。 BFT コンセンサス プロトコル。1 未満である限りそれを保証します。 3の 参加者は、クラッシュするか、何らかの方法でルールに違反する動作をすることによって失敗します。 議定書では合意が得られます。 この正直な validator パーセンテージを仮定すると、現在のセットが シャード内の validators はいくつかのブロックを提供します。素朴な解決策では次のように仮定します。 ブロックが有効であり、validator が信じているものに基づいて構築されていること 検証を開始したときのそのシャードの正規チェーン。 validator さん 以前の validator セットから正規チェーンを学習しました。 正規チェーンの先頭であるブロックの上に構築された仮定 その前に。帰納法により、チェーン全体が有効になり、validator のセットがないため、 フォークが生成されたどの時点でも、単純な解決策では、現在の チェーンはシャード内の唯一のチェーンです。視覚化については、図 6 を参照してください。

図6: BFT コンセンサスを介して最終化された各ブロックを含む blockchain validator が次の可能性があると仮定すると、この単純な解決策は機能しません。 適応的に破損しますが、これは不合理な仮定ではありません6。適応的に 1,000 個のシャードがあるシステム内の 1 つのシャードを破損する方が大幅にコストが安くなります システム全体を破壊するよりも。したがって、プロトコルのセキュリティはシャードの数に応じて直線的に低下します。有効性について確実性を持たせるためには、 ブロックである場合、歴史のどの時点においても、システム内のシャードにはブロックが存在しないことを知っておく必要があります。 validator の大多数が共謀している。適応的な敵対者にとって、私たちはもはや そのような確実性。セクション 1.5 で説明したように、共謀した validator は、行使できる可能性があります。 2 つの基本的な悪意のある動作: フォークの作成と無効なブロックの生成。 悪意のあるフォークは、ブロックがビーコン チェーンにクロスリンクされることで対処できます。ビーコン チェーンは一般に、ビーコン チェーンよりも大幅に高いセキュリティを持つように設計されています。 シャードチェーン。 ただし、無効なブロックの生成はさらに重要です。 取り組むべき困難な問題。 2.2 状態の有効性 図 7 では、シャード #1 が破損し、悪意のある攻撃者によって生成されたものを考えてみましょう。 無効なブロック B。このブロック B で 1000 個の token が薄いブロックから鋳造されたとします。 アリスのアカウントで放送します。次に、悪意のある攻撃者は有効なブロック C を生成します ( C のトランザクションが正しく適用されていることを意味します)B の上に重ねて難読化します 無効なブロック B を削除し、シャード #2 へのクロスシャード トランザクションを開始します。 これら 1000 token をボブのアカウントに転送します。この瞬間から、不適切な 作成された token は、シャード #2 の完全に有効な blockchain に存在します。 この問題に対処する簡単なアプローチは次のとおりです。 6読む これ 記事 のために 詳細 に どうやって 適応的な 汚職 できる なる 運ばれた アウト: https://medium.com/nearprotocol/d859adb464c8. のために もっと見る 詳細 に 適応的な 汚職、 読む https://github.com/ethereum/wiki/wiki/Sharding-FAQ# 私たちが運用しているセキュリティモデルとは何ですか図 7: 無効なブロックを持つチェーンからのクロスシャード トランザクション 1. シャード #2 の validator について、トランザクションの送信元のブロックを検証します。 が開始されます。ブロック C があるため、上記の例でもこれは機能しません。 完全に有効であると思われます。 2. シャード #2 の validator については、トランザクションが開始されるブロックに先行する多数のブロックを検証します。当然のことながら、 受信シャードによって検証された任意の数のブロック N validators は、無効なブロックの上に N+1 個の有効なブロックを作成できます。 生産された。 この問題を解決する有望なアイデアは、シャードを配置して 各シャードが他のいくつかのシャードに接続されている無向グラフ、および 隣接するシャード間のクロスシャードトランザクションのみを許可します(例:これが方法です) Vlad Zamfir のシャーディングは基本的に機能し7、同様のアイデアが嘉手納のシャーディングでも使用されています。 チェーンウェブ [1])。シャード間でシャード間トランザクションが必要な場合は、 隣接するシャードではないため、そのようなトランザクションは複数のシャードを介してルーティングされます。このデザインでは 各シャードの validator は、シャード内のすべてのブロックの両方を検証することが期待されます 隣接するすべてのシャード内のすべてのブロックも同様です。以下の図を考えてみましょう 10 個のシャードがあり、それぞれに 4 つの隣接シャードがあり、それ以上を必要とする 2 つのシャードはありません 図 8 に示すシャード間通信の場合は 2 ホップよりも短くなります。 シャード #2 は、自身の blockchain だけでなく、次の blockchain も検証しています。 シャード #1 を含むすべての近隣者。したがって、悪意のある攻撃者がシャード #1 にいた場合、 無効なブロック B を作成し、その上にブロック C を構築しようとしています。 クロスシャードトランザクションを開始すると、そのようなクロスシャードトランザクションは実行されません シャード #2 がシャード #1 の履歴全体を検証しているため、 これにより、無効なブロック B が識別されます。 7デザインの詳細については、こちらをご覧ください: https://medium.com/nearprotocol/37e538177ed9

図 8: チェーンウェブのようなシステムにおける無効なクロスシャード トランザクションにより、 検出される 単一のシャードを破損することは実行可能な攻撃ではなくなりましたが、 シャードがほとんどないという問題が残っています。図 9 では、敵が両方のシャードを破損しています

1 とシャード #2 はシャード #3 へのクロスシャード トランザクションを正常に実行します

無効なブロック B からの資金を使用: 図9: チェーンウェブのようなシステムにおける無効なクロスシャード トランザクションにより、 検出されない シャード #3 はシャード #2 のすべてのブロックを検証しますが、シャード #1 のブロックは検証しません。 悪意のあるブロックを検出する方法はありません。 状態の妥当性を適切に解決するには、主に 2 つの方向があります。

そして暗号による計算の証明。 2.3 漁師 最初のアプローチの背後にある考え方は次のとおりです。 あらゆる目的(チェーンへのクロスリンクなど)でチェーン間で通信されます。 ビーコン チェーン、またはクロスシャード トランザクション)、次の期間があります。 正直な validator であれば、ブロックが無効であるという証拠を提供できます。そこに ブロックが存在するという非常に簡潔な証明を可能にするさまざまな構造です。 無効であるため、受信ノードの通信オーバーヘッドははるかに小さくなります。 フルブロックを受信するよりも。 このアプローチは、少なくとも 1 つの正直な validator が存在する限り、 シャード、システムは安全です。 図 10: 漁師 これは、現在提案されているプロトコルの中で (問題が存在しないふりをすることを除けば) 主流のアプローチです。 ただし、このアプローチには次の 2 つの点があります。 主な欠点: 1. 正直な validator にとって、チャレンジ期間は十分に長い必要があります ブロックが生成されたことを認識し、ダウンロードし、完全に検証し、準備する ブロックが無効な場合のチャレンジ。 このような期間を導入すると、 シャード間のトランザクションが大幅に遅くなります。 2. チャレンジプロトコルの存在が新たな攻撃ベクトルを生み出す 悪意のあるノードが無効なチャレンジでスパムを送信した場合。明らかな解決策 この問題には、挑戦者にある程度の token を預けさせる必要があります。 チャレンジが有効な場合は返されます。これは部分的な解決策にすぎません。 敵対者がシステムにスパムを送信する(そして焼き付ける)ことが依然として有益である可能性があります。 デポジット) に無効なチャレンジが含まれる場合 (たとえば、有効なチャレンジを防ぐため)正直な validator からの挑戦です。これらの攻撃は、 グリービングアタックと呼ばれます。 後者の点を回避する方法については、セクション 3.7.2 を参照してください。 2.4 知識に関する簡潔な非対話型議論 複数のシャードの破損に対する 2 番目の解決策は、特定の計算 (たとえば、 トランザクションのセットからブロックを計算するなど) は正しく実行されました。 このような構造は実際に存在します。 zk-SNARK、zk-STARK、その他いくつか、 一部は今日、プライベートな支払いのためにblockchainプロトコルで積極的に使用されています。 最も注目すべきはZCashです。このようなプリミティブの主な問題は、 計算が遅いことで有名です。例えば。 zk-SNARK を使用する Coda プロトコル 特に、blockchain 内のすべてのブロックが有効であることを証明するためであると、ある論文では述べられています。 証拠を作成するのに 1 件の取引につき 30 秒かかる可能性があるというインタビューの結果 (この数字はおそらく今ではもっと小さくなっているでしょう)。 興味深いことに、証明は信頼できる当事者によって計算される必要はありません。 この証明は、その目的で構築された計算の正当性を証明するだけでなく、 証明そのものの有効性。したがって、そのような証明の計算は分割できます。 冗長性が従来よりも大幅に低い参加者のセットの間で行われます。 トラストレス計算を実行するために必要です。参加者も可能です zk-SNARK を計算して、特殊なハードウェア上で実行するために、 システムの分散化。 zk-SNARK には、パフォーマンス以外にも次のような課題があります。 1. 研究が少なく、テストもあまり行われていない暗号プリミティブへの依存。 2. 「有毒廃棄物」 — zk-SNARK は、グループが連携する信頼できるセットアップに依存しています。 の人々が何らかの計算を実行し、中間計算を破棄します。 その計算の値。手続き参加者全員が共謀した場合 中間値を保持すると、偽の証明を作成できます。 3. システム設計に余分な複雑さが導入される。 4. zk-SNARK は可能な計算のサブセットに対してのみ機能するため、プロトコル チューリング完全な smart contract 言語では使用できません チェーンの正当性を証明するためのSNARK。 2.5 データの可用性 2 番目の問題については、データの可用性について触れます。一般にノード 特定の blockchain を操作するノードは、フル ノード、 すべての完全なブロックをダウンロードし、すべてのトランザクションを検証するものと、ライト ブロックヘッダーのみをダウンロードし、パーツにマークル証明を使用するノード 図 11 に示すように、関心のある状態とトランザクションを確認します。

図 11: マークルツリー フルノードの大多数が結託した場合、有効または無効のブロックを生成できるようになりました。 無効であり、その hash をライト ノードに送信しますが、完全な内容は決して公開しないでください ブロックの。そこから利益を得ることができるさまざまな方法があります。たとえば、 図 12 を考えてみましょう。 図 12: データの可用性の問題 3 つのブロックがあります。前の A は、正直な validators によって生成されます。 現在の B には validator が共謀しています。そして次のCも生産されます 正直なvalidatorsによるものです(blockchainは右下隅に描かれています)。 あなたは商人です。現在のブロック (B) の validator がブロックを受信しました 以前の validator から、お金を受け取るブロックを計算しました。そして、そのブロックのヘッダーを状態のマークル証明とともに送信しました。 お金を持っていること(またはお金を送金する有効な取引のマークル証明) あなたへ)。取引が完了したと確信してサービスを提供してください。 ただし、validator はブロック B の完全なコンテンツを配布することはありません。 誰でも。そのため、ブロック C の正直な validator はブロックを取得できません。 システムを停止させるか、A の上に構築することを強いられ、 お金の商人。 同じシナリオをシャーディングに適用すると、フルとシャーディングの定義は次のようになります。 ライト ノードは通常、シャードごとに適用されます: 各シャードの validators のダウンロード間隔 そのシャード内でブロックし、そのシャード内のすべてのトランザクションを検証しますが、その他の システム内のノード (スナップショット シャード チェーンの状態を含むノードも含む) ビーコン チェーンでは、ヘッダーのみをダウンロードします。したがって、シャード内の validator は次のようになります。 そのシャードのノードが効率的にフルになる一方で、システム内の他の参加者は、 ビーコンチェーンを含め、ライトノードとして動作します。 上で説明した漁師のアプローチが機能するには、正直なvalidators ビーコンチェーンにクロスリンクされたブロックをダウンロードできる必要があります。 悪意のある validator が無効なブロックのヘッダーをクロスリンクした場合 (またはそれを使用した場合) クロスシャードトランザクションを開始します)が、ブロックを配布することはありませんでした。 validator には課題を作成する方法がありません。 この問題に対処するための 3 つのアプローチを説明します。 お互いに。 2.5.1 保管証明 解決すべき最も差し迫った問題は、ブロックが一度利用できるかどうかです。 それは出版されています。 提案されたアイデアの 1 つは、いわゆる公証人を交代で配置することです。 シャード間での使用頻度は、 ブロックして、ダウンロードできたという事実を証明します。それらは可能です 状態全体をダウンロードする必要がないため、より頻繁にローテーションされます 頻繁にローテーションできない validator とは異なり、シャードの 図に示すように、シャードが回転するたびにシャードの状態をダウンロードする必要があります 13. この素朴なアプローチの問題は、後で証明することが不可能であることです。 公証人がブロックをダウンロードできたかどうかにかかわらず、公証人は ブロックをダウンロードすることなくブロックをダウンロードできたことを常に証明することを選択できます。 それを取り戻そうとしたとしても。これに対する解決策の 1 つは、公証人が提供するものです。 ブロックがあったことを証明する何らかの証拠、またはある程度の token を賭ける ダウンロードされました。そのようなソリューションの 1 つがここで説明されています: https://ethresear.ch/t/ 1 ビット アグリゲーションに優しいカストディ ボンド/2236。 2.5.2 消去コード 特定のライト ノードがブロックの hash を受信すると、ノードの ブロックが利用可能であるという確信があれば、いくつかのランダムなダウンロードを試みることができます ブロックの破片。これは完全な解決策ではありません。 悪意のあるブロック作成者が選択できるブロック全体をまとめてダウンロードする

図 13: バリデーターは状態をダウンロードする必要があるため、ローテーションできません 頻繁に ライトノードによってダウンロードされなかったブロックの部分を差し控えるため、 したがって、ブロックは引き続き使用できなくなります。 1 つの解決策は、イレイジャー コードと呼ばれる構造を使用して、それを可能にすることです。 図に示すように、ブロックの一部しか利用できない場合でも、ブロック全体を復元するには 図 14 に示します。 図 14: Merkle tree イレイジャーコーディングされたデータの上に構築 Polkadot と Ethereum Serenity は両方とも、このアイデアに基づいた設計を行っています。 ライトノードがブロックが利用可能であることを十分に確信できる方法を提供します。 Ethereum Serenity アプローチについては、[2] で詳しく説明されています。2.5.3 Polkadot のデータ可用性に対するアプローチ Polkadot では、ほとんどのシャード ソリューションと同様に、各シャード (パラチェーンと呼ばれます) がそのブロックのスナップショットをビーコン チェーン (リレー チェーンと呼ばれます) に作成します。 2f + 1があるとします。 リレーチェーン上のvalidator。パラチェーンブロックのブロックプロデューサーは、と呼ばれます コレーターは、パラチェーン ブロックが生成されると、任意の f 部分が十分になるように、2f +1 個の部分で構成されるブロックの消失符号化バージョンを計算します。 ブロックを再構築します。次に、各 validator に 1 つのパートを配布します。 リレーチェーン。特定のリレー チェーン validator はリレー チェーンにのみ署名します スナップショットが作成される各パラチェーン ブロックのパートがある場合は、ブロックします。 そんなリレーチェーンブロック。したがって、リレー チェーン ブロックに 2f + 1 からの署名がある場合、 validator 件、そのうち f 件以下がプロトコルに違反しない限り、それぞれ パラチェーン ブロックは、validators からパーツをフェッチすることで再構築できます。 プロトコルに従うもの。図 15 を参照してください。 図 15: Polkadot のデータの可用性 2.5.4 長期的なデータの可用性 上で説明したすべてのアプローチは、ブロックが すでに出版されており、現在も入手可能です。ブロックは後で使用できなくなる可能性があります さまざまな理由で: ノードがオフラインになる、ノードが意図的に履歴を消去する データ、その他。 この問題に対処する注目に値するホワイトペーパーは、Polyshard [3] です。 これは消去コードを使用して、複数のシャードが存在する場合でもブロックをまたがって利用できるようにします。 シャードはデータを完全に失います。残念ながら、彼らの具体的なアプローチには次のことが必要です すべてのシャードが他のすべてのシャードからブロックをダウンロードすることは法外です 高価な。 長期的な可用性は、参加者がいないため、それほど差し迫った問題ではありません。 システムでは、すべてのチェーンのすべてを検証できることが期待されます。

シャードの場合、シャード プロトコルのセキュリティは次のように設計する必要があります。 たとえ一部のシャード内の古いブロックが壊れたとしてもシステムが安全である方法 完全に利用不可。

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.

Nightshade

3.1 シャードチェーンからシャードチャンクへ シャード チェーンとビーコン チェーンを使用したシャーディング モデルは非常に強力ですが、 にはある種の複雑さがあります。特に、フォーク選択ルールを実行する必要があります。 各チェーンで個別に、シャード チェーンとビーコンでのフォーク選択ルール チェーンは別々に構築し、個別にテストする必要があります。 Nightshade では、システムを単一の blockchain としてモデル化します。 ブロックにはすべてのシャードのすべてのトランザクションが論理的に含まれており、 すべてのシャードの全体状態。ただし、物理的には、参加者は誰もダウンロードしません。 完全な状態または完全な論理ブロック。代わりに、ネットワークの各参加者のみが トランザクションを検証するシャードに対応する状態を維持し、ブロック内のすべてのトランザクションのリストが物理的なトランザクションに分割されます。 チャンク、シャードごとに 1 つのチャンク。 理想的な条件下では、各ブロックにはシャードごとに 1 つのチャンクが含まれます。 ブロック。これは、シャード チェーンを含むモデルにほぼ対応します。 シャード チェーンは、ビーコン チェーンと同じ速度でブロックを生成します。ただし、 ネットワークの遅延により、一部のチャンクが欠落している可能性があるため、実際には各ブロックが欠落している可能性があります。 シャードごとに 1 つまたはゼロのチャンクが含まれます。方法の詳細については、セクション 3.3 を参照してください。 ブロックが生成されます。 図 16: 左側にシャード チェーンがあり、1 つのチェーンが 右側のブロックに分割されたブロック

3.2 コンセンサス 今日のblockchainのコンセンサスへの主要なアプローチは 2 つあります。 最も長い (または最も重い) チェーン。その中で最も多くの作業またはステークを持つチェーン ビルドに使用されたものは正規とみなされ、BFT ではブロックごとにいくつかの validator のセットが BFT のコンセンサスに達しました。 最近提案されたプロトコルでは、後者のアプローチがより有力です。 これは即時的な最終性を提供しますが、最長のチェーンではより多くのブロックが必要となるためです。 ファイナリティを保証するためにブロックの上に構築されます。多くの場合、意味のあることを目的として セキュリティ上、十分な数のブロックが構築されるまでに時間がかかります。 時間の順序。 各ブロックで BFT コンセンサスを使用すると、次のような欠点もあります。 1. BFT コンセンサスにはかなりの量のコミュニケーションが必要です。その間 最近の進歩により、数の点で直線的な時間内に合意に達することが可能になりました 参加者の数 (例: [4] を参照) であっても、ブロックあたりのオーバーヘッドは依然として顕著です。 2. すべてのネットワーク参加者が BFT に参加することは不可能です。 したがって、通常はランダムに抽出された参加者のサブセットのみがコンセンサスに達します。ランダムにサンプリングされたセットは、原則として次のようになります。 適応的に破損し、理論上はフォークが作成される可能性があります。システム どちらもそのようなイベントに備えてモデル化する必要があるため、 BFT コンセンサス以外にフォーク選択ルールがある、またはシャットダウンするように設計されている このようなイベントでダウンします。いくつかのデザインについて言及する価値があります。 Algorand [5] により、適応型破損の可能性が大幅に減少します。 3. 最も重要なのは、次の場合にシステムが停止することです。 参加者全員のうち3名以上が オフライン。したがって、一時的なネットワーク障害やネットワークの分裂により、システムが完全に停止する可能性があります。理想的には、システムは継続的に動作できる必要があります。 参加者の少なくとも半数がオンラインである限り動作します (最も重い チェーンベースのプロトコルは、参加者の半分未満がオンラインであっても動作し続けますが、この特性が望ましいかどうかについては議論の余地があります。 コミュニティ内)。 使用されるコンセンサスが最も重いものであるハイブリッド モデル チェーンですが、一部のブロックはBFT フィナリティ ガジェットを使用して定期的にファイナライズされ、両方のモデルの利点が維持されます。このようなBFT フィナリティ ガジェットは、 Ethereum 2.0 8、Casper CBC で使用される Casper FFG [6] (https://vitalik. を参照) ca/general/2018/12/05/cbc_casper.html) および GRANDPA (https:// を参照) Medium.com/polkadot-network/d08a24a021b5) Polkadot で使用されます。 Nightshade は最も重いチェーンのコンセンサスを使用します。 特にブロックのとき プロデューサーはブロックを生成し (セクション 3.3 を参照)、ブロックから署名を収集できます。 他のブロックプロデューサーと前のブロックを証明するvalidator。セクションを参照 このような多数の署名がどのように集約されるかについては、3.8 を参照してください。重量 8Casper の詳細な概要については、Justin Drake とのホワイトボード セッションもご覧ください。 FFG、およびそれが GHOST の最も重いチェーンのコンセンサスとどのように統合されるかについては、こちらをご覧ください: https://www. youtube.com/watch?v=S262StTwkmoブロックの賭け金は、署名が行われたすべての署名者の累積賭け金となります。 ブロックに含まれています。チェーンの重みはブロックの重みの合計です。 最も重いチェーンのコンセンサスの上に、次のようなフィナリティ ガジェットを使用します。 ブロックを完成させるための証明書。システムの複雑さを軽減するには、 フォーク選択ルールにまったく影響を与えないフィナリティ ガジェットを使用します。 その代わりに、ブロックが一度ブロックされると、追加のスラッシュ条件が導入されるだけです。 フィナリティ ガジェットによってファイナライズされるため、よほど大きなパーセンテージが得られない限りフォークは不可能です 賭け金の合計が削減されます。 Casper CBC は非常にフィナリティの高いガジェットであり、 現在、Casper CBC を念頭に置いたモデルです。 また、TxFlow と呼ばれる別の BFT プロトコルにも取り組んでいます。当時 この文書を書いている時点では、Casper の代わりに TxFlow が使用されるかどうかは不明です CBC。ただし、フィナリティ ガジェットの選択は設計の残りの部分とほぼ直交していることに注意してください。 3.3 ブロック生産 Nightshade には、ブロック プロデューサーと validator という 2 つの役割があります。 いずれにしても システムには w ブロックプロデューサーが含まれている点、モデルでは w = 100、および wv validators、私たちのモデルでは v = 100、wv = 10,000。システムはプルーフ・オブ・ステークです。 つまり、ブロックプロデューサーとvalidatorの両方がいくつかの内部 通貨 (「tokens」と呼ばれます) は、 チェーンの構築と検証という職務の遂行に費やす時間。 すべての Proof of Stake システムと同様、すべての W ブロックプロデューサーがブロックするわけではありません。 それを強制することはできないため、すべての wv validator は異なるエンティティになります。それぞれ ただし、w ブロックプロデューサーと wv validator には別個の 賭け金。 システムには n 個のシャードが含まれており、このモデルでは n = 1000 です。で述べたように セクション 3.1 で説明したように、Nightshade にはシャード チェーンはなく、代わりにすべてのブロック プロデューサーと validator が単一の blockchain を構築しています。 メインチェーン。メインチェーンの状態は n 個のシャードに分割され、各ブロックは プロデューサーと validator は、現時点では、ローカルにダウンロードしたのは、 シャードの一部のサブセットに対応し、プロセスとのみに対応する状態 州のこれらの部分に影響を与えるトランザクションを検証します。 ブロックプロデューサーになるために、ネットワークの参加者はいくつかの大きなロックを行います。 token の金額 (ステーク)。ネットワークのメンテナンスはエポック単位で行われます。 ここで、エポックは数日程度の期間です。 参加者 特定のエポックの開始時に最大の賭け金が得られるブロックは、 その時代のプロデューサー。各ブロックプロデューサーは sw シャードに割り当てられます (たとえば、 sw = 40、これにより、sww/n = 4 シャードあたりのブロックプロデューサーになります)。ブロック プロデューサーは、エポック以前に割り当てられているシャードの状態をダウンロードします。 が開始され、エポック全体を通じてそのシャードに影響を与えるトランザクションを収集します。 そしてそれらを状態に適用します。 メインチェーン上の各ブロック b およびすべてのシャード s には、次のいずれかが存在します。 b に関連する部分を生成する責任がある s にブロック生成者を割り当てます。 シャードに。シャード s に関連する b の部分はチャンクと呼ばれ、 b に含まれるシャードのトランザクションのリストとマークル結果の状態のルート。 b には最終的には非常に小さなヘッダーのみが含まれます。 チャンク、つまり適用されたすべてのトランザクションのマークル ルート (セクションを参照) 正確な詳細については 3.7.1 を参照)、最終状態のマークル ルート。 ドキュメントの残りの部分では、ブロック プロデューサーについてよく言及します。 特定のシャードに対して特定の時間にチャンクを生成する役割を果たします。 チャンクプロデューサーとして。チャンクプロデューサーは常にブロックプロデューサーの 1 つです。 ブロックプロデューサーとチャンクプロデューサーは、次のように各ブロックをローテーションします。 固定スケジュールに。ブロックプロデューサーは命令を受けて繰り返し生産します。 この順序でブロックします。 例えば。 ブロックプロデューサーが 100 人いる場合、最初のブロック プロデューサーはブロック 1、101、201 などの生成を担当し、2 番目はブロックです。 2、102、202など)の制作を担当。 チャンク生成はブロック生成と異なりメンテナンスが必要となるため、 状態、および各シャードについてのみ sww/n ブロックプロデューサーが状態を維持します シャードごとに、それに対応して、それらの sww/n ブロックプロデューサーのみがローテーションして作成されます。 塊。例えば。上記の定数と 4 つのブロック プロデューサーが割り当てられたもの 各シャード、各ブロックプロデューサーは 4 ブロックごとにチャンクを作成します。 3.4 データの可用性を確保する データの可用性を確保するために、Polkadot と同様のアプローチを使用します。 セクション 2.5.3 で説明されています。ブロックプロデューサーがチャンクを生成すると、 の最適な (w, ⌊w/6 + 1⌋) ブロック コードを使用したその消失符号化バージョン チャンク。 次に、消去符号化されたチャンクの 1 つの部分を送信します (このような部分を チャンク部分、または部分のみ)を各ブロックプロデューサーに送信します。 すべての部分を葉として含むマークル ツリーを計算します。 各チャンクのヘッダーには、そのようなツリーのマークル ルートが含まれます。 パーツは onepart メッセージを介して validator に送信されます。そういったメッセージ一つ一つが チャンクヘッダー、パートの序数、およびパートの内容が含まれます。の メッセージには、ブロックを作成したブロックプロデューサーの署名も含まれています。 チャンクとその部分がヘッダーに対応することを証明するマークル パス 適切なブロックプロデューサーによって生成されます。 ブロックプロデューサーがメインチェーンブロックを受け取ると、まず、それらがメインチェーンブロックであるかどうかを確認します。 ブロックに含まれるチャンクごとに 1 つのパート メッセージが含まれます。そうでない場合はブロック 欠落している onepart メッセージが取得されるまで処理されません。 すべての onepart メッセージが受信されると、ブロックプロデューサーは 残りの部分をピアから取得し、ピアが保持するチャンクを再構築します。 状態。 少なくとも 1 つのメイン チェーン ブロックの場合、ブロック プロデューサーはメイン チェーン ブロックを処理しません。 ブロックに含まれるチャンクに対応する onepart メッセージがない場合、または状態を維持する少なくとも 1 つのシャードについては、 チャンク全体を再構築します。 特定のチャンクを利用可能にするには、ブロックの ⌊w/6⌋+1 だけで十分です 生産者は自分の役割を持ち、それを提供します。したがって、その数が続く限り、 悪意のあるアクターは ⌊w/3⌋ ブロックの半分を超えるチェーンを超えない それを構築するプロデューサーは、使用できないチャンクを持つ可能性があります。図 17: 各ブロックにはシャードごとに 1 つまたはゼロのチャンクが含まれており、各チャンクには 消去符号化されています。 Erasure Code チャンクの各部分は、指定されたアドレスに送信されます。 特別な onepart メッセージを介してプロデューサーをブロックする 3.4.1 遅延ブロックプロデューサーへの対処 ブロックプロデューサーに onepart メッセージが欠落しているブロックがある場合、 ブロックがチェーン上に存在することになった場合、まだ署名することを選択する可能性があります。 ブロックプロデューサーの報酬を最大化します。ブロックのリスクはありません ブロックプロデューサーが持っていなかったことを後で証明することは不可能であるため、プロデューサー ワンパートメッセージ。 これに対処するために、チャンクを作成するときに各チャンクをプロデューサーにします。 今後エンコードされるチャンクの各部分の色 (赤または青) を選択し、保存します エンコード前のチャンク内の割り当てられた色のビットマスク。それぞれのパート メッセージにはパーツに割り当てられた色が含まれており、その色は次の場合に使用されます。 エンコードされた部分のマークルルートを計算します。チャンクプロデューサーが外れると プロトコルから、マークルルートが存在しないため、それは簡単に証明できます。 onepart メッセージ、または onepart メッセージの色に対応します。 マークル ルートに対応するものは、チャンク内のマスクとは一致しません。 ブロックプロデューサーがブロックに署名するとき、すべてのブロックのビットマスクが含まれます。 ブロックに含まれるチャンクとして受け取った赤い部分。の出版 不正なビットマスクはスラッシュ可能な動作です。ブロックプロデューサーが 一部のメッセージでは、メッセージの色を知る方法がありません。 したがって、彼らが盲目的に署名しようとすると、切りつけられる可能性が50%あります。 ブロック。 3.5 状態遷移アプリケーション チャンクプロデューサーは、チャンクに含めるトランザクションを選択するだけですが、 チャンクを生成するときに状態遷移を適用しません。これに対応して、

チャンクヘッダーには、以前のメルケル化状態のマークルルートが含まれます チャンク内のトランザクションが適用されます。 トランザクションは、チャンクを含む完全なブロックが存在する場合にのみ適用されます。 処理されます。参加者は次の場合にのみブロックを処理します。 1. 前のブロックが受信され、処理されました。 2. 各チャンクについて、参加者はその状態を維持しません。 onepart メッセージを確認しました。 3. 各チャンクについて、参加者は状態を維持します。 完全なチャンク。 ブロックが処理されると、参加者が参加するシャードごとに 状態を維持し、トランザクションを適用して新しい状態を計算します トランザクションが適用された後の時点で、トランザクションを生成する準備が整います。 次のブロックのチャンク(シャードに割り当てられている場合)。 新しいメルケル化国家のマークルルート。 3.6 クロスシャードトランザクションと領収書 トランザクションが複数のシャードに影響を与える必要がある場合は、連続して影響を与える必要があります。 各シャードで個別に実行されます。トランザクション全体が最初のシャードに送信されます 影響を受け、トランザクションがそのようなシャードのチャンクに含まれると、 チャンクがブロックに含まれた後に適用され、いわゆるレシートが生成されます。 トランザクション。トランザクションが必要な次のシャードにルーティングされます。 処刑される。さらに多くの手順が必要な場合は、受領トランザクションの実行 新しい領収書トランザクションなどを生成します。 3.6.1 受信トランザクションの有効期間 レシートトランザクションは、それが生成されたブロックの直後のブロックで適用されることが望ましい。受け取り取引のみです 前のブロックがブロックプロデューサーによって受信および適用された後に生成されます 元のシャードを維持しており、 次のブロックのチャンクは宛先のブロックプロデューサーによって生成されます 破片。したがって、受領書はソースシャードからシャードに通信される必要があります。 これら 2 つのイベントの間の短い時間枠で宛先シャードを作成します。 A を、レシート r を生成するトランザクション t を含む、最後に生成されたブロックであるとします。 B を次に生成されるブロック (つまり、A を持つブロック) とします。 その前のブロック)、r を含めたいとします。 t をシャード a と r に含めます。 シャード内 b. 図 18 にも示されているレシートの有効期間は次のとおりです。 領収書の作成と保管。シャードのチャンクプロデューサーの CPA a はブロック A を受け取り、トランザクション t を適用し、レシート r を生成します。公認会計士 次に、作成されたすべてのレシートをインデックス付きの内部永続ストレージに保存します。 ソースシャードIDによって異なります。領収書を配布します。 CPA がチャンクを生成する準備ができたら、 ブロック B のシャード a、ブロック A からシャード a のトランザクションを適用することによって生成されたすべてのレシートをフェッチし、それらをシュラッドのチャンクに含めます。 ブロック B 内の a。そのようなチャンクが生成されると、cpa はその消去符号化を生成します。 バージョンと、対応するすべての onepart メッセージ。 cpa は、どのブロックプロデューサーがどのシャードの完全な状態を維持しているかを知っています。特定のブロックプロデューサーの場合 bp cpa には、ブロック A のトランザクションを適用した結果生じた入金が含まれます bp が宛先として気にしているシャードのいずれかを含むシャード a の場合 ブロック B のシャード a のチャンクを配布したときの onepart メッセージ内 (onepart メッセージに含まれるレシートを示す図 17 を参照)。 領収書の受け取り。参加者 (ブロック プロデューサーと validator の両方) は、onepart メッセージを取得するまでブロックを処理しないことに注意してください。 ブロックに含まれるチャンクごとに。したがって、特定の参加者がブロック B を適用するまでに、参加者は、以下に対応するすべての onepart メッセージを取得します。 B にチャンクがあるため、シャードを含むすべての受信レシートが存在します。 参加者は目的地としての状態を維持します。 適用するときは、 特定のシャードの状態遷移の場合、参加者は両方のレシートを適用します onepart メッセージ内のシャード用に収集したものと、すべての チャンク自体に含まれるトランザクション。 図 18: 領収書トランザクションの有効期間 3.6.2 多すぎる領収書の処理 特定のシャードをターゲットとする受信の数が、 特定のブロックが大きすぎて処理できません。たとえば、図 19 を考えてみましょう。 各シャードの各トランザクションは、シャード 1 を対象とするレシートを生成します。 次のブロックまでに、シャード 1 が処理する必要があるレシートの数は次のとおりです。 処理中にすべてのシャードが結合して処理された負荷に相当します 前のブロック。

図 19: すべてのレシートが同じシャードをターゲットにしている場合、シャードには それらを処理する能力 これに対処するために、QuarkChain 9 で使用されているのと同様の技術を使用します。 具体的には、各シャードの最後のブロック B とその中の最後のシャード s レシートが適用されたブロックが記録されます。新しいシャードが作成されるとき 作成されると、レシートは B の残りのシャードから順に適用されます。 次に、B に続くブロックで、新しいチャンクがいっぱいになるまで続けます。正常時 バランスのとれた負荷がある状況では、通常、すべての受信が発生します。 適用されます (したがって、最後のブロックの最後のシャードが記録されます) 各チャンク)、負荷のバランスが取れていない時間帯、および特定の シャードは不釣り合いに多くのレシートを受け取りますが、このテクニックにより、シャードは次のことが可能になります。 含まれるトランザクション数の制限を尊重しながら処理されます。 このような偏荷重が長時間続くと、 アプリケーションが無限に成長し続けるまで、レシートの作成は行われません。 1 つ これに対処する方法は、 ある定数 (1 エポックなど) を超える処理遅延があるシャード。 図 20 を考えてみましょう。ブロック B により、シャード 4 はすべてのレシートを処理できなくなります。 したがって、ブロック A のシャード 3 までの受信のみを処理します。 それを記録します。ブロック C には、ブロック B のシャード 5 までのレシートが含まれており、 その後、ブロック D までにシャードが追いつき、残りのすべてのレシートを処理します。 ブロック B とブロック C からのすべてのレシート。 3.7 チャンクの検証 特定のシャード用に生成されたチャンク (またはシャード チェーンを含むモデル内の特定のシャード チェーン用に生成されたシャード ブロック) は、 9QuarkChainを使用したホワイトボードのエピソードはこちらでご覧ください: https://www.youtube.com/watch? v=opEtG6NM4x4: クロスシャード トランザクションへのアプローチなどが説明されています。 物図 20: 領収書の処理が遅れている 状態を維持する参加者。これらはブロックプロデューサー、validators、 または、状態をダウンロードしてシャードを検証した外部の証人だけ 彼らは資産を保管します。 この文書では、参加者の大多数がデータを保存できないことを想定しています。 シャードの大部分の状態。ただし、言及する価値があります。 次のことを前提として設計されたシャード化された blockchain が存在すること ほとんどの参加者は、ほとんどの状態を保存し、検証する能力を持っています。 QuarkChain などのシャード。 参加者の一部だけがシャードを検証する状態を持っているため、 チャンクを持っている参加者だけを適応的に破損させることが可能です。 状態を変更し、無効な状態遷移を適用します。 数回ごとに validator をサンプリングする複数のシャーディング設計が提案されました 2/3 を超えるシャード チェーン内のブロックは 1 日以内に削除されます。 そのようなシャードに割り当てられた validator の署名が直ちに考慮されます 最後。このようなアプローチでは、適応型の敵対者は 2n/3+1 を破壊するだけで済みます。 シャード チェーン内の validator の無効な状態遷移を適用します。 実現するのは難しいと思われますが、一般の人々にとってセキュリティのレベルは十分ではありません blockchain。 セクション 2.3 で説明したように、一般的なアプローチは、状態 (状態に関係なく) を持つ参加者に対してブロックが作成された後、一定の時間枠を許可することです。 それはブロックプロデューサー、validator、または外部オブザーバーです) の正当性に異議を唱えます。このような参加者はフィッシャーマンと呼ばれます。漁師ができるようになるためには、 無効なブロックに異議を唱える場合は、そのようなブロックが利用可能であることを確認する必要があります。 彼ら。 Nightshade でのデータの可用性については、セクション 3.4 で説明します。 Nightshade では、ブロックが生成されると、チャンクは検証されませんでした。 実際のチャンクプロデューサー以外の誰でも。特に、ブロックプロデューサーは、 ブロックには自然にほとんどのシャードの状態が存在しないことを示唆し、チャンクを検証できませんでした。次のブロックが生成されると、そのブロックには複数のブロック生成者の証明書 (セクション 3.2 を参照) と validator が含まれます。 ただし、ブロックプロデューサーとvalidatorの大部分は状態を維持しないため ほとんどのシャードでも、無効なチャンクが 1 つだけあるブロックは、半分以上の認証を収集し、最も重いブロックに残り続けます。 チェーン。 この問題に対処するために、次の状態を維持する参加者を許可します。 シャードで生成された無効なチャンクに対してオンチェーンでチャレンジを送信するためのシャード 破片。 3.7.1 状態の有効性のチャレンジ 参加者が特定のチャンクが無効であることを検出したら、そのチャンクが無効であるという証拠を提供する必要があります。ネットワーク参加者の大多数は、無効なチャンクが含まれるシャードの状態を維持しないため、 証明には、ブロックが正しいことを確認するのに十分な情報が必要です。 状態がなければ無効です。 単一トランザクションが実行できる状態量 (バイト単位) の制限 Ls を設定します。 累積的に読み取りまたは書き込みができます。 Ls を超えるトランザクション 状態は無効とみなされます。セクション 3.5 で述べたチャンクを思い出してください。 特定のブロック B には、適用されるトランザクションのみが含まれますが、 新しい状態のルート。ブロック B のチャンクに含まれるステート ルートはステートです。 そのようなトランザクションを適用する前、ただしトランザクションを適用した後は root にアクセスします。 同じシャード内のブロックの前の最後のチャンク B. 悪意のある攻撃者 無効な状態遷移を適用しようとすると、不正な状態ルートが含まれる可能性があります 適用の結果生じるステートルートに対応しないブロック B 内 前のチャンク内のトランザクション。 チャンクプロデューサーがチャンクに含める情報を拡張します。 すべてのトランザクションを適用した後の状態を単に含めるのではなく、 連続する各トランザクション セットを適用した後の状態ルートが含まれます。 Ls バイトの状態をまとめて読み書きします。 この情報をもとに、 漁師は、状態遷移が誤って適用されるという課題を作成します。 最初の無効な状態ルートを見つけて、その Ls バイトだけを含めるには十分です。 最後のステート ルート (以前のステート ルート) 間のトランザクションによって影響を受けるステート 有効)とマークル証明付きの現在の状態ルート。その後、参加者全員が セグメント内のトランザクションを検証し、チャンクが有効であることを確認できます。 無効です。 同様に、チャンクプロデューサーが以下のトランザクションを含めようとした場合、 Ls バイトを超える状態を書き込みます。チャレンジには、以下を含めるだけで十分です。 マークル証明と接触する最初の Ls バイト。これで十分です。 トランザクションを適用し、次の処理が実行される瞬間があることを確認します。 Ls バイトを超えるコンテンツの読み取りまたは書き込みが行われます。

3.7.2 漁師と高速クロスシャードトランザクション セクション 2.3 で説明したように、シャード チャンク (またはシャード) が シャード チェーンを含むモデル内のブロック)が無効になり、問題が発生する可能性があります その間、それはフィナリティに悪影響を及ぼし、したがってシャード間の通信に悪影響を及ぼします。で 特に、シャード間トランザクションの宛先シャードは確実ではありません。 元のシャード チャンクまたはブロックは、チャレンジ期間が終了するまで最終的なものとなります (図 21 を参照)。 図 21: レシートを適用する前にチャレンジ期間を待っています クロスシャードトランザクションを行う方法でこれに対処する方法 瞬時とは、宛先シャードがチャレンジ期間を待たないことです。 ソースシャードトランザクションが公開された後、レシートトランザクションを適用します すぐにロールバックしますが、その後、ソースシャードとともに宛先シャードをロールバックします。 元のチャンクまたはブロックが後で無効であることが判明した場合のシャード (図を参照) 22)。これは、シャードが含まれる Nightshade のデザインにも非常に自然に当てはまります。 チェーンは独立していませんが、代わりにシャード チャンクがすべて公開されます 同じメインチェーンブロック内に一緒に。いずれかのチャンクが無効であることが判明した場合、 そのチャンクを含むブロック全体が無効とみなされ、その上に構築されたすべてのブロックが無効と見なされます。 その頂上。図 23 を参照してください。 上記のアプローチは両方とも、チャレンジを前提としてアトミック性を提供します。 期間が十分に長い。通常の状況下では高速なクロスシャード トランザクションを提供する方が不便さを上回るため、後者のアプローチを使用します。 いずれかの無効な状態遷移により、宛先シャードがロールバックします。 ソースシャード、これは非常にまれなイベントです。 3.7.3 validator を非表示にしています 課題の存在により、すでに次のような可能性が大幅に減少しています。 無効な状態遷移ポストでチャンクを終了するため、適応的な破損が発生します。図 22: 領収書をただちに適用し、宛先をロールバックする ソースチェーンに無効なブロックがあった場合はチェーン 図 23: ナイトシェイドでの漁師チャレンジ 適応的な敵対者がすべての参加者を堕落させるために必要なチャレンジ期間 すべての validator を含む、シャードの状態を維持するもの。 このようなイベントが発生する可能性を推定することは非常に複雑です。 シャード化された blockchain は、そのような攻撃が試行されるのに十分な期間存続しています。我々は、その可能性は極めて低いとはいえ、それでも十分にあると主張する。 数百万のトランザクションを実行することが予想されるシステムとしては大規模であり、 世界規模の金融業務を運営します。 この考えには主に 2 つの理由があります。 1. Proof-of-Stake チェーンおよびマイナーの validator のほとんど

Proof-of-Work チェーンは主に財務上の好転によって奨励されます。もし 適応的な敵対者は、期待される利益よりも多くの資金を提供します 正直に動作することから、多くの validator が発生することが予想されます。 申し出を受け入れるでしょう。 2. 多くの企業が Proof-of-Stake チェーンの検証を専門的に行っており、 どのチェーンでも株式の大部分が そのような実体から。そのようなエンティティの数は、 適応的な敵対者として、彼らのほとんどを個人的に知り、 彼らが腐敗する傾向があることをよく理解しています。 どの validator がどのシャードに割り当てられているかを非表示にすることで、適応型破損の可能性を減らすためにさらに一歩進んでいます。アイデアは Algorand [5] が validator を隠す方法とほぼ同じです。 Algorand のように、validator が隠蔽されている場合でも注意することが重要です。 あるいは、以下で説明するように、適応的な破損は理論的には依然として可能です。その間 適応型の敵対者は、作成または検証する参加者を知りません。 ブロックでもチャンクでも、参加者自身が自分が実行することを知っています。 そのようなタスクを実行し、その暗号による証明を持っています。 したがって、敵は、 腐敗させる意図をブロードキャストし、提供してくれる参加者に報酬を支払う そのような暗号証明。ただし、敵はそうではないため、 破損させたいシャードに割り当てられている validator を知っている場合、 特定のシャードを破壊する意図をブロードキャストする以外に選択肢はありません。 コミュニティ全体。その時点で、正直な人にとっては経済的に有益です。 参加者は、そのシャードを検証する完全なノードをスピンアップします。 そのシャードに無効なブロックが出現する可能性があり、これは チャレンジを作成し、関連する報酬を集めます。 特定のシャードに割り当てられている validator を公開しないようにするには、 以下のとおりです (図 24 を参照)。 VRF を使用して割り当てを取得します。各エポックの開始時にそれぞれ validator は VRF を使用して、validator が割り当てられているシャードのビットマスクを取得します。 各 validator のビットマスクには Sw ビットがあります (定義についてはセクション 3.3 を参照してください) スイス)。次に、validator は対応するシャードの状態をフェッチし、 エポック中に、受信したブロックごとに、対応するチャンクを検証します validator が割り当てられているシャードに。 チャンクではなくブロックにサインオンします。シャードの割り当ては隠蔽されているため、validator はチャンクに署名できません。代わりに、常に全体に署名します ブロックするため、どのシャードを検証するかは明らかにされません。具体的には、validator がブロックを受信してすべてのチャンクを検証すると、メッセージが作成されます。 これは、validator が割り当てられているすべてのシャード内のすべてのチャンクが 有効 (それらのシャードが何であるかをまったく示さずに)、または次のようなメッセージ いずれかのチャンクが無効な場合、無効な状態遷移の証明が含まれます。を参照してください。 このようなメッセージがどのように集約されるかについてはセクション 3.8、詳細についてはセクション 3.7.4 を参照してください。 validators が次からのメッセージに便乗するのを防ぐ方法の詳細 その他のvalidator、および報酬と罰の詳細についてはセクション 3.7.5 を参照してください。 validators は、無効な状態遷移チャレンジが実際に成功した場合に発生します。図 24: Nightshade で validator を隠す 3.7.4 コミットと公開 validators に関する一般的な問題の 1 つは、validator が状態のダウンロードと実際のチャンクとブロックの検証をスキップし、その代わりに ネットワークを観察し、他の validator が送信した内容を確認し、その内容を繰り返します。 メッセージ。このような戦略に従う validator は、追加の機能を提供しません。 ネットワークのセキュリティを確保しますが、報酬も収集します。 この問題の一般的な解決策は、validator ごとに証明を提供することです。 たとえば独自のトレースを提供するなどして、ブロックを実際に検証したこと 状態遷移を適用する必要がありますが、そのような証明はコストを大幅に増加させます 検証の。 図 25: コミットと公開

代わりに、validators を最初に検証結果にコミットします (どちらか チャンクの有効性を証明するメッセージ、または無効であることの証明 状態遷移)、図 25 に示すように、一定期間待機してから初めて実際の検証結果が表示されます。コミット期間は次の期間と交差しません。 公開期間があるため、怠惰な validator は正直な validator をコピーできません。 さらに、不正な validator が、 割り当てられたチャンクの有効性、および少なくとも 1 つのチャンクが無効になった場合 チャンクが無効であることが示されているため、validator はスラッシュを回避できません。 セクション 3.7.5 で示すように、そのような状況で斬られないようにする唯一の方法 無効な状態遷移の証拠を含むメッセージを提示することです。 コミットと一致します。 3.7.5 課題への対処 上で説明したように、validator が無効なチャンクを含むブロックを受信すると、 彼らはまず無効な状態遷移の証明を準備します (セクション 3.7.1 を参照)。 そのような証明に取り組み(3.7.4 を参照)、一定期間後に課題を明らかにします。 公開されたチャレンジがブロックに含まれると、次のことが起こります。 1. を含むブロックから発生したすべての状態遷移。 公開されたチャレンジが含まれるブロックが取得されるまで無効なチャンク 無効化された。公開されたチャレンジを含むブロック前の状態 を含むブロックの前の状態と同じとみなされます。 無効なチャンク。 2. 一定期間内に、各 validator はビットマスクを公開する必要があります 彼らが検証したシャード。ビットマスクは VRF 経由で作成されるため、 それらは無効な状態遷移のあるシャードに割り当てられていました。 それを明らかにすることは避けられない。ビットマスクを明らかにできないvalidator シャードに割り当てられていると想定されます。 3. この期間後にシャードに割り当てられていることが判明した各 validator、 を含むブロックの検証結果にコミットしました。 無効なチャンクであり、無効な状態遷移の証拠は明らかにされませんでした コミットに対応する部分はスラッシュされます。 4. 各 validator には新しいシャードが割り当てられ、新しいエポックがスケジュールされます すべての validator がダウンロードするのに十分な時間が経過した後に開始します。 図 26 に示す状態。 validator が割り当てられたシャードを明らかにした瞬間から注意してください。 新しいエポックが始まるまで、システムのセキュリティは低下します。 シャードの割り当てが明らかになります。ネットワークの参加者はそれを保管する必要があります その間ネットワークをご利用になる際はご注意ください。 3.8 署名の集約 数百のシャードを含むシステムが安全に動作するには、 10,000 validator 以上の注文。セクション 3.7 で説明したように、それぞれが必要です。図 26: 課題への対処 validator 特定のメッセージに対するコミットと署名を平均して公開します ブロックごとに 1 回。たとえコミットメッセージが同じであっても、そのようなメッセージを集約すると、 BLS 署名とその検証には法外な費用がかかるでしょう。でも 当然のことながら、コミット メッセージとリビール メッセージは validator 間で同じではありません。 したがって、そのようなメッセージと署名を 1 つのファイルに集約する何らかの方法が必要です。 これにより、後で迅速に検証できるようになります。 私たちが使用する具体的なアプローチは次のとおりです。 ブロックプロデューサーに参加するバリデーター。ブロックプロデューサーは既知です エポックが始まる少し前に、ダウンロードするのに時間がかかるため、 エポックが開始する前の状態であり、validator とは異なり、ブロックプロデューサーは 隠蔽されていない。各ブロックプロデューサーには v validator スロットがあります。バリデーターが送信する ブロックプロデューサーへのオフチェーンの提案で、ブロックプロデューサーの 1 つとして含めることができます。 validator秒。ブロックプロデューサーがvalidatorを含めたい場合は、 validator からの最初のオフチェーンリクエストを含むトランザクション、および validator をブロック プロデューサーに参加させるブロック プロデューサーの署名。 ブロックプロデューサーに割り当てられた validator は必ずしも ブロックプロデューサーがチャンクを生成するのと同じシャードを検証します。 もし validator は複数のブロックプロデューサーの結合に適用されます。ブロックプロデューサーからのトランザクションのみです。 最初のブロックプロデューサーが成功します。 ブロックプロデューサーはコミットを収集します。ブロック プロデューサーは、validator からコミット メッセージとリビール メッセージを常に収集します。このようなメッセージが一定数蓄積されると、ブロックプロデューサーはマークルを計算します。 これらのメッセージのツリーを作成し、各 validator にマークル ルートと 彼らのメッセージへのマークルパス。 validator はパスを検証し、サインオンします。 マークルルート。次に、ブロックプロデューサーは BLS 署名を validators からマークル ルートを取得し、マークル ルートと 積み上げたサイン。ブロックプロデューサーは、ブロックの有効性にも署名します。 安価な ECDSA 署名を使用したマルチ署名。マルチ署名が機能しない場合 送信されたマークル ルート、または参加している validator のビットマスクと一致する場合、これはスラッシュ可能な動作です。チェーンを同期するとき、参加者は validators からのすべての BLS 署名を検証することを選択できます (validators の公開鍵の集約が必要なため、非常にコストがかかります)、またはのみを検証することもできます。ブロックプロデューサーからの ECDMA 署名を使用し、次の事実に依存します。 ブロックプロデューサーは異議を申し立てられず、切り捨てられました。 オンチェーントランザクションとマークルプルーフをチャレンジに使用します。それ そうでない場合、validators からのメッセージを公開しても意味がないことに注意してください。 無効な状態遷移が検出されました。実際の内容を含むメッセージのみ 無効な状態遷移の証拠は、そのようなメッセージに対してのみ明らかにされる必要があります。 それらが前のコミットと一致することを示す必要があります。メッセージには次のことが必要です 次の 2 つの目的で公開されます。 1. 実際にチェーンのロールバックを開始して、直前の時点に戻します。 無効な状態遷移 (セクション 3.7.5 を参照)。 2. validator が、 無効なチャンクです。 いずれの場合も、次の 2 つの問題に対処する必要があります。 1. 実際のコミットはチェーンに含まれておらず、マークルルートのみがチェーンに含まれていました。 他のメッセージと集約されたコミット。 validator は、 ブロックプロデューサーによって提供されるマークルパスとその元のコミット 彼らがその挑戦に真剣に取り組んでいることを証明します。 2. シャードに割り当てられているすべての validator が無効である可能性があります。 状態遷移は破損したブロックプロデューサーに割り当てられているため、 彼らを検閲しているのだ。それを回避するために、私たちは彼らが公開を提出することを許可します オンチェーン上の通常のトランザクションとして、集約をバイパスします。 後者は、無効な状態遷移の証明にのみ許可されます。 非常にまれであるため、ブロックのスパム送信にはならないはずです。 対処する必要がある最後の問題は、ブロックプロデューサーが次のことを行うことができるということです。 メッセージ集約に参加しないことを選択するか、特定の validator を意図的に検閲します。ブロック化することで経済的に不利になります プロデューサーの報酬は、割り当てられた validator の数に比例します。私たち また、エポック間のブロックプロデューサーが大部分で交差していることにも注意してください( 常に最も高い賭け金を持つ上位 2 人の参加者です)、validator は次のことができます 同じブロックプロデューサーとの連携にほぼ固執するため、リスクが軽減されます。 過去に検閲を行ったブロックプロデューサーに割り当てられたことについて。 3.9 スナップショットチェーン メインチェーン上のブロックは非常に頻繁に生成されるため、ダウンロード 完全な履歴はすぐに高価になる可能性があります。また、 ブロックには多数の参加者の BLS 署名が含まれており、署名をチェックするための公開鍵の集合だけでも法外な量になる可能性があります。 高価でもあります。 最後に、予見可能な将来において Ethereum 1.0 は 1 のままになる可能性が高いため、 最も使用されている blockchain から資産を転送する有意義な方法を備えています。

Ethereum に近いことが要件であり、現在、BLS 署名を検証して確実にしています。 Ethereum 側のニアブロックの有効性は不可能です。 Nightshade メインチェーンの各ブロックには、オプションで Schnorr を含めることができます。 このような Schnorr を含む最後のブロックのヘッダーの多重署名 マルチシグネチャ。このようなブロックをスナップショット ブロックと呼びます。の最初のブロック すべてのエポックはスナップショット ブロックである必要があります。このようなマルチシグネチャの作業中に、 ブロックプロデューサーは、validators の BLS 署名も蓄積する必要があります。 最後のスナップショット ブロックで、で説明したのと同じ方法でそれらを集計します。 セクション3.8。 ブロックプロデューサーセットはエポック全体を通じて一定であるため、検証 何もしないと仮定すると、各エポックの最初のスナップショット ブロックだけで十分です。 ブロックプロデューサーとvalidatorの大部分が共謀して作成されたことを指摘する フォーク。 エポックの最初のブロックには、計算に十分な情報が含まれている必要があります ブロックプロデューサーとエポックのvalidator。 スナップショットのみを含むメインチェーンのサブチェーンを呼び出します。 スナップショット チェーンをブロックします。 Schnorr マルチ署名の作成は対話型のプロセスですが、 どんなに非効率なプロセスであっても、頻繁に実行するだけで済みます。 十分でしょう。 Schnorr マルチ署名は Ethereum で簡単に検証できます。 したがって、クロスblockchainを安全に実行するための重要なプリミティブが提供されます。 コミュニケーション。 Near チェーンと同期するには、すべてのスナップショットをダウンロードするだけで済みます ブロックし、Schnorr 署名が正しいことを確認し (オプションで validator の個々の BLS 署名も検証します)、同期のみを行います。 最後のスナップショット ブロックからのメイン チェーン ブロック。

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.

結論

このドキュメントでは、シャード化された blockchain を構築するアプローチについて説明しました。 既存のアプローチの 2 つの主要な課題、つまり状態の妥当性をカバーしました。 データの可用性。次に、Nightshade というシャーディング デザインを提案しました。 NEAR プロトコルを強化します。 デザインは進行中です。コメント、質問、フィードバックがありましたら このドキュメントについては、https://near.chat. にアクセスしてください。

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.