Wer kann teilnehmen?
+ Jede Person, die älter als 18 Jahre ist, mindestens eine andere Sprache als Englisch als Muttersprache spricht und über gute Englischkenntnisse verfügt. +Muss ich ein Übersetzer sein?
+ Nein. Sie müssen lediglich zweisprachig sein und menschliche Übersetzungen vorschlagen (die Verwendung von maschineller Übersetzung ist verboten!) nach bestem Wissen und Gewissen, keine Berufserfahrung erforderlich. +Wie viel Zeit muss ich investieren?
+ So viel Sie möchten. Die Mindestschwelle, um für Preise in Frage zu kommen, liegt bei 1.000 übersetzten Wörtern, was etwa 2 Stunden in Anspruch nehmen sollte, während der Wettbewerb um die Hauptpreise einen größeren Zeitaufwand erfordert. +Muss ich mit Ethereum vertraut sein?
+ Nein. Obwohl es für Ihre Produktivität und Qualität hilfreich sein kann, mit Ethereum vertraut zu sein, ist der Translatathon auch eine Lernerfahrung, und jeder ist eingeladen, mitzumachen und während der Teilnahme mehr über Ethereum zu lernen. +`Nonce``
+Beispiel: ``nonce``
-`` – _Öffnender Tag, der einen Code-Ausschnitt enthält_
+`` - _Öffnender Tag, der einen Code-Ausschnitt enthält_
-Nonce – _Nicht übersetzbarer Text_
+nonce - _Nicht übersetzbarer Text_
-`` – _Schließender Tag_
+`` - _Schließender Tag_
-
+
Der Quelltext enthält auch verkürzte Tags, die nur Zahlen enthalten. Ihre Funktion ist dadurch nicht direkt ersichtlich. Sie können mit dem Mauszeiger über diese Tags fahren, um genau zu sehen, welche Funktion sie haben.
-Im folgenden Beispiel können Sie sehen, dass der Mauszeiger über dem \<0> Tag zeigt, dass er `` darstellt und einen Code-Ausschnitt enthält. Daher sollte der Inhalt innerhalb dieser Tags nicht übersetzt werden.
+Im Beispiel unten sehen Sie, dass das Tag `<0>` beim Darüberfahren anzeigt, dass es `` darstellt und einen Code-Ausschnitt enthält. Daher sollte der Inhalt innerhalb dieser Tags nicht übersetzt werden.
-## Kurze vs. vollständige Formulierungen/Abkürzungen {#short-vs-full-forms}
+## Kurz- vs. Langformen/Abkürzungen {#short-vs-full-forms}
-Auf der Website werden viele Abkürzungen verwendet, z. B. dApps, NFT, DAO, DeFi etc. Diese Abkürzungen werden im Englischen häufig verwendet und sind den meisten Besuchern der Website bekannt.
+Auf der Website werden viele Abkürzungen verwendet, z. B. Dapps, NFT, DAO, DeFi usw. Diese Abkürzungen werden im Englischen häufig verwendet und sind den meisten Besuchern der Website bekannt.
Da es für diese und ähnliche Begriffe in der Regel keine etablierten Übersetzungen in anderen Sprachen gibt, ist es am besten, eine beschreibende Übersetzung der vollständigen Form anzugeben und die englische Abkürzung in Klammern hinzuzufügen.
@@ -168,11 +174,11 @@ Da es für diese und ähnliche Begriffe in der Regel keine etablierten Übersetz
Beispiel für die Übersetzung von dApps:
-- Dezentrale Anwendungen (dApps) → _Übersetzte Vollform (englische Abkürzung in Klammern)_
+- Dezentralisierte Anwendungen (Dapps) → _Übersetzte Vollform (englische Abkürzung in Klammern)_
## Begriffe ohne etablierte Übersetzungen {#terms-without-established-translations}
-Für einige Begriffe gibt es möglicherweise keine etablierten Übersetzungen in anderen Sprachen und sie sind weithin unter dem englischen Originalbegriff bekannt. Diese Begriffe umfassen meist neuere Konzepte wie Proof-of-Work, Proof-of-Stake, Beacon Chain, Staking usw.
+Für einige Begriffe gibt es möglicherweise keine etablierten Übersetzungen in anderen Sprachen und sie sind weithin unter dem englischen Originalbegriff bekannt. Diese Begriffe umfassen meist neuere Konzepte wie Proof ofWork, Proof of Stake, Beacon Chain, Staking usw.
Die Übersetzung dieser Begriffe kann zwar unnatürlich klingen, da aber die englische Version auch in anderen Sprachen häufig verwendet wird, ist es sehr empfehlenswert, sie zu übersetzen.
@@ -180,17 +186,17 @@ Wenn Sie sie übersetzen, können Sie kreativ sein, beschreibende Übersetzungen
**Es ist sinnvoll, die meisten Begriffe zu übersetzen, anstatt sie auf Englisch zu belassen, da diese neue Terminologie sich zukünftig stärker verbreitet, wenn mehr Menschen Ethereum und zugehörige Technologien nutzen. Wenn wir mehr Menschen aus der ganzen Welt für diesen Bereich gewinnen wollen, müssen wir eine verständliche Terminologie in so vielen Sprachen wie möglich anbieten, auch wenn wir sie selbst erstellen müssen.**
-## Schaltflächen und CTAs (Call to Action) {#buttons-and-ctas}
+## Schaltflächen & CTAs {#buttons-and-ctas}
Die Website enthält zahlreiche Schaltflächen, die anders übersetzt werden sollten als andere Inhalte.
Schaltflächentext kann identifiziert werden, indem Sie sich die zugehörigen Kontext-Screenshots ansehen oder den Kontext im Editor überprüfen, der den Ausdruck „Button“ enthält.
-Die Übersetzungen für Schaltflächen sollten so kurz wie möglich sein, um Formatierungsfehler zu vermeiden. Außerdem sollten die Schaltflächenübersetzungen als Anweisung formuliert sein, d. h. einen Befehl oder eine Aufforderung darstellen.
+Die Übersetzungen für Schaltflächen sollten so kurz wie möglich sein, um Formatierungsfehler zu vermeiden. Zudem sollten Übersetzungen von Schaltflächen im Imperativ stehen, d. h. einen Befehl oder eine Aufforderung darstellen.
-
+
-## Übersetzen für Inklusion {#translating-for-inclusivity}
+## Inklusives Übersetzen {#translating-for-inclusivity}
Die Besucher von ethereum.org kommen aus der ganzen Welt und haben ganz unterschiedliche Hintergründe. Die Sprache auf der Website sollte daher neutral, einladend für alle und nicht ausschließend sein.
@@ -229,7 +235,7 @@ Einige Beispiele dafür, worauf besonders zu achten ist:
- Jede Sprache hat vielfältige und komplexe Regeln für die Erstellung von Listen. Diese können sich erheblich vom Englischen unterscheiden.
- In einigen Sprachen muss das erste Wort jeder neuen Zeile groß geschrieben werden, während in anderen Sprachen neue Zeilen mit Kleinbuchstaben beginnen sollten. Viele Sprachen haben auch unterschiedliche Regeln für die Groß- und Kleinschreibung in Listen, je nach Länge der einzelnen Zeilen.
-- Das Gleiche gilt für die Interpunktion von Zeilenelementen. Das Endzeichen in Listen kann, je nach Sprache, ein Punkt (**.**), ein Komma (**,**) oder ein Semikolon (**;**) sein.
+- Das Gleiche gilt für die Interpunktion von Zeilenelementen. Das abschließende Satzzeichen in Listen kann je nach Sprache ein Punkt (.), ein Komma (,) oder ein Semikolon (;) sein.
**Anführungszeichen**
@@ -256,7 +262,7 @@ Einige Beispiele dafür, worauf besonders zu achten ist:
- Englisch – **1,000.50**
- Spanisch – **1.000,50**
- Französisch – **1 000,50**
-- Ebenfalls wichtig bei der Übersetzung von Zahlen ist das Prozentzeichen. Es kann auf verschiedene Weise geschrieben werden: **100%**, **100 %** oder **%100**.
+- Ebenfalls wichtig bei der Übersetzung von Zahlen ist das Prozentzeichen. Es kann auf verschiedene Weisen geschrieben werden: **100%**, **100 %** oder **%100**.
- Und abschließend können auch negative Zahlen je nach Sprache unterschiedlich dargestellt werden: -100, 100-, (100) oder [100].
**Datumsangaben**
@@ -284,7 +290,7 @@ Einige Beispiele dafür, worauf besonders zu achten ist:
- Als allgemeine Regel gilt, dass die Maßeinheiten aus der Quelle beibehalten werden sollten. Wenn in Ihrem Land ein anderes System verwendet wird, können Sie die Umrechnung in Klammern angeben.
- Abgesehen von der Lokalisierung von Maßeinheiten sollte ebenfalls beachtet werden, wie unterschiedlich die Herangehensweise bei diesen Einheiten in den verschiedenen Sprachen ist. Der Hauptunterschied ist der Abstand zwischen der Zahl und der Einheit, der je nach Sprache unterschiedlich sein kann. Beispiele hierfür sind 100kB vs. 100 kB oder 50ºF vs. 50 ºF.
-## Zusammenfassung {#conclusion}
+## Fazit {#conclusion}
Das Übersetzen von ethereum.org ist eine gute Gelegenheit, die verschiedenen Aspekte von Ethereum kennenzulernen.
diff --git a/public/content/translations/de/dao/index.md b/public/content/translations/de/dao/index.md
index f7922d74baf..57f195b7951 100644
--- a/public/content/translations/de/dao/index.md
+++ b/public/content/translations/de/dao/index.md
@@ -1,5 +1,6 @@
---
-title: Dezentrale autonome Organisationen (DAOs)
+title: Was ist ein DAO?
+metaTitle: Was ist ein DAO? | Dezentralisierte Autonome Organisation
description: Eine Übersicht über DAOs auf Ethereum
lang: de
template: use-cases
@@ -18,7 +19,7 @@ Eine DAO ist eine Organisation im kollektiven Besitz, die auf eine gemeinsame Mi
DAOs ermöglichen es uns, mit Gleichgesinnten rund um den Globus zusammenzuarbeiten, ohne auf das Wohlwollen einer Führungskraft vertrauen zu müssen, die unsere Geldmittel oder die Operationen verwaltet. Es gibt keinen CEO, der Geldmittel nach Lust und Laune ausgibt, und keinen Finanzchef, der die Buchhaltung manipulieren kann. Stattdessen bestimmen die in den Code eingebauten, Blockchain-basierten Regeln, wie die Organisation funktioniert und wie Geldmittel ausgegeben werden.
-Die Finanzverwaltung ist integriert und niemand kann ohne die Zustimmung der Gruppe auf die Mittel zugreifen. Entscheidungen werden nach Vorschlägen und Abstimmungen getroffen. So wird sichergestellt, dass jeder in der Organisation eine Stimme hat und dass alles transparent [on-Chain](/glossary/#on-chain) abläuft.
+Die Finanzverwaltung ist integriert und niemand kann ohne die Zustimmung der Gruppe auf die Mittel zugreifen. Entscheidungen werden durch Vorschläge und Abstimmungen getroffen, um sicherzustellen, dass jeder in der Organisation eine Stimme hat und alles transparent [onchain](/glossary/#onchain) geschieht.
## Wofür brauchen wir DAOs? {#why-dao}
@@ -28,27 +29,27 @@ Das eröffnet so viele neue Möglichkeiten der globalen Zusammenarbeit und Koord
### Ein Vergleich {#dao-comparison}
-| DAO | Eine herkömmliche Organisation |
-| ---------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
-| In der Regel flache Strukturen und vollständig demokratisiert | In der Regel hierarchisch strukturiert |
-| Abstimmung durch die Mitglieder erforderlich, damit Veränderungen implementiert werden können | Veränderungen können je nach Struktur von einzelnen Parteien verlangt oder durch offene Abstimmungen beschlossen werden |
-| Nach der Stimmenauszählung wird das Ergebnis automatisch ohne vertrauenswürdige Vermittlungsinstanz implementiert | Sofern Abstimmungen erlaubt sind, werden die Stimmen intern gezählt und das Ergebnis muss manuell umgesetzt werden |
+| DAO | Eine herkömmliche Organisation |
+| ----------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
+| In der Regel flache Strukturen und vollständig demokratisiert | In der Regel hierarchisch strukturiert |
+| Abstimmung durch die Mitglieder erforderlich, damit Veränderungen implementiert werden können | Veränderungen können je nach Struktur von einzelnen Parteien verlangt oder durch offene Abstimmungen beschlossen werden |
+| Nach der Stimmenauszählung wird das Ergebnis automatisch ohne vertrauenswürdige Vermittlungsinstanz implementiert | Sofern Abstimmungen erlaubt sind, werden die Stimmen intern gezählt und das Ergebnis muss manuell umgesetzt werden |
| Angebotene Dienste werden automatisch auf dezentrale Weise abgewickelt (etwa die Verteilung von Geldmitteln für einen guten Zweck) | Erfordert die Abwicklung durch Personen oder zentral kontrollierte automatische Abläufe, die anfällig für Manipulation sind |
-| Alle Aktivitäten sind transparent und vollständig öffentlich | Aktivitäten sind normalerweise organisationsintern, begrenzte Einsicht für die Öffentlichkeit |
+| Alle Aktivitäten sind transparent und vollständig öffentlich | Aktivitäten sind normalerweise organisationsintern, begrenzte Einsicht für die Öffentlichkeit |
-### Beispiele für DAOs {#dao-examples}
+### DAO-Beispiele {#dao-examples}
Für ein besseres Verständnis finden Sie im Folgenden einige Beispiele für den Einsatz einer DAO:
- **Eine Wohltätigkeitsorganisation** – Sie könnten von jeder Person auf der Welt Spenden annehmen und darüber abstimmen, welche Zwecke unterstützt werden sollen.
-- **Kollektivbesitz** – Sie könnten physische oder digitale Vermögenswerte erwerben und Mitglieder können darüber abstimmen, wie diese eingesetzt werden sollen.
-- **Projekte und Förderung** – Sie könnten einen Risikofonds anlegen, der Investitionskapital zusammenlegt und abstimmt, welche Projekte unterstützt werden sollen. Das zurückgezahlte Geld könnte später unter den DAO-Mitgliedern neu verteilt werden.
+- **Kollektives Eigentum** – Sie könnten physische oder digitale Vermögenswerte erwerben und die Mitglieder können darüber abstimmen, wie diese verwendet werden sollen.
+- **Wagniskapital und Zuschüsse** – Sie könnten einen Risikofonds gründen, der Investitionskapital bündelt und darüber abstimmt, welche Vorhaben unterstützt werden sollen. Das zurückgezahlte Geld könnte später unter den DAO-Mitgliedern neu verteilt werden.
@@ -55,17 +56,17 @@ Um das wahre Potenzial von DeFi erkennen zu können, ist es wichtig, die aktuell
Bitcoin war in vielerlei Hinsicht die erste DeFi-Anwendung. Mit Bitcoin können Sie den Wert selbst besitzen, kontrollieren und überall auf der Welt hinsenden. Bitcoin bietet vielen Menschen, die sich gegenseitig nicht vertrauen, die Möglichkeit, eine Einigung über einen aktuellen Transaktionsstatus und Stand aller Konten zu erzielen, ohne dass dafür ein vertrauenswürdiger Vermittler vonnöten ist. Bitcoin ist offen für jeden und niemand ist befugt, Regeln zu ändern. Die Regeln von Bitcoin, wie die Knappheit und Offenheit, sind in der Technologie niedergeschrieben. Es ist nicht wie im traditionellen Finanzwesen, wo Regierungen Geld drucken können, das Ihre Ersparnisse entwertet, und Unternehmen die Märkte schließen können.
-Darauf baut Ethereum auf. Wie bei Bitcoin, können die Regeln sich nicht ändern und jeder hat Zugang dazu. Doch zusätzlich macht Ethereum dieses digitale Geld programmierbar, und zwar mit[Smart Contracts](/glossary/#smart-contract). Dies bietet über das Speichern und Senden von Werten hinaus noch viele weitere Möglichkeiten.
+Darauf baut Ethereum auf. Wie bei Bitcoin, können die Regeln sich nicht ändern und jeder hat Zugang dazu. Aber es macht dieses digitale Geld auch programmierbar, indem [Smart Contracts](/glossary/#smart-contract) verwendet werden, sodass Sie über das Speichern und Senden von Werten hinausgehen können.
+
Machen Sie sich mit unseren Vorschlägen für DeFi-Anwendungen vertraut und testen sie, wenn Sie neu bei Ethereum sind.
DeFi-Apps entdecken
@@ -77,37 +78,37 @@ Das klingt merkwürdig... „Warum würde ich mein Geld programmieren wollen?“
Für fast alle Finanzdienstleistungen gibt es dezentrale Alternativen. Ethereum aber schafft zudem Möglichkeiten, komplett neue Finanzprodukte zu gestalten. Im Folgenden eine Liste mit Beispielen, die ständig länger wird:
-- [Geld rund um die Welt senden](#send-money)
-- [Geld rund um die Welt „streamen“](#stream-money)
-- [Zugang zu stabilen Währungen](#stablecoins)
-- [Kredite mit hinterlegten Sicherheiten aufnehmen](#lending)
-- [Kredite ohne hinterlegte Sicherheiten aufnehmen](#flash-loans)
-- [Krypto-Sparkonten eröffnen](#saving)
-- [Mit Token handeln](#swaps)
-- [Das eigene Portfolio vergrößern](#investing)
+- [Geld um die ganze Welt senden](#send-money)
+- [Geld um den Globus streamen](#stream-money)
+- [Auf stabile Währungen zugreifen](#stablecoins)
+- [Kredite mit Sicherheiten aufnehmen](#lending)
+- [Kredite ohne Sicherheiten aufnehmen](#flash-loans)
+- [Mit Krypto-Sparen beginnen](#saving)
+- [Token handeln](#swaps)
+- [Ihr Portfolio vergrößern](#investing)
- [Ihre Ideen finanzieren](#crowdfunding)
-- [Versicherungen abschließen](#insurance)
-- [Das eigene Portfolio verwalten](#aggregators)
+- [Versicherung abschließen](#insurance)
+- [Ihr Portfolio verwalten](#aggregators)
- Siehe Zahlungs-dApps
+ Zahlungs-Dapps ansehen
#### Geld um die Welt „streamen“... {#stream-money}
Über Ethereum lässt sich auch Geld streamen. So können Sie das Gehalt für Personen sekündlich überweisen und geben ihnen damit Zugang zu ihrem verdienten Geld, wann immer sie es gerade benötigen. Ein weiterer Anwendungsfall wäre beispielsweise das Mieten von Objekten, wie z. B. Schließfächer oder E-Scooter, auf sekündlicher Basis.
-Und wenn Sie keine [ETH](/glossary/#ether) senden oder streamen wollen, weil sich der Wert so stark verändern kann, gibt es alternative Währungen auf Ethereum: [Stablecoins](/glossary/#stablecoin).
+Und wenn Sie [ETH](/glossary/#ether) nicht senden oder streamen möchten, weil sich sein Wert so stark ändern kann, gibt es alternative Währungen auf Ethereum: [Stablecoins](/glossary/#stablecoin).
- Siehe Lending-dApps
+ Kredit-Dapps ansehen
Auf dezentrale Kreditanbieter zurückzugreifen, bietet viele Vorteile...
-#### Geld leihen mit Privatsphäre {#borrowing-privacy}
+#### Kreditaufnahme mit Datenschutz {#borrowing-privacy}
Bei der Vergabe und Inanspruchnahme von Krediten dreht sich heutzutage alles um die beteiligten Einzelpersonen. Banken müssen vor einer Kreditvergabe wissen, ob man wahrscheinlich in der Lage ist, den Kredit zurückzuzahlen.
-Eine dezentrale Kreditvergabe funktioniert vollständig ohne Identifikation der involvierten Parteien. Stattdessen muss der Kreditnehmer eine Sicherheit stellen, die der Kreditgeber automatisch erhält, wenn der Kredit nicht zurückgezahlt wird. Manche Kreditanbieter nehmen sogar [NFTs](/glossary/#nft) als Sicherheiten an. NFTs kann man sich wie eine Besitzurkunde für einen bestimmten Vermögenswert vorstellen. [Mehr zu NFTs](/nft/)
+Eine dezentrale Kreditvergabe funktioniert vollständig ohne Identifikation der involvierten Parteien. Stattdessen muss der Kreditnehmer eine Sicherheit stellen, die der Kreditgeber automatisch erhält, wenn der Kredit nicht zurückgezahlt wird. Manche Kreditgeber akzeptieren sogar [NFTs](/glossary/#nft) als Sicherheit. NFTs kann man sich wie eine Besitzurkunde für einen bestimmten Vermögenswert vorstellen. [Mehr zu NFTs](/nft/)
Das ermöglicht es, ohne Kreditchecks und Preisgabe von privaten Informationen Geld zu borgen.
-#### Zugang zu globalen Geldmitteln {#access-global-funds}
+#### Zugriff auf globale Geldmittel {#access-global-funds}
-Wenn Sie auf einen dezentralen Kreditgeber setzen, erhalten Sie Zugang zu allen hinterlegten Assets überall auf der Welt und nicht nur zu denen, die im Depot Ihrer Bank oder Institution verwaltet werden. Damit werden Kredite leichter zugänglich und die Zinssätze verbessern sich.
+Wenn Sie auf einen dezentralen Kreditgeber setzen, erhalten Sie Zugang zu allen hinterlegten Assets überall auf der Welt und nicht nur zu denen, die im Depot Ihrer Bank oder Institution verwaltet werden. Dadurch werden Kredite leichter zugänglich und die Zinssätze verbessern sich.
#### Steuervorteile {#tax-efficiencies}
Wenn Sie Geld leihen, erhalten Sie Zugang zu Assets und müssen nicht Ihr ETH verkaufen (ein steuerpflichtiger Vorgang). Stattdessen können Sie ETH als Sicherheit für einen Stablecoin-Kredit verwenden. Damit erhalten Sie den benötigten Cashflow, ohne Ihre ETH verkaufen zu müssen. Stablecoins sind Token, die als Zahlungsmittel wesentlich besser geeignet sind, da sie anders als ETH keinen Wertschwankungen unterliegen. [Mehr zu Stablecoins](#stablecoins)
-#### Flash Loans {#flash-loans}
+#### Flash-Loans {#flash-loans}
Flash Loans, also Blitzkredite, sind eine experimentelle Form der dezentralen Kreditaufnahme. Dabei können Sie Geld leihen, ohne Sicherheiten oder persönliche Informationen hinterlegen zu müssen.
@@ -172,27 +173,27 @@ Gäbe es an Handelsplatz B kurzfristig zu wenig Angebot von Assets, wodurch Sie
Um das obige Beispiel in der etablierten Finanzwelt umzusetzen, benötigten Sie sehr viel Geld. Diese Strategien des Geldverdienens sind jenen mit großem bestehenden Vermögen vorbehalten. Flash Loans sind ein Beispiel einer Zukunft, in der der Besitz von Geld nicht die Voraussetzung dafür ist, Geld zu verdienen.
- Mehr zu Flash Loans
+ Mehr zu Flash-Loans
- Zu Lending-dApps
+ Lending-Dapps ansehen
-#### No-Loss-Lotterien {#no-loss-lotteries}
+#### Verlustfreie Lotterien {#no-loss-lotteries}
No-Loss-Lotterien wie zum Beispiel PoolTogether sind ein lustiger und innovativer Weg, Geld zu sparen.
@@ -205,7 +206,7 @@ No-Loss-Lotterien wie zum Beispiel PoolTogether sind ein lustiger und innovative
Der Gewinnpool wird aus allen Zinsen gewonnen, die durch das Verleihen der Ticketanzahlungen wie im Beispiel zum Verleihen oben generiert wurden.
- PoolTogether testen
+ PoolTogether ausprobieren
- Zu Token-Handesplätzen
+ Token-Börsen ansehen
- Zu Trading-dApps
+ Trading-Dapps ansehen
- Zu Investment-dApps
+ Investment-Dapps ansehen
- Zu Crowdfunding-dApps
+ Crowdfunding-Dapps ansehen
#### Quadratische Finanzierung {#quadratic-funding}
-Ethereum ist Open-Source-Software und ein Großteil der bisherigen Arbeit wurde von der Community finanziert. Das hat zur Entwicklung eines interessanten neuen Fundraising-Modells geführt: die quadratische Finanzierung. Damit lässt sich die Art und Weise, wie wir in Zukunft alle Arten von öffentlichen Gütern finanzieren, verbessern.
+Ethereum ist Open-Source-Software und ein Großteil der bisherigen Arbeit wurde von der Community finanziert. Das hat zur Entwicklung eines interessanten neuen Fundraising-Modells geführt: die quadratische Finanzierung. Dieses Modell hat das Potenzial die Art und Weise zu verbessern, wie wir in Zukunft alle Arten von öffentlichen Gütern finanzieren.
Über die quadratische Finanzierung wird sichergestellt, dass die Projekte mit dem größten individuellen Bedarf auch die meisten Mittel erhalten. Mit anderen Worten: Projekte, die das Leben der meisten Menschen verbessern können. So funktioniert es:
@@ -272,7 +273,7 @@ Ethereum ist Open-Source-Software und ein Großteil der bisherigen Arbeit wurde
Projekt A mit 100 Spenden zu je 1 Euro könnte also mehr Mittel erhalten als Projekt B mit einer einzelnen Spende von 10.000 Euro (abhängig von der Größe des übereinstimmenden Pools).
- Zu quadratischer Finanzierung
+ Mehr über quadratische Finanzierung
- Zu Versicherungs-dApps
+ Versicherungs-Dapps ansehen
- Zu Portfolio-dApps
+ Portfolio-Dapps ansehen
- Mehr zum Erstellen von dApps
+ Mehr zum Erstellen von Dapps
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
### DeFi-Daten {#defi-data}
@@ -346,18 +347,19 @@ DeFi ist eine Open-Source-Bewegung. DeFi-Protokolle und -Anwendungen sind für j
### DeFi-Artikel {#defi-articles}
-- [Ein Leitfaden für Einsteiger in DeFi](https://blog.coinbase.com/a-beginners-guide-to-decentralized-finance-defi-574c68ff43c4) – _Sid Coelho-Prabhu, 6. Januar 2020_
+- [Ein Leitfaden für Anfänger zu DeFi](https://blog.coinbase.com/a-beginners-guide-to-decentralized-finance-defi-574c68ff43c4) – _Sid Coelho-Prabhu, 6. Januar 2020_
+- [EEA DeFi Risk Assessment Guidelines](https://entethalliance.org/specs/defi-risks/) – Ein von der Branche unterstützter Überblick, wie man die wichtigsten Risiken in DeFi-Protokollen identifiziert und bewertet.
### Videos {#videos}
-- [Finanzmathematik – mehr erfahren über dezentralisierte Finanzmärkte](https://finematics.com/) – _Videos zu DeFi_
-- [The Defiant](https://www.youtube.com/playlist?list=PLaDcID4s1KronHMKojfjwiHL0DdQEPDcq) - _DeFi-Grundlagen: Alles, was Sie wissen müssen, um in diesem gelegentlich verblüffenden Bereich durchzustarten._
-- [Whiteboard-Krypto](https://youtu.be/17QRFlml4pA) _Was ist DeFi?_
+- [Finematics – Bildung im Bereich dezentrales Finanzwesen](https://finematics.com/) – _Videos zu DeFi_
+- [The Defiant](https://www.youtube.com/playlist?list=PLaDcID4s1KronHMKojfjwiHL0DdQEPDcq) – _DeFi-Grundlagen: Alles, was Sie für den Einstieg in diesen manchmal verwirrenden Bereich wissen müssen._
+- [Whiteboard Crypto](https://youtu.be/17QRFlml4pA) – _Was ist DeFi?_
-### Communities {#communities}
+### Communitys {#communities}
-- [DeFi Llama Discord Server](https://discord.defillama.com/)
-- [DeFi Pulse Discord Server](https://discord.gg/Gx4TCTk)
+- [DeFi Llama Discord-Server](https://discord.defillama.com/)
+- [DeFi Pulse Discord-Server](https://discord.gg/Gx4TCTk)
+> clef newaccount --keystore
-Please enter a password for the new account to be created:
->
+Bitte gib ein Passwort für das neu zu erstellende Konto ein:
+>
------------
-INFO [10-28|16:19:09.156] Your new key was generated address=0x5e97870f263700f46aa00d967821199b9bc5a120
-WARN [10-28|16:19:09.306] Please backup your key file path=/home/user/go-ethereum/data/keystore/UTC--2022-10-28T15-19-08.000825927Z--5e97870f263700f46aa00d967821199b9bc5a120
-WARN [10-28|16:19:09.306] Please remember your password!
-Generated account 0x5e97870f263700f46aa00d967821199b9bc5a120
+INFO [10-28|16:19:09.156] Dein neuer Schlüssel wurde generiert address=0x5e97870f263700f46aa00d967821199b9bc5a120
+WARN [10-28|16:19:09.306] Bitte sichere deine Schlüsseldatei path=/home/user/go-ethereum/data/keystore/UTC--2022-10-28T15-19-08.000825927Z--5e97870f263700f46aa00d967821199b9bc5a120
+WARN [10-28|16:19:09.306] Bitte merke dir dein Passwort!
+Erstelltes Konto 0x5e97870f263700f46aa00d967821199b9bc5a120
```
-[Dokumentation für Geth](https://geth.ethereum.org/docs)
+[Geth-Dokumentation](https://geth.ethereum.org/docs)
-Es ist möglich, neue öffentliche Schlüssel von deinem privaten Schlüssel abzuleiten, aber nicht, einen privaten Schlüssel von öffentlichen Schlüsseln abzuleiten. Es ist unabdingbar, Ihren privaten Schlüssel sicher aufzubewahren und – wie der Name schon sagt – **PRIVAT** zu halten.
+Es ist möglich, neue öffentliche Schlüssel von deinem privaten Schlüssel abzuleiten, aber du kannst keinen privaten Schlüssel von öffentlichen Schlüsseln ableiten. Es ist unerlässlich, deine privaten Schlüssel sicher aufzubewahren und – wie der Name schon sagt – **PRIVAT** zu halten.
Du benötigst einen privaten Schlüssel, um Nachrichten und Transaktionen zu signieren, die eine Signatur nach außen anzeigen. Andere können dann die Unterschrift verwenden, um deinen öffentlichen Schlüssel abzuleiten und den Autor der Nachricht zu verifizieren. In Ihrer Anwendung können Sie eine JavaScript-Bibliothek nutzen, um Transaktionen zum Netzwerk zu senden.
@@ -106,11 +107,11 @@ Beispiel:
Die Vertragsadresse wird in der Regel angegeben, wenn ein Vertrag an die Ethereum Blockchain versendet wird. Diese Adresse stammt von der Erstelleradresse und der Anzahl der Transaktionen, die von dieser Adresse versendet werden (die „nonce“).
-## Schlüssel für Validatoren {#validators-keys}
+## Validator-Schlüssel {#validators-keys}
Es gibt einen weiteren Schlüsseltyp in Ethereum, der mit dem Wechsel von Proof-of-Work zu Proof-of-Stake für den Konsensmechanismus eingeführt wurde. Dieser nennt sich BLS-Schlüssel und wird verwendet, um Validatoren zu identifizieren. Diese Schlüssel lassen sich sehr effizient aggregieren, um die Bandbreite zu reduzieren, die das Netzwerk benötigt, um einen Konsens zu erzielen. Ohne diese Schlüsselaggregation wäre der minimale Stake für Validatoren viel höher.
-[Mehr über Schlüssel für Validatoren](/developers/docs/consensus-mechanisms/pos/keys/).
+[Mehr über Validator-Schlüssel](/developers/docs/consensus-mechanisms/pos/keys/).
## Ein Hinweis zu Wallets {#a-note-on-wallets}
@@ -124,11 +125,11 @@ Austin führt Sie durch Hash-Funktionen und Schlüsselpaare.
+ Endpunkt im Playground ausprobieren
+
**Parameter**
-Keine
+Keine (None)
-**Rückgabewert**
+**Rückgabewerte**
-Die genauen Rückgabedaten variieren je nach Client-Implementierung. Alle Clients geben `False` zurück, wenn der Knoten nicht synchronisiert wird, und alle Clients geben die nachfolgenden Felder zurück.
+Die genauen Rückgabedaten variieren je nach Client-Implementierung. Alle Clients geben `False` zurück, wenn der Node nicht synchronisiert wird, und alle Clients geben die folgenden Felder zurück.
-`Object|Boolean` – ein Objekt mit Synchronisierungsstatus-Daten oder `FALSE`, wenn nicht synchronisiert wird:
+`Object|Boolean`, Ein Objekt mit Synchronisierungsstatusdaten oder `FALSE`, wenn nicht synchronisiert wird:
-- `startingBlock`: `QUANTITY` - Der Block, bei dem der Import begonnen hat (wird nur zurückgesetzt, nachdem die Synchronisierung ihren Kopf erreicht hat)
-- `currentBlock`: `QUANTITY` - Der aktuelle Block, identisch zu eth_blockNumber
-- `highestBlock`: `QUANTITY` - Der geschätzte höchste Block
+- `startingBlock`: `QUANTITY` – Der Block, bei dem der Import gestartet wurde (wird erst zurückgesetzt, nachdem die Synchronisierung ihren Head erreicht hat)
+- `currentBlock`: `QUANTITY` – Der aktuelle Block, wie bei eth_blockNumber
+- `highestBlock`: `QUANTITY` – Der geschätzte höchste Block
Die einzelnen Clients können jedoch auch zusätzliche Daten liefern. Beispielsweise gibt Geth Folgendes zurück:
@@ -362,9 +366,9 @@ Weitere Einzelheiten finden Sie in der Dokumentation zu Ihrem jeweiligen Client.
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}'
-// Result
+// Ergebnis
{
"id":1,
"jsonrpc": "2.0",
@@ -374,7 +378,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}
highestBlock: '0x454'
}
}
-// Or when not syncing
+// Oder wenn nicht synchronisiert wird
{
"id":1,
"jsonrpc": "2.0",
@@ -386,20 +390,26 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}
Gibt die Coinbase-Adresse des Clients zurück.
+
+ Endpunkt im Playground ausprobieren
+
+
+> **Hinweis:** Diese Methode ist seit **v1.14.0** veraltet und wird nicht mehr unterstützt. Der Versuch, diese Methode zu verwenden, führt zu dem Fehler „Method not supported“.
+
**Parameter**
Keine (None)
-**Rückgaben**
+**Rückgabewerte**
-`DATA`, 20 Byte – die aktuelle Coinbase-Adresse.
+`DATA`, 20 Bytes – die aktuelle Coinbase-Adresse.
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_coinbase","params":[],"id":64}'
-// Result
+// Ergebnis
{
"id":64,
"jsonrpc": "2.0",
@@ -411,20 +421,24 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_coinbase","params":[],"id":6
Gibt die Ketten-ID zurück, die für das Unterzeichnen der Replay-geschützten Transaktionen verwendet wird.
+
+ Endpunkt im Playground ausprobieren
+
+
**Parameter**
Keine (None)
-**Rückgaben**
+**Rückgabewerte**
-`chainId` – Hexadezimalwert als String, der die Ganzzahl der aktuellen Ketten-ID repräsentiert.
+`chainId`, Hexadezimalwert als String, der die Ganzzahl der aktuellen Ketten-ID darstellt.
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":67}'
-// Result
+// Ergebnis
{
"id":67,
"jsonrpc": "2.0",
@@ -434,20 +448,24 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":67
### eth_mining {#eth_mining}
-Gibt `true` zurück, wenn der Client aktiv neue Blöcke mint. Dies kann für Proof-of-Work-Netzwerke nur `true` zurückgeben und ist möglicherweise seit [der Zusammenführung](/roadmap/merge/) in einigen Clients nicht mehr verfügbar.
+Gibt `true` zurück, wenn der Client aktiv neue Blöcke schürft. Dies kann nur bei Proof-of-Work-Netzwerken `true` zurückgeben und ist bei einigen Clients seit [The Merge](/roadmap/merge/) möglicherweise nicht mehr verfügbar.
+
+
+ Endpunkt im Playground ausprobieren
+
**Parameter**
Keine (None)
-**Rückgaben**
+**Rückgabewerte**
-`Boolean` – gibt `true` zurück, wenn der Client aktiv mint, andernfalls `false`.
+`Boolean` – gibt `true` zurück, wenn der Client schürft, andernfalls `false`.
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_mining","params":[],"id":71}'
//
{
@@ -459,22 +477,26 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_mining","params":[],"id":71}
### eth_hashrate {#eth_hashrate}
-Gibt die Anzahl der Hashes pro Sekunde zurück, mit der der Knoten mint. Dies kann für Proof-of-Work-Netzwerke nur `true` zurückgeben und ist möglicherweise seit [der Zusammenführung](/roadmap/merge/) in einigen Clients nicht mehr verfügbar.
+Gibt die Anzahl der Hashes pro Sekunde zurück, mit der der Knoten mint. Dies kann nur bei Proof-of-Work-Netzwerken `true` zurückgeben und ist bei einigen Clients seit [The Merge](/roadmap/merge/) möglicherweise nicht mehr verfügbar.
+
+
+ Endpunkt im Playground ausprobieren
+
**Parameter**
Keine (None)
-**Rückgaben**
+**Rückgabewerte**
`QUANTITY` – Anzahl der Hashes pro Sekunde.
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_hashrate","params":[],"id":71}'
-// Result
+// Ergebnis
{
"id":71,
"jsonrpc": "2.0",
@@ -486,20 +508,24 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_hashrate","params":[],"id":7
Gibt eine Schätzung des aktuellen Preises pro Gas in Wei zurück. Der Besu-Client prüft beispielsweise die letzten 100 Blöcke und gibt standardmäßig den mittleren Preis pro Gas-Einheit zurück.
+
+ Endpunkt im Playground ausprobieren
+
+
**Parameter**
Keine (None)
-**Rückgaben**
+**Rückgabewerte**
-`QUANTITY` – Ganzzahl des aktuellen Gas-Preises in Wei.
+`QUANTITY` – Ganzzahl des aktuellen Gaspreises in Wei.
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":73}'
-// Result
+// Ergebnis
{
"id":73,
"jsonrpc": "2.0",
@@ -511,20 +537,24 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":7
Gibt eine Liste von Adressen zurück, die dem Client gehören.
+
+ Endpunkt im Playground ausprobieren
+
+
**Parameter**
Keine (None)
-**Rückgaben**
+**Rückgabewerte**
-`Array of DATA`, 20 Byte – Adressen, die dem Client gehören.
+`Array von DATA`, 20 Bytes – Adressen, die dem Client gehören.
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_accounts","params":[],"id":1}'
-// Result
+// Ergebnis
{
"id":1,
"jsonrpc": "2.0",
@@ -534,22 +564,26 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_accounts","params":[],"id":1
### eth_blockNumber {#eth_blocknumber}
-Gibt die Zahl des aktuellsten Blocks zurück.
+Gibt die Nummer des neuesten Blocks zurück.
+
+
+ Endpunkt im Playground ausprobieren
+
**Parameter**
Keine (None)
-**Rückgaben**
+**Rückgabewerte**
-`QUANTITY` – Ganzzahl der Blocknummer, auf der sich der Client derzeit befindet.
+`QUANTITY` – Ganzzahl der aktuellen Blocknummer, auf der sich der Client befindet.
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":83}'
-// Result
+// Ergebnis
{
"id":83,
"jsonrpc": "2.0",
@@ -559,27 +593,31 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id
### eth_getBalance {#eth_getbalance}
-Gibt das Guthaben des Kontos einer bestimmten Adresse zurück.
+Gibt das Guthaben des Kontos an einer bestimmten Adresse zurück.
+
+
+ Endpunkt im Playground ausprobieren
+
**Parameter**
-1. `DATA`, 20 Bytes - Adresse, deren Guthaben überprüft werden soll.
-2. `QUANTITY|TAG` – ganzzahlige Blocknummer oder der String `"latest"`, `"earliest"`, `"pending"`, `"safe"` oder `"finalized"`, siehe [Standardblockparameter](/developers/docs/apis/json-rpc/#default-block)
+1. `DATA`, 20 Bytes – Adresse, deren Guthaben geprüft werden soll.
+2. `QUANTITY|TAG` – ganzzahlige Blocknummer oder der String `"latest"`, `"earliest"`, `"pending"`, `"safe"` oder `"finalized"`, siehe den [Block-Parameter](/developers/docs/apis/json-rpc/#block-parameter)
```js
params: ["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "latest"]
```
-**Rückgaben**
+**Rückgabewerte**
-`QUANTITY` – Ganzzahl für den aktuellen Saldo in Wei.
+`QUANTITY` – Ganzzahl des aktuellen Guthabens in Wei.
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBalance","params":["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "latest"],"id":1}'
-// Result
+// Ergebnis
{
"id":1,
"jsonrpc": "2.0",
@@ -591,30 +629,35 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBalance","params":["0x407
Gibt den Wert aus einer Speicherposition an einer angegebenen Adresse zurück.
+
+ Endpunkt im Playground ausprobieren
+
+
**Parameter**
-1. `DATA`, 20 Bytes - Adresse des Speichers.
-2. `QUANTITY` - Ganzzahlwert der Position im Speicher.
-3. `QUANTITY|TAG` – ganzzahlige Blocknummer oder der String `"latest"`, `"earliest"`, `"pending"`, `"safe"`, `"finalized"`, siehe [Standardblockparameter](/developers/docs/apis/json-rpc/#default-block)
+1. `DATA`, 20 Bytes – Adresse des Speichers.
+2. `QUANTITY` – Ganzzahl der Position im Speicher.
+3. `QUANTITY|TAG` – ganzzahlige Blocknummer oder der String `"latest"`, `"earliest"`, `"pending"`, `"safe"` oder `"finalized"`, siehe den [Block-Parameter](/developers/docs/apis/json-rpc/#block-parameter)
-**Rückgaben**
+**Rückgabewerte**
`DATA` – der Wert an dieser Speicherposition.
-**Beispiel:** Die Berechnung der richtigen Position hängt vom abzurufenden Speicher ab. Betrachten Sie den folgenden Contract, der unter `0x295a70b2de5e3953354a6a8344e616ed314d7251` von der Adresse `0x391694e7e0b0cce554cb130d723a9d27458f9298` bereitgestellt wurde.
+**Beispiel**
+Die Berechnung der korrekten Position hängt vom abzurufenden Speicher ab. Betrachten Sie den folgenden Contract, der unter `0x295a70b2de5e3953354a6a8344e616ed314d7251` von der Adresse `0x391694e7e0b0cce554cb130d723a9d27458f9298` bereitgestellt wurde.
```
contract Storage {
uint pos0;
mapping(address => uint) pos1;
- function Storage() {
+ constructor() {
pos0 = 1234;
pos1[msg.sender] = 5678;
}
}
```
-Das Abrufen des Wertes von pos0 ist simpel:
+Das Abrufen des Wertes von pos0 ist einfach:
```js
curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": ["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x0", "latest"], "id": 1}' localhost:8545
@@ -658,28 +701,32 @@ curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": [
Gibt die Anzahl der von einer Adresse _gesendeten_ Transaktionen zurück.
+
+ Endpunkt im Playground ausprobieren
+
+
**Parameter**
-1. `DATA`, 20 Bytes - Adresse.
-2. `QUANTITY|TAG` – ganzzahlige Blocknummer oder der String `"latest"`, `"earliest"`, `"pending"`, `"safe"` oder `"finalized"`, siehe [Standardblockparameter](/developers/docs/apis/json-rpc/#default-block)
+1. `DATA`, 20 Bytes – Adresse.
+2. `QUANTITY|TAG` – ganzzahlige Blocknummer oder der String `"latest"`, `"earliest"`, `"pending"`, `"safe"` oder `"finalized"`, siehe den [Block-Parameter](/developers/docs/apis/json-rpc/#block-parameter)
```js
params: [
"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
- "latest", // state at the latest block
+ "latest", // Zustand des neuesten Blocks
]
```
-**Rückgaben**
+**Rückgabewerte**
`QUANTITY` – Ganzzahl der Anzahl der von dieser Adresse gesendeten Transaktionen.
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionCount","params":["0x407d73d8a49eeb85d32cf465507dd71d507100c1","latest"],"id":1}'
-// Result
+// Ergebnis
{
"id":1,
"jsonrpc": "2.0",
@@ -691,15 +738,19 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionCount","params
Gibt die Anzahl der Transaktionen in einem Block zurück, von einem Block, der dem angegebenen Block-Hash entspricht.
+
+ Endpunkt im Playground ausprobieren
+
+
**Parameter**
-1. `DATA`, 32 Bytes - Hash eines Blocks
+1. `DATA`, 32 Bytes – Hash eines Blocks
```js
params: ["0xd03ededb7415d22ae8bac30f96b2d1de83119632693b963642318d87d1bece5b"]
```
-**Rückgaben**
+**Rückgabewerte**
`QUANTITY` – Ganzzahl der Anzahl der Transaktionen in diesem Block.
@@ -720,9 +771,13 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockTransactionCountByHa
Gibt die Anzahl der Transaktionen in einem Block zurück, der der angegebenen Blocknummer entsprechen.
+
+ Endpunkt im Playground ausprobieren
+
+
**Parameter**
-1. `QUANTITY|TAG` – Ganzzahl einer Blocknummer oder der String `"earliest"`, `"latest"`, `"pending"`, `"safe"` oder `"finalized"`, wie im [Standardblockparameter](/developers/docs/apis/json-rpc/#default-block).
+1. `QUANTITY|TAG` – eine Ganzzahl einer Blocknummer oder der String `"earliest"`, `"latest"`, `"pending"`, `"safe"` oder `"finalized"`, wie im [Block-Parameter](/developers/docs/apis/json-rpc/#block-parameter).
```js
params: [
@@ -730,7 +785,7 @@ params: [
]
```
-**Rückgaben**
+**Rückgabewerte**
`QUANTITY` – Ganzzahl der Anzahl der Transaktionen in diesem Block.
@@ -751,17 +806,21 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockTransactionCountByNu
Gibt die Anzahl der Onkel in einem Block zurück, der dem angegebenen Block-Hash entspricht.
+
+ Endpunkt im Playground ausprobieren
+
+
**Parameter**
-1. `DATA`, 32 Bytes - Hash eines Blocks
+1. `DATA`, 32 Bytes – Hash eines Blocks
```js
params: ["0x1d59ff54b1eb26b013ce3cb5fc9dab3705b415a67127a003c3e61eb445bb8df2"]
```
-**Rückgaben**
+**Rückgabewerte**
-`QUANTITY` – Ganzzahl für die Anzahl der Onkel in diesem Block.
+`QUANTITY` – Ganzzahl der Anzahl der Uncles in diesem Block.
**Beispiel**
@@ -780,9 +839,13 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleCountByBlockHash","p
Gibt die Anzahl der Onkel in einem Block zurück, der der angegebenen Blocknummer entspricht.
+
+ Endpunkt im Playground ausprobieren
+
+
**Parameter**
-1. `QUANTITY|TAG` – Ganzzahl einer Blocknummer oder der String `"latest"`, `"earliest"`, `"pending"`, `"safe"` oder `"finalized"`, siehe [Standardblockparameter](/developers/docs/apis/json-rpc/#default-block)
+1. `QUANTITY|TAG` – ganzzahlige Blocknummer oder der String `"latest"`, `"earliest"`, `"pending"`, `"safe"` oder `"finalized"`, siehe den [Block-Parameter](/developers/docs/apis/json-rpc/#block-parameter)
```js
params: [
@@ -790,9 +853,9 @@ params: [
]
```
-**Rückgaben**
+**Rückgabewerte**
-`QUANTITY` – Ganzzahl für die Anzahl der Onkel in diesem Block.
+`QUANTITY` – Ganzzahl der Anzahl der Uncles in diesem Block.
**Beispiel**
@@ -811,10 +874,14 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleCountByBlockNumber",
Gibt den Code an einer angegebenen Adresse zurück.
+
+ Endpunkt im Playground ausprobieren
+
+
**Parameter**
-1. `DATA`, 20 Bytes - Adresse
-2. `QUANTITY|TAG` – ganzzahlige Blocknummer oder der String `"latest"`, `"earliest"`, `"pending"`, `"safe"` oder `"finalized"`, siehe [Standardblockparameter](/developers/docs/apis/json-rpc/#default-block)
+1. `DATA`, 20 Bytes – Adresse
+2. `QUANTITY|TAG` – ganzzahlige Blocknummer oder der String `"latest"`, `"earliest"`, `"pending"`, `"safe"` oder `"finalized"`, siehe den [Block-Parameter](/developers/docs/apis/json-rpc/#block-parameter)
```js
params: [
@@ -823,7 +890,7 @@ params: [
]
```
-**Rückgaben**
+**Rückgabewerte**
`DATA` – der Code von der angegebenen Adresse.
@@ -842,27 +909,27 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getCode","params":["0xC02aaA
### eth_sign {#eth_sign}
-Die Unterzeichnungsmethode berechnet eine Ethereum-spezifische Signatur mit: `sign(keccak256("\x19Ethereum Signed Message:\n" + len(message) + message)))`.
+Die sign-Methode berechnet eine Ethereum-spezifische Signatur mit: `sign(keccak256("\x19Ethereum Signed Message:\n" + len(message) + message)))`.
-Durch das Hinzufügen eines Präfixes zur Nachricht wird die berechnete Signatur als Ethereum-spezifische Signatur erkennbar. Das verhindert Missbrauch, bei dem eine bösartige dApp beliebige Daten (z. B. Transaktionen) signieren und die Signatur nutzen kann, um sich als das Opfer auszugeben.
+Durch das Hinzufügen eines Präfixes zur Nachricht wird die berechnete Signatur als Ethereum-spezifische Signatur erkennbar. Dies verhindert einen Missbrauch, bei dem eine böswillige Dapp beliebige Daten (z. B. eine Transaktion) signieren und die Signatur verwenden kann, um sich als das Opfer auszugeben.
Hinweis: Die zum Signieren verwendete Adresse muss entsperrt sein.
**Parameter**
-1. `DATA`, 20 Bytes - Adresse
-2. `DATA`, N Bytes - Nachricht zum Signieren
+1. `DATA`, 20 Bytes – Adresse
+2. `DATA`, N Bytes – zu signierende Nachricht
-**Rückgaben**
+**Rückgabewerte**
`DATA`: Signatur
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sign","params":["0x9b2055d370f73ec7d8a03e965129118dc8f5bf83", "0xdeadbeaf"],"id":1}'
-// Result
+// Ergebnis
{
"id":1,
"jsonrpc": "2.0",
@@ -872,31 +939,31 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sign","params":["0x9b2055d37
### eth_signTransaction {#eth_signtransaction}
-Signiert eine Transaktion, die zu einem späteren Zeitpunkt an das Netzwerk gesendet werden kann, indem sie mit [eth_sendRawTransaction](#eth_sendrawtransaction) verwendet wird.
+Signiert eine Transaktion, die zu einem späteren Zeitpunkt mit [eth_sendRawTransaction](#eth_sendrawtransaction) an das Netzwerk übermittelt werden kann.
**Parameter**
-1. `Objekt` - Das Transaktionsobjekt
+1. `Object` – Das Transaktionsobjekt
- `type`:
-- `from`: `DATA`, 20 Bytes - Die Adresse, von der die Transaktion gesendet wird.
-- `to`: `DATA`, 20 Bytes - (Optional beim Erstellen eines neuen Vertrags) Die Adresse, an die die Transaktion gerichtet ist.
-- `gas`: `MENGE` - (Optional, Standard: 90000) Ganzzahlwert des Gases, das für die Transaktionsausführung bereitgestellt wurde. Es wird ungenutztes Gas zurückgegeben.
-- `gasPrice`: `QUANTITY` – (optional, Standard: noch zu bestimmen) Ganzzahl von gasPrice, die für jedes bezahlte Gas verwendet wird, in Wei.
-- `value`: `QUANTITY` – (optional) Ganzzahl des Werts, der mit dieser Transaktion gesendet wird, in Wei.
-- `data`: `DATA` - Der kompilierte Code eines Vertrags ODER der Hash der aufgerufenen Methode Signatur und kodierter Parameter.
-- `nonce`: `QUANTITY` - (Optional) Ganzzahlwert einer Nonce. Dies ermöglicht es, eigene ausstehende Transaktionen mit der gleichen Nonce zu überschreiben.
+- `from`: `DATA`, 20 Bytes – Die Adresse, von der die Transaktion gesendet wird.
+- `to`: `DATA`, 20 Bytes – (optional bei der Erstellung eines neuen Vertrags) Die Adresse, an die die Transaktion gerichtet ist.
+- `gas`: `QUANTITY` – (optional, Standard: 90000) Ganzzahl des für die Transaktionsausführung bereitgestellten Gases. Es wird ungenutztes Gas zurückgegeben.
+- `gasPrice`: `QUANTITY` – (optional, Standard: wird noch festgelegt) Ganzzahl des Gaspreises, der für jedes bezahlte Gas in Wei verwendet wird.
+- `value`: `QUANTITY` – (optional) Ganzzahl des mit dieser Transaktion gesendeten Werts in Wei.
+- `data`: `DATA` – Der kompilierte Code eines Vertrags ODER der Hash der aufgerufenen Methodensignatur und der kodierten Parameter.
+- `nonce`: `QUANTITY` – (optional) Ganzzahl einer Nonce. Dies ermöglicht es, eigene ausstehende Transaktionen mit der gleichen Nonce zu überschreiben.
-**Rückgaben**
+**Rückgabewerte**
-`DATA` – das RLP-codierte Transaktionsobjekt, das vom angegebenen Konto signiert wurde.
+`DATA`, Das RLP-kodierte Transaktionsobjekt, das vom angegebenen Konto signiert wurde.
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"id": 1,"jsonrpc": "2.0","method": "eth_signTransaction","params": [{"data":"0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675","from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155","gas": "0x76c0","gasPrice": "0x9184e72a000","to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567","value": "0x9184e72a"}]}'
-// Result
+// Ergebnis
{
"id": 1,
"jsonrpc": "2.0",
@@ -906,19 +973,19 @@ curl -X POST --data '{"id": 1,"jsonrpc": "2.0","method": "eth_signTransaction","
### eth_sendTransaction {#eth_sendtransaction}
-Erstellt eine neue Nachrichtenanruftransaktion oder eine Contract-Erstellung, wenn das Datenfeld Code enthält, und signiert sie mit dem im `from`-Feld angegebenen Konto.
+Erstellt eine neue Nachrichtenaufruf-Transaktion oder eine Vertragserstellung, wenn das Datenfeld Code enthält, und signiert sie mit dem in `from` angegebenen Konto.
**Parameter**
-1. `Objekt` - Das Transaktionsobjekt
+1. `Object` – Das Transaktionsobjekt
-- `from`: `DATA`, 20 Bytes - Die Adresse, von der die Transaktion gesendet wird.
-- `to`: `DATA`, 20 Bytes - (Optional beim Erstellen eines neuen Vertrags) Die Adresse, an die die Transaktion gerichtet ist.
-- `gas`: `MENGE` - (Optional, Standard: 90000) Ganzzahlwert des Gases, das für die Transaktionsausführung bereitgestellt wurde. Es wird ungenutztes Gas zurückgegeben.
-- `gasprice`: `QUANTITY` – (Optional, Standard: Noch zu bestimmen) Ganzzahlwert des Gaspreises, der für jedes bezahlte Gas verwendet wird.
-- `Value`: `QUANTITY` - (Optional) Ganzzahlwert des mit dieser Transaktion gesendeten Werts.
-- `input`: `DATA` – der kompilierte Code eines Contracts ODER der Hash der aufgerufenen Methodensignatur und der codierten Parameter.
-- `nonce`: `QUANTITY` - (Optional) Ganzzahlwert einer Nonce. Dies ermöglicht es, eigene ausstehende Transaktionen mit der gleichen Nonce zu überschreiben.
+- `from`: `DATA`, 20 Bytes – Die Adresse, von der die Transaktion gesendet wird.
+- `to`: `DATA`, 20 Bytes – (optional bei der Erstellung eines neuen Vertrags) Die Adresse, an die die Transaktion gerichtet ist.
+- `gas`: `QUANTITY` – (optional, Standard: 90000) Ganzzahl des für die Transaktionsausführung bereitgestellten Gases. Es wird ungenutztes Gas zurückgegeben.
+- `gasPrice`: `QUANTITY` – (optional, Standard: wird noch festgelegt) Ganzzahl des Gaspreises, der für jedes bezahlte Gas verwendet wird.
+- `value`: `QUANTITY` – (optional) Ganzzahl des mit dieser Transaktion gesendeten Werts.
+- `input`: `DATA` – Der kompilierte Code eines Vertrags ODER der Hash der aufgerufenen Methodensignatur und der kodierten Parameter.
+- `nonce`: `QUANTITY` – (optional) Ganzzahl einer Nonce. Dies ermöglicht es, eigene ausstehende Transaktionen mit der gleichen Nonce zu überschreiben.
```js
params: [
@@ -934,18 +1001,18 @@ params: [
]
```
-**Rückgaben**
+**Rückgabewerte**
-`DATA`, 32 Byte – der Transaktions-Hash oder der Null-Hash, wenn die Transaktion noch nicht verfügbar ist.
+`DATA`, 32 Bytes – der Transaktionshash oder der Null-Hash, wenn die Transaktion noch nicht verfügbar ist.
-Verwenden Sie [eth_getTransactionReceipt](#eth_gettransactionreceipt), um die Contract-Adresse zu erhalten, nachdem die Transaktion in einem Block vorgeschlagen wurde, wenn Sie einen Contract erstellt haben.
+Verwenden Sie [eth_getTransactionReceipt](#eth_gettransactionreceipt), um die Vertragsadresse zu erhalten, nachdem die Transaktion in einem Block vorgeschlagen wurde, als Sie einen Vertrag erstellt haben.
**Beispiel**
```js
-// Request
-curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sendTransaction","params":[{see above}],"id":1}'
-// Result
+// Anfrage
+curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sendTransaction","params":[{siehe oben}],"id":1}'
+// Ergebnis
{
"id":1,
"jsonrpc": "2.0",
@@ -967,18 +1034,18 @@ params: [
]
```
-**Rückgaben**
+**Rückgabewerte**
-`DATA`, 32 Byte – der Transaktions-Hash oder der Null-Hash, wenn die Transaktion noch nicht verfügbar ist.
+`DATA`, 32 Bytes – der Transaktionshash oder der Null-Hash, wenn die Transaktion noch nicht verfügbar ist.
-Verwenden Sie [eth_getTransactionReceipt](#eth_gettransactionreceipt), um die Contract-Adresse zu erhalten, nachdem die Transaktion in einem Block vorgeschlagen wurde, wenn Sie einen Contract erstellt haben.
+Verwenden Sie [eth_getTransactionReceipt](#eth_gettransactionreceipt), um die Vertragsadresse zu erhalten, nachdem die Transaktion in einem Block vorgeschlagen wurde, als Sie einen Vertrag erstellt haben.
**Beispiel**
```js
-// Request
-curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sendRawTransaction","params":[{see above}],"id":1}'
-// Result
+// Anfrage
+curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sendRawTransaction","params":[{siehe oben}],"id":1}'
+// Ergebnis
{
"id":1,
"jsonrpc": "2.0",
@@ -988,31 +1055,35 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sendRawTransaction","params"
### eth_call {#eth_call}
-Führt sofort einen neuen Nachrichtenaufruf aus, ohne eine Transaktion auf der Blockchain zu erstellen. Wird häufig für die Ausführung von Smart-Contract-Funktionen mit Leseberechtigung verwendet, zum Beispiel `balanceOf` für einen ERC-20-Contract.
+Führt einen neuen Message Call sofort aus, ohne eine Transaktion auf der Blockchain zu erstellen. Wird oft für die Ausführung schreibgeschützter Smart-Contract-Funktionen verwendet, zum Beispiel `balanceOf` für einen ERC-20-Vertrag.
+
+
+ Endpunkt im Playground ausprobieren
+
**Parameter**
-1. `Object` - Das Transaktionsaufrufobjekt
+1. `Object` – Das Transaktionsaufruf-Objekt
-- `from`: `DATA`, 20 Bytes - (Optional) Die Adresse, von der die Transaktion gesendet wird.
+- `from`: `DATA`, 20 Bytes – (optional) Die Adresse, von der die Transaktion gesendet wird.
- `to`: `DATA`, 20 Bytes – Die Adresse, an die die Transaktion gerichtet ist.
-- `gas`: `QUANTITY` - (Optional) Ganzzahlwert des für die Transaktionsausführung bereitgestellten Gases. eth_call verbraucht kein Gas, aber dieser Parameter kann von einigen Ausführungen benötigt werden.
-- `gasprice`: `QUANTITY` - (Optional) Ganzzahlwert des Gaspreises, der für jedes bezahlte Gas verwendet wird
-- `value`: `QUANTITY` - (Optional) Ganzzahlwert des mit dieser Transaktion gesendeten Werts
-- `input`: `DATA` – (optional) Hash der Methodensignatur und der codierten Parameter. Einzelheiten finden Sie unter [Ethereum-Contract-ABI in der Solidity-Dokumentation](https://docs.soliditylang.org/en/latest/abi-spec.html).
+- `gas`: `QUANTITY` – (optional) Ganzzahl des für die Transaktionsausführung bereitgestellten Gases. eth_call verbraucht kein Gas, aber dieser Parameter kann von einigen Ausführungen benötigt werden.
+- `gasPrice`: `QUANTITY` – (optional) Ganzzahl des für jedes bezahlte Gas verwendeten Gaspreises.
+- `value`: `QUANTITY` – (optional) Ganzzahl des mit dieser Transaktion gesendeten Werts.
+- `input`: `DATA` – (optional) Hash der Methodensignatur und der kodierten Parameter. Details hierzu finden Sie unter [Ethereum Contract ABI in der Solidity-Dokumentation](https://docs.soliditylang.org/en/latest/abi-spec.html).
-2. `QUANTITY|TAG` – ganzzahlige Blocknummer oder der String `"latest"`, `"earliest"`, `"pending"`, `"safe"` oder `"finalized"`, siehe [Standardblockparameter](/developers/docs/apis/json-rpc/#default-block)
+2. `QUANTITY|TAG` – ganzzahlige Blocknummer oder der String `"latest"`, `"earliest"`, `"pending"`, `"safe"` oder `"finalized"`, siehe den [Block-Parameter](/developers/docs/apis/json-rpc/#block-parameter)
-**Rückgaben**
+**Rückgabewerte**
-`DATA` – der Rückgabewert des ausgeführten Vertrages.
+`DATA` – der Rückgabewert des ausgeführten Vertrags.
**Beispiel**
```js
-// Request
-curl -X POST --data '{"jsonrpc":"2.0","method":"eth_call","params":[{see above}],"id":1}'
-// Result
+// Anfrage
+curl -X POST --data '{"jsonrpc":"2.0","method":"eth_call","params":[{siehe oben}],"id":1}'
+// Ergebnis
{
"id":1,
"jsonrpc": "2.0",
@@ -1024,20 +1095,24 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_call","params":[{see above}]
Generiert und gibt eine Schätzung zurück, wie viel Gas erforderlich ist, damit die Transaktion abgeschlossen werden kann. Die Transaktion wird nicht zur Blockchain hinzugefügt. Beachten Sie, dass die Schätzung aus verschiedenen Gründen, einschließlich der EVM-Mechanik und der Leistung des Knotens, erheblich höher sein kann als die tatsächlich von der Transaktion verbrauchte Gas-Menge.
+
+ Endpunkt im Playground ausprobieren
+
+
**Parameter**
-Siehe [eth_call](#eth_call)-Parameter – mit der Ausnahme, dass alle Eigenschaften optional sind. Wenn kein Gas-Limit angegeben ist, verwendet Geth das Block-Gas-Limit aus dem anstehenden Block als Obergrenze. Infolgedessen reicht die zurückgegebene Schätzung möglicherweise nicht aus, um die Abfrage/Transaktion auszuführen, wenn die Gas-Menge höher als das ausstehende Block-Gas-Limit ist.
+Siehe [eth_call](#eth_call) Parameter, außer dass alle Eigenschaften optional sind. Wenn kein Gas-Limit angegeben ist, verwendet Geth das Block-Gas-Limit aus dem anstehenden Block als Obergrenze. Daher reicht die zurückgegebene Schätzung möglicherweise nicht aus, um den Aufruf/die Transaktion auszuführen, wenn die Gasmenge höher ist als das Gaslimit des ausstehenden Blocks.
-**Rückgaben**
+**Rückgabewerte**
-`QUANTITY` – die verbrauchte Gas-Menge.
+`QUANTITY` – die Menge des verbrauchten Gases.
**Beispiel**
```js
-// Request
-curl -X POST --data '{"jsonrpc":"2.0","method":"eth_estimateGas","params":[{see above}],"id":1}'
-// Result
+// Anfrage
+curl -X POST --data '{"jsonrpc":"2.0","method":"eth_estimateGas","params":[{siehe oben}],"id":1}'
+// Ergebnis
{
"id":1,
"jsonrpc": "2.0",
@@ -1049,10 +1124,14 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_estimateGas","params":[{see
Gibt Informationen zu einem Block per Hash zurück.
+
+ Endpunkt im Playground ausprobieren
+
+
**Parameter**
-1. `DATA`, 32 Bytes - Hash eines Blocks.
-2. `Boolean` - Bei `true` werden die vollständigen Transaktionsobjekte zurückgegeben, bei `false` nur die Hashes der Transaktionen.
+1. `DATA`, 32 Bytes – Hash eines Blocks.
+2. `Boolean` – Wenn `true`, werden die vollständigen Transaktionsobjekte zurückgegeben, wenn `false`, nur die Hashes der Transaktionen.
```js
params: [
@@ -1061,41 +1140,40 @@ params: [
]
```
-**Rückgaben**
+**Rückgabewerte**
-`Object` – ein Blockobjekt oder `null`, wenn kein Block gefunden wurde:
+`Object` – Ein Block-Objekt oder `null`, wenn kein Block gefunden wurde:
-- `number`: `QUANTITY` - Die Blocknummer. `null`, wenn es ein ausstehender Block ist.
-- `hash`: `DATA`, 32 Bytes - Hash des Blocks. `null`, wenn es ein ausstehender Block ist.
-- `parentHash`: `DATA`, 32 Bytes - Hash des übergeordneten Blocks.
-- `nonce`: `DATA`, 8 Bytes - Hash des generierten Proof-of-Work. `null`, wenn es ein ausstehender Block ist.
-- `sha3Uncles`: `DATA`, 32 Bytes - SHA3 der Onkeldaten im Block.
-- `logsBloom`: `DATA`, 256 Bytes - Der Bloom-Filter für die Protokolle des Blocks. `null`, wenn es ein ausstehender Block ist.
-- `TransaktionsRoot`: `DATA`, 32 Bytes - Das Stammverzeichnis der Transaktions-Trie des Blocks.
+- `number`: `QUANTITY` – die Blocknummer. `null`, wenn es ein ausstehender Block ist.
+- `hash`: `DATA`, 32 Bytes – Hash des Blocks. `null`, wenn es ein ausstehender Block ist.
+- `parentHash`: `DATA`, 32 Bytes – Hash des übergeordneten Blocks.
+- `nonce`: `DATA`, 8 Bytes – Hash des generierten Proof-of-Work. `null`, wenn es ein ausstehender Block ist, `0x0` für Proof-of-Stake-Blöcke (seit The Merge)
+- `sha3Uncles`: `DATA`, 32 Bytes – SHA3 der Uncle-Daten im Block.
+- `logsBloom`: `DATA`, 256 Bytes – der Bloom-Filter für die Protokolle des Blocks. `null`, wenn es ein ausstehender Block ist.
+- `transactionsRoot`: `DATA`, 32 Bytes – die Wurzel des Transaktions-Trie des Blocks.
- `stateRoot`: `DATA`, 32 Bytes – Die Wurzel des endgültigen Zustands-Trie des Blocks.
-- `receiptsRoot`: `DATA`, 32 Bytes - Die Wurzel des Quittungstries des Blocks.
-- `miner`: `DATA`, 20 Byte – die Adresse des Begünstigten, dem die Mining-Belohnungen gegeben wurden.
-- `difficulty`: `QUANTITY` - Ganzzahlwert der Schwierigkeit für diesen Block.
-- `totalDifficulty`: `QUANTITY` - Ganzzahlwert der Gesamtschwierigkeit der Blockchain bis zu diesem Block.
-- `extraData`: `DATA` - Das Feld „zusätzliche Daten“ dieses Blocks.
-- `size`: `QUANTITY` - Ganzzahlwert der Größe dieses Blocks in Bytes.
-- `gasLimit`: `QUANTITY` - Das maximal zulässige Gas in diesem Block.
-- `gasUsed`: `QUANTITY` - Das insgesamt von allen Transaktionen in diesem Block verbrauchte Gas.
-- `timestamp`: `QUANTITY` - Der Unix-Zeitstempel für den Zeitpunkt, zu dem der Block sortiert wurde.
+- `receiptsRoot`: `DATA`, 32 Bytes – die Wurzel des Beleg-Trie des Blocks.
+- `miner`: `DATA`, 20 Bytes – die Adresse des Begünstigten, der die Block-Belohnungen erhalten hat.
+- `difficulty`: `QUANTITY` – Ganzzahl der für diesen Block erforderlichen Rechenleistung.
+- `totalDifficulty`: `QUANTITY` – Ganzzahl der gesamten Rechenleistung der Kette bis zu diesem Block.
+- `extraData`: `DATA` – das „extra data“-Feld dieses Blocks.
+- `size`: `QUANTITY` – Ganzzahl der Größe dieses Blocks in Bytes.
+- `gasLimit`: `QUANTITY` – das maximal zulässige Gas in diesem Block.
+- `gasUsed`: `QUANTITY` – das insgesamt von allen Transaktionen in diesem Block verbrauchte Gas.
+- `timestamp`: `QUANTITY` – der Unix-Zeitstempel, zu dem der Block zusammengestellt wurde.
- `transactions`: `Array` – Array von Transaktionsobjekten oder 32-Byte-Transaktions-Hashes, abhängig vom zuletzt angegebenen Parameter.
-- `uncles`: `Array` - Array von Onkel-Hashes.
+- `uncles`: `Array` – Array von Uncle-Hashes.
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockByHash","params":["0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae", false],"id":1}'
-// Result
-{
+// Ergebnis
{
-"jsonrpc": "2.0",
-"id": 1,
-"result": {
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
"difficulty": "0x4ea3f27bc",
"extraData": "0x476574682f4c5649562f76312e302e302f6c696e75782f676f312e342e32",
"gasLimit": "0x1388",
@@ -1118,7 +1196,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockByHash","params":["0
"transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
"uncles": [
]
-}
+ }
}
```
@@ -1126,10 +1204,14 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockByHash","params":["0
Gibt Informationen über eine Block-für-Block-Nummer zurück.
+
+ Endpunkt im Playground ausprobieren
+
+
**Parameter**
-1. `QUANTITY|TAG` – Ganzzahl einer Blocknummer oder der String `"earliest"`, `"latest"`, `"pending"`, `"safe"` oder `"finalized"`, wie im [Standardblockparameter](/developers/docs/apis/json-rpc/#default-block).
-2. `Boolean` - Bei `true` werden die vollständigen Transaktionsobjekte zurückgegeben, bei `false` nur die Hashes der Transaktionen.
+1. `QUANTITY|TAG` – eine Ganzzahl einer Blocknummer oder der String `"earliest"`, `"latest"`, `"pending"`, `"safe"` oder `"finalized"`, wie im [Block-Parameter](/developers/docs/apis/json-rpc/#block-parameter).
+2. `Boolean` – Wenn `true`, werden die vollständigen Transaktionsobjekte zurückgegeben, wenn `false`, nur die Hashes der Transaktionen.
```js
params: [
@@ -1138,12 +1220,13 @@ params: [
]
```
-**Rückgaben** Siehe [eth_getBlockByHash](#eth_getblockbyhash)
+**Rückgabewerte**
+Siehe [eth_getBlockByHash](#eth_getblockbyhash)
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":["0x1b4", true],"id":1}'
```
@@ -1153,39 +1236,43 @@ Ergebnis siehe [eth_getBlockByHash](#eth_getblockbyhash)
Gibt die Informationen über eine Transaktion zurück, die anhand des Transaktions-Hashs angefordert wurde.
+
+ Endpunkt im Playground ausprobieren
+
+
**Parameter**
-1. `DATA`, 32 Bytes - Hash einer Transaktion
+1. `DATA`, 32 Bytes – Hash einer Transaktion
```js
params: ["0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"]
```
-**Rückgaben**
+**Rückgabewerte**
-`Object` – ein Transaktionsobjekt oder `null`, wenn keine Transaktion gefunden wurde:
+`Object` – Ein Transaktionsobjekt oder `null`, wenn keine Transaktion gefunden wurde:
-- `blockHash`: `DATA`, 32 Bytes - Hash des Blocks, in dem sich diese Transaktion befand. `null`, wenn es aussteht.
-- `blockNumber`: `QUANTITY` - Blocknummer, in der sich diese Transaktion befand. `null`, wenn es aussteht.
-- `from`: `DATA`, 20 Bytes - Adresse des Senders.
-- `gas`: `QUANTITY` - Vom Sender bereitgestelltes Gas.
-- `gasPrice`: `QUANTITY` - Vom Sender bereitgestellter Gaspreis in Wei.
-- `hash`: `DATA`, 32 Bytes - Hash der Transaktion.
-- `input`: `DATA` - Die mit der Transaktion gesendeten Daten.
-- `nonce`: `QUANTITY` - Die Anzahl der von dem Sender vor dieser Transaktion durchgeführten Transaktionen.
-- `to`: `DATA`, 20 Bytes - Adresse des Empfängers. `null` wenn es sich um eine Vertragserstellungstransaktion handelt.
-- `transactionIndex`: `QUANTITY` - Ganzzahlwert der Transaktionsindexposition im Block. `null`, wenn es aussteht.
-- `value`: `QUANTITY` - Der übertragene Wert in Wei.
-- `v`: `QUANTITY` - ECDSA Wiederherstellungs-ID
-- `r`: `QUANTITY` - ECDSA Signatur r
-- `s`: `QUANTITY` - ECDSA Signatur s
+- `blockHash`: `DATA`, 32 Bytes – Hash des Blocks, in dem sich diese Transaktion befand. `null`, wenn sie aussteht.
+- `blockNumber`: `QUANTITY` – Blocknummer, in der sich diese Transaktion befand. `null`, wenn sie aussteht.
+- `from`: `DATA`, 20 Bytes – Adresse des Absenders.
+- `gas`: `QUANTITY` – vom Absender bereitgestelltes Gas.
+- `gasPrice`: `QUANTITY` – vom Absender bereitgestellter Gaspreis in Wei.
+- `hash`: `DATA`, 32 Bytes – Hash der Transaktion.
+- `input`: `DATA` – die mit der Transaktion gesendeten Daten.
+- `nonce`: `QUANTITY` – die Anzahl der Transaktionen, die vom Absender vor dieser getätigt wurden.
+- `to`: `DATA`, 20 Bytes – Adresse des Empfängers. `null`, wenn es sich um eine Vertragserstellungstransaktion handelt.
+- `transactionIndex`: `QUANTITY` – Ganzzahl der Indexposition der Transaktion im Block. `null`, wenn sie aussteht.
+- `value`: `QUANTITY` – in Wei übertragener Wert.
+- `v`: `QUANTITY` – ECDSA-Wiederherstellungs-ID
+- `r`: `QUANTITY` – ECDSA-Signatur r
+- `s`: `QUANTITY` – ECDSA-Signatur s
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionByHash","params":["0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"],"id":1}'
-// Result
+// Ergebnis
{
"jsonrpc":"2.0",
"id":1,
@@ -1212,10 +1299,14 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionByHash","param
Gibt Informationen über eine Transaktion nach dem Block-Hash und der Transaktionsindexposition zurück.
+
+ Endpunkt im Playground ausprobieren
+
+
**Parameter**
-1. `DATA`, 32 Bytes - Hash eines Blocks.
-2. `QUANTITY` - Ganzzahlwert der Transaktionsindexposition.
+1. `DATA`, 32 Bytes – Hash eines Blocks.
+2. `QUANTITY` – Ganzzahl der Indexposition der Transaktion.
```js
params: [
@@ -1224,7 +1315,8 @@ params: [
]
```
-**Rückgaben** Siehe [eth_getTransactionByHash](#eth_gettransactionbyhash)
+**Rückgabewerte**
+Siehe [eth_getTransactionByHash](#eth_gettransactionbyhash)
**Beispiel**
@@ -1239,10 +1331,14 @@ Ergebnis siehe [eth_getTransactionByHash](#eth_gettransactionbyhash)
Gibt Informationen über eine Transaktion nach der Blocknummer und der Transaktionsindexposition zurück.
+
+ Endpunkt im Playground ausprobieren
+
+
**Parameter**
-1. `QUANTITY|TAG` – eine Blocknummer oder der String `"earliest"`, `"latest"`, `"pending"`, `"safe"` oder `"finalized"`, wie im [Standardblockparameter](/developers/docs/apis/json-rpc/#default-block).
-2. `QUANTITY` - Die Transaktionsindexposition.
+1. `QUANTITY|TAG` – eine Blocknummer oder der String `"earliest"`, `"latest"`, `"pending"`, `"safe"` oder `"finalized"`, wie im [Block-Parameter](/developers/docs/apis/json-rpc/#block-parameter).
+2. `QUANTITY` – die Indexposition der Transaktion.
```js
params: [
@@ -1251,12 +1347,13 @@ params: [
]
```
-**Rückgaben** Siehe [eth_getTransactionByHash](#eth_gettransactionbyhash)
+**Rückgabewerte**
+Siehe [eth_getTransactionByHash](#eth_gettransactionbyhash)
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionByBlockNumberAndIndex","params":["0x9c47cf", "0x24"],"id":1}'
```
@@ -1270,39 +1367,40 @@ Gibt den Beleg einer Transaktion nach dem Transaktions-Hash zurück.
**Parameter**
-1. `DATA`, 32 Bytes - Hash einer Transaktion
+1. `DATA`, 32 Bytes – Hash einer Transaktion
```js
params: ["0x85d995eba9763907fdf35cd2034144dd9d53ce32cbec21349d4b12823c6860c5"]
```
-**Rückgaben** `Object` – ein Transaktionsbeleg-Objekt oder `null`, wenn kein Beleg gefunden wurde:
+**Rückgabewerte**
+`Object` – Ein Transaktionsbeleg-Objekt oder `null`, wenn kein Beleg gefunden wurde:
-- `transactionHash`: `DATA`, 32 Bytes - Hash der Transaktion.
-- `transactionIndex`: `QUANTITY` - Ganzzahlwert der Transaktionsindexposition im Block.
-- `blockHash`: `DATA`, 32 Bytes - Hash des Blocks, in dem sich diese Transaktion befand.
-- `blockNumber`: `QUANTITY` - Blocknummer, in der sich diese Transaktion befand.
-- `from`: `DATA`, 20 Bytes - Adresse des Senders.
-- `to`: `DATA`, 20 Bytes - Adresse des Empfängers. null, wenn es sich um eine Vertragserstellungstransaktion handelt.
-- `cumulativeGasUsed` : `QUANTITY` - Die Gesamtmenge an Gas, die bei Ausführung dieser Transaktion im Block verwendet wurde.
-- `effectiveGasPrice` : `QUANTITY` - Die Summe der Grundgebühr und der Tipp, die pro Einheit Gas bezahlt wurde.
-- `gasUsed`: `QUANTITY` - Die Menge an Gas, die von dieser bestimmten Transaktion allein verwendet wurde.
-- `contractAddress`: `DATA`, 20 Bytes - Die Vertragsadresse, die erstellt wurde, falls die Transaktion eine Vertragserstellung war, andernfalls `null`.
-- `logs`: `Array` - Array von Log-Objekten, die diese Transaktion generiert hat.
-- `logsBloom`: `DATA`, 256 Bytes - Bloom-Filter für leichte Clients, um schnell verwandte Logs abzurufen.
-- `type`: `QUANTITY` - Ganzzahlwert des Transaktionstyps, `0x0` für veraltete Transaktionen, `0x1` für Zugriffslistentypen, `0x2` für dynamische Gebühren.
+- `transactionHash `: `DATA`, 32 Bytes – Hash der Transaktion.
+- `transactionIndex`: `QUANTITY` – Ganzzahl der Indexposition der Transaktion im Block.
+- `blockHash`: `DATA`, 32 Bytes – Hash des Blocks, in dem sich diese Transaktion befand.
+- `blockNumber`: `QUANTITY` – Blocknummer, in der sich diese Transaktion befand.
+- `from`: `DATA`, 20 Bytes – Adresse des Absenders.
+- `to`: `DATA`, 20 Bytes – Adresse des Empfängers. null, wenn es sich um eine Vertragserstellungstransaktion handelt.
+- `cumulativeGasUsed` : `QUANTITY ` – die Gesamtmenge an Gas, die bei der Ausführung dieser Transaktion im Block verbraucht wurde.
+- `effectiveGasPrice` : `QUANTITY` – die Summe aus der Grundgebühr und dem pro Gaseinheit gezahlten Trinkgeld.
+- `gasUsed `: `QUANTITY ` – die Menge an Gas, die allein durch diese spezifische Transaktion verbraucht wurde.
+- `contractAddress `: `DATA`, 20 Bytes – die erstellte Vertragsadresse, wenn es sich bei der Transaktion um eine Vertragserstellung handelte, andernfalls `null`.
+- `logs`: `Array` – Array von Log-Objekten, die diese Transaktion generiert hat.
+- `logsBloom`: `DATA`, 256 Bytes – Bloom-Filter für Light Clients, um zugehörige Protokolle schnell abzurufen.
+- `type`: `QUANTITY` – Ganzzahl des Transaktionstyps, `0x0` für Legacy-Transaktionen, `0x1` für Zugriffstlistentypen, `0x2` für dynamische Gebühren.
-Es gibt auch _eines davon_ zurück:
+Es gibt auch eines davon zurück:
-- `root` : `DATA` 32 Bytes des vorherigen Transaktions-Stateroots (vor Byzantium)
-- `status`: `QUANTITY` entweder `1` (Erfolg) or `0` (Fehler)
+- `root` : `DATA` 32 Bytes des Post-Transaktions-Zustands-Roots (vor Byzanz)
+- `status`: `QUANTITY` entweder `1` (erfolgreich) oder `0` (fehlgeschlagen)
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionReceipt","params":["0x85d995eba9763907fdf35cd2034144dd9d53ce32cbec21349d4b12823c6860c5"],"id":1}'
-// Result
+// Ergebnis
{
"jsonrpc": "2.0",
"id": 1,
@@ -1310,15 +1408,15 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionReceipt","para
"blockHash":
"0xa957d47df264a31badc3ae823e10ac1d444b098d9b73d204c40426e57f47e8c3",
"blockNumber": "0xeff35f",
- "contractAddress": null, // string of the address if it was created
+ "contractAddress": null, // string der Adresse, wenn sie erstellt wurde
"cumulativeGasUsed": "0xa12515",
"effectiveGasPrice": "0x5a9c688d4",
"from": "0x6221a9c005f6e47eb398fd867784cacfdcfff4e7",
"gasUsed": "0xb4c8",
"logs": [{
- // logs as returned by getFilterLogs, etc.
+ // logs wie sie von getFilterLogs usw. zurückgegeben werden.
}],
- "logsBloom": "0x00...0", // 256 byte bloom filter
+ "logsBloom": "0x00...0", // 256-Byte-Bloom-Filter
"status": "0x1",
"to": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
"transactionHash":
@@ -1331,12 +1429,16 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionReceipt","para
### eth_getUncleByBlockHashAndIndex {#eth_getunclebyblockhashandindex}
-Gibt Informationen über einen Onkel eines Blocks nach Hash und Onkel-Indexposition zurück.
+Gibt Informationen über einen Uncle eines Blocks nach Hash und Uncle-Indexposition zurück.
+
+
+ Endpunkt im Playground ausprobieren
+
**Parameter**
-1. `DATA`, 32 Bytes - Der Hash eines Blocks.
-2. `QUANTITY` - Die Indexposition des Onkels.
+1. `DATA`, 32 Bytes – Der Hash eines Blocks.
+2. `QUANTITY` – die Indexposition des Uncle.
```js
params: [
@@ -1345,7 +1447,8 @@ params: [
]
```
-**Rückgaben** Siehe [eth_getBlockByHash](#eth_getblockbyhash)
+**Rückgabewerte**
+Siehe [eth_getBlockByHash](#eth_getblockbyhash)
**Beispiel**
@@ -1356,16 +1459,20 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleByBlockHashAndIndex"
Ergebnis siehe [eth_getBlockByHash](#eth_getblockbyhash)
-**Hinweis**: Ein Onkel enthält keine einzelnen Transaktionen.
+**Hinweis**: Ein Uncle enthält keine einzelnen Transaktionen.
### eth_getUncleByBlockNumberAndIndex {#eth_getunclebyblocknumberandindex}
-Gibt Informationen über einen Onkel eines Blocks nach Nummer und Onkel-Indexposition zurück.
+Gibt Informationen über einen Uncle eines Blocks nach Nummer und Uncle-Indexposition zurück.
+
+
+ Endpunkt im Playground ausprobieren
+
**Parameter**
-1. `QUANTITY|TAG` – eine Blocknummer oder der String `"earliest"`, `"latest"`, `"pending"`, `"safe"`, `"finalized"`, wie im [Standardblockparameter](/developers/docs/apis/json-rpc/#default-block).
-2. `QUANTITY` - Die Indexposition des Onkels.
+1. `QUANTITY|TAG` – eine Blocknummer oder der String `"earliest"`, `"latest"`, `"pending"`, `"safe"` oder `"finalized"`, wie im [Block-Parameter](/developers/docs/apis/json-rpc/#block-parameter).
+2. `QUANTITY` – die Indexposition des Uncle.
```js
params: [
@@ -1374,14 +1481,15 @@ params: [
]
```
-**Rückgaben** Siehe [eth_getBlockByHash](#eth_getblockbyhash)
+**Rückgabewerte**
+Siehe [eth_getBlockByHash](#eth_getblockbyhash)
-**Hinweis**: Ein Onkel enthält keine einzelnen Transaktionen.
+**Hinweis**: Ein Uncle enthält keine einzelnen Transaktionen.
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleByBlockNumberAndIndex","params":["0x29c", "0x0"],"id":1}'
```
@@ -1389,23 +1497,25 @@ Ergebnis siehe [eth_getBlockByHash](#eth_getblockbyhash)
### eth_newFilter {#eth_newfilter}
-Erstellt auf Basis von Filteroptionen ein Filterobjekt, um eine Benachrichtigung auszugeben, wenn sich der Status ändert (Protokolle). Um zu überprüfen, ob sich der Status geändert hat, rufen Sie [eth_getFilterChanges](#eth_getfilterchanges) auf.
+Erstellt auf Basis von Filteroptionen ein Filterobjekt, um eine Benachrichtigung auszugeben, wenn sich der Status ändert (Protokolle).
+Um zu prüfen, ob sich der Zustand geändert hat, rufen Sie [eth_getFilterChanges](#eth_getfilterchanges) auf.
-**Hinweis zum Festlegen von Themenfiltern:** Themen sind auftragsabhängig. Eine Transaktion mit einem Protokoll mit den Themen [A, B] wird mit den folgenden Themenfiltern abgeglichen:
+**Ein Hinweis zur Angabe von Themenfiltern:**
+Themen sind reihenfolgeabhängig. Eine Transaktion mit einem Protokoll mit den Themen [A, B] wird mit den folgenden Themenfiltern abgeglichen:
- `[]` „alles“
-- `[A]` „A an erster Stelle (und alles danach)“
-- `[null, B]` „Alles an erster Stelle UND B an zweiter Stelle (und alles danach)“
-- `[A, B]` „A an erster Stelle UND B an zweiter Stelle (und alles danach)“
-- `[[A, B], [A, B]]` „(A ODER B) an erster Stelle UND (A ODER B) an zweiter Stelle (und alles danach)“
+- `[A]` „A an erster Position (und alles danach)“
+- `[null, B]` „alles an erster Position UND B an zweiter Position (und alles danach)“
+- `[A, B]` „A an erster Position UND B an zweiter Position (und alles danach)“
+- `[[A, B], [A, B]]` „(A ODER B) an erster Position UND (A ODER B) an zweiter Position (und alles danach)“
- **Parameter**
-1. `Object` – die Filteroptionen:
+1. `Object` – Die Filteroptionen:
-- `fromBlock`: `QUANTITY|TAG` – (optional, standardmäßig: `"latest"`) ganzzahlige Blocknummer oder `"latest"` für den letzten vorgeschlagenen Block, `"safe"` für den letzten sicheren Block, `"finalized"` für den letzten abgeschlossenen Block oder `"pending"`, `"earliest"` für Transaktionen, die noch nicht in einem Block sind.
-- `toBlock`: `QUANTITY|TAG` – (optional, standardmäßig: `"latest"`) ganzzahlige Blocknummer oder `"latest"` für den letzten vorgeschlagenen Block, `"safe"` für den letzten sicheren Block, `"finalized"` für den letzten abgeschlossenen Block oder `"pending"`, `"earliest"` für Transaktionen, die noch nicht in einem Block sind.
-- `Adresse`: `DATA|Array`, 20 Bytes - (Optional) Vertragsadresse oder eine Liste von Adressen, von denen Protokolle stammen sollen.
-- `topics`: `Array of DATA`, - (Optional) Array von 32 Bytes `DATA`-Themen. Themen sind auftragsabhängig. Jedes Thema kann auch ein Array von DATEN mit „oder“-Optionen sein.
+- `fromBlock`: `QUANTITY|TAG` – (optional, Standard: `"latest"`) ganzzahlige Blocknummer oder `"latest"` für den letzten vorgeschlagenen Block, `"safe"` für den letzten sicheren Block, `"finalized"` für den letzten finalisierten Block oder `"pending"`, `"earliest"` für Transaktionen, die noch nicht in einem Block sind.
+- `toBlock`: `QUANTITY|TAG` – (optional, Standard: `"latest"`) ganzzahlige Blocknummer oder `"latest"` für den letzten vorgeschlagenen Block, `"safe"` für den letzten sicheren Block, `"finalized"` für den letzten finalisierten Block oder `"pending"`, `"earliest"` für Transaktionen, die noch nicht in einem Block sind.
+- `address`: `DATA|Array`, 20 Bytes – (optional) Vertragsadresse oder eine Liste von Adressen, von denen Protokolle stammen sollen.
+- `topics`: `Array von DATA`, – (optional) Array von 32 Bytes `DATA` Themen. Themen sind auftragsabhängig. Jedes Thema kann auch ein Array von DATEN mit „oder“-Optionen sein.
```js
params: [
@@ -1425,14 +1535,15 @@ params: [
]
```
-**Rückgaben** `QUANTITY` – eine Filter-ID.
+**Rückgabewerte**
+`QUANTITY` – eine Filter-ID.
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newFilter","params":[{"topics":["0x12341234"]}],"id":73}'
-// Result
+// Ergebnis
{
"id":1,
"jsonrpc": "2.0",
@@ -1442,18 +1553,21 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newFilter","params":[{"topic
### eth_newBlockFilter {#eth_newblockfilter}
-Erstellt einen Filter im Knoten, um eine Benachrichtigung auszugeben, wenn ein neuer Block eintrifft. Um zu überprüfen, ob sich der Status geändert hat, rufen Sie [eth_getFilterChanges](#eth_getfilterchanges) auf.
+Erstellt einen Filter im Knoten, um eine Benachrichtigung auszugeben, wenn ein neuer Block eintrifft.
+Um zu prüfen, ob sich der Zustand geändert hat, rufen Sie [eth_getFilterChanges](#eth_getfilterchanges) auf.
-**Parameter** Keine
+**Parameter**
+Keine
-**Rückgaben** `QUANTITY` – eine Filter-ID.
+**Rückgabewerte**
+`QUANTITY` – eine Filter-ID.
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newBlockFilter","params":[],"id":73}'
-// Result
+// Ergebnis
{
"id":1,
"jsonrpc": "2.0",
@@ -1463,18 +1577,21 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newBlockFilter","params":[],
### eth_newPendingTransactionFilter {#eth_newpendingtransactionfilter}
-Erstellt einen Filter im Knoten, um eine Benachrichtigung auszugeben, wenn eine neue ausstehende Transaktionen eintrifft. Um zu überprüfen, ob sich der Status geändert hat, rufen Sie [eth_getFilterChanges](#eth_getfilterchanges) auf.
+Erstellt einen Filter im Knoten, um eine Benachrichtigung auszugeben, wenn eine neue ausstehende Transaktionen eintrifft.
+Um zu prüfen, ob sich der Zustand geändert hat, rufen Sie [eth_getFilterChanges](#eth_getfilterchanges) auf.
-**Parameter** Keine
+**Parameter**
+Keine
-**Rückgaben** `QUANTITY` – eine Filter-ID.
+**Rückgabewerte**
+`QUANTITY` – eine Filter-ID.
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newPendingTransactionFilter","params":[],"id":73}'
-// Result
+// Ergebnis
{
"id":1,
"jsonrpc": "2.0",
@@ -1484,11 +1601,12 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newPendingTransactionFilter"
### eth_uninstallFilter {#eth_uninstallfilter}
-Deinstalliert einen Filter mit angegebener ID. Sollte immer aufgerufen werden, wenn die Uhr nicht mehr benötigt wird. Zusätzlich Timeout für Filter, wenn sie für einen bestimmten Zeitraum nicht mit [eth_getFilterChanges](#eth_getfilterchanges) angefordert werden.
+Deinstalliert einen Filter mit angegebener ID. Sollte immer aufgerufen werden, wenn die Uhr nicht mehr benötigt wird.
+Zusätzlich kommt es bei Filtern zu einem Timeout, wenn sie für einen bestimmten Zeitraum nicht mit [eth_getFilterChanges](#eth_getfilterchanges) angefordert werden.
**Parameter**
-1. `QUANTITY` – die Filter-ID.
+1. `QUANTITY` – Die Filter-ID.
```js
params: [
@@ -1496,14 +1614,15 @@ params: [
]
```
-**Rückgabewerte** `Boolean` – `true`, wenn der Filter erfolgreich deinstalliert wurde, andernfalls `false`.
+**Rückgabewerte**
+`Boolean` – `true`, wenn der Filter erfolgreich deinstalliert wurde, andernfalls `false`.
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_uninstallFilter","params":["0xb"],"id":73}'
-// Result
+// Ergebnis
{
"id":1,
"jsonrpc": "2.0",
@@ -1525,26 +1644,30 @@ params: [
]
```
-**Rückgabewerte** `Array` – Array von Protokollobjekten oder ein leeres Array, wenn sich seit der letzten Umfrage nichts geändert hat.
+**Rückgabewerte**
+`Array` – Array von Protokollobjekten oder ein leeres Array, wenn sich seit der letzten Abfrage nichts geändert hat.
+
+- Für mit `eth_newBlockFilter` erstellte Filter sind die Rückgabewerte Block-Hashes (`DATA`, 32 Bytes), z. B. `["0x3454645634534..."]`.
+
+- Für mit `eth_newPendingTransactionFilter` erstellte Filter sind die Rückgabewerte Transaktions-Hashes (`DATA`, 32 Bytes), z. B. `["0x6345343454645..."]`.
-- Für mit `eth_newBlockFilter` erstellte Filter sind die Rückgabewerte Block-Hashes (`DATA`, 32 Bytes), z. `["0x3454645634534..."]`.
-- Für Filter, die mit `eth_newPendingTransactionFilter` erstellt wurden, sind die Rückgabewerte Transaktions-Hashes (`DATA`, 32 Bytes), z. `["0x6345343454645..."]`.
- Für mit `eth_newFilter` erstellte Filter sind Protokolle Objekte mit folgenden Parametern:
- - `removed`: `TAG` - `true`, als das Protokoll aufgrund einer Neustrukturierung der Blockchain entfernt wurde. `false`, wenn es sich um ein gültiges Protokoll handelt.
- - `logIndex`: `QUANTITY` – Ganzzahlwert der Protokollindexposition im Block. `null`, wenn es sich um ein ausstehendes Protokoll handelt.
- - `transactionIndex`: `QUANTITY` - Ganzzahlwert der Transaktionsindexposition, aus der das Protokoll erstellt wurde. `null`, wenn es sich um ein ausstehendes Protokoll handelt.
- - `transactionHash`: `DATA`, 32 Bytes - Hash der Transaktionen, aus denen dieses Protokoll erstellt wurde. `null`, wenn es sich um ein ausstehendes Protokoll handelt.
- - `blockHash`: `DATA`, 32 Bytes - Hash des Blocks, in dem sich dieses Protokoll befand. `null`, wenn es aussteht. `null`, wenn es sich um ein ausstehendes Protokoll handelt.
- - `blockNumber`: `QUANTITY` - Die Blocknummer, in der sich dieses Protokoll befand. `null`, wenn es aussteht. `null`, wenn es sich um ein ausstehendes Protokoll handelt.
- - `Adresse`: `DATA`, 20 Bytes - Adresse, von der dieses Protokoll stammt.
- - `data`: `DATA` – enthält null oder mehr 32 Byte nicht indizierte Argumente des Protokolls.
- - `topics`: `Array of DATA` - Array von 0 bis 4 32 Bytes `DATA` von indizierten Protokollargumenten. (In _Solidity_: Das erste Thema ist der _Hash_ der Signatur des Ereignisses (z. B. `Deposit (address,bytes32,uint256)`), es sei denn, Sie haben das Ereignis mit dem `anonymous`-Spezifizierer deklariert.)
+ - `removed`: `TAG` – `true`, wenn das Protokoll aufgrund einer Reorganisation der Kette entfernt wurde. `false`, wenn es sich um ein gültiges Protokoll handelt.
+ - `logIndex`: `QUANTITY` – Ganzzahl der Protokollindexposition im Block. `null`, wenn es sich um ein ausstehendes Protokoll handelt.
+ - `transactionIndex`: `QUANTITY` – Ganzzahl der Indexposition der Transaktion, aus der das Protokoll erstellt wurde. `null`, wenn es sich um ein ausstehendes Protokoll handelt.
+ - `transactionHash`: `DATA`, 32 Bytes – Hash der Transaktionen, aus denen dieses Protokoll erstellt wurde. `null`, wenn es sich um ein ausstehendes Protokoll handelt.
+ - `blockHash`: `DATA`, 32 Bytes – Hash des Blocks, in dem sich dieses Protokoll befand. `null`, wenn sie aussteht. `null`, wenn es sich um ein ausstehendes Protokoll handelt.
+ - `blockNumber`: `QUANTITY` – die Blocknummer, in der sich dieses Protokoll befand. `null`, wenn sie aussteht. `null`, wenn es sich um ein ausstehendes Protokoll handelt.
+ - `address`: `DATA`, 20 Bytes – Adresse, von der dieses Protokoll stammt.
+ - `data`: `DATA` – nicht indizierte Protokolldaten mit variabler Länge. (In _Solidity_: null oder mehr nicht indizierte 32-Byte-Protokollargumente.)
+ - `topics`: `Array von DATA` – Array von 0 bis 4 32 Bytes `DATA` von indizierten Protokollargumenten. (In _Solidity_: Das erste Thema ist der _Hash_ der Signatur des Ereignisses (z. B. `Deposit(address,bytes32,uint256)`), es sei denn, Sie haben das Ereignis mit dem `anonymous`-Spezifizierer deklariert.)
+
- **Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getFilterChanges","params":["0x16"],"id":73}'
-// Result
+// Ergebnis
{
"id":1,
"jsonrpc":"2.0",
@@ -1569,7 +1692,7 @@ Gibt ein Array aller Protokolle zurück, die dem Filter mit der angegebenen ID e
**Parameter**
-1. `QUANTITY` – die Filter-ID.
+1. `QUANTITY` – Die Filter-ID.
```js
params: [
@@ -1577,12 +1700,13 @@ params: [
]
```
-**Rückgabewerte** Siehe [eth_getFilterChanges](#eth_getfilterchanges)
+**Rückgabewerte**
+Siehe [eth_getFilterChanges](#eth_getfilterchanges)
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getFilterLogs","params":["0x16"],"id":74}'
```
@@ -1594,13 +1718,13 @@ Gibt ein Array aller Protokolle zurück, die einem angegebenen Filterobjekt ents
**Parameter**
-1. `Object` – die Filteroptionen:
+1. `Object` – Die Filteroptionen:
-- `fromBlock`: `QUANTITY|TAG` – (optional, standardmäßig: `"latest"`) ganzzahlige Blocknummer oder `"latest"` für den letzten vorgeschlagenen Block, `"safe"` für den letzten sicheren Block, `"finalized"` für den letzten abgeschlossenen Block oder `"pending"`, `"earliest"` für Transaktionen, die noch nicht in einem Block sind.
-- `toBlock`: `QUANTITY|TAG` – (optional, standardmäßig: `"latest"`) ganzzahlige Blocknummer oder `"latest"` für den letzten vorgeschlagenen Block, `"safe"` für den letzten sicheren Block, `"finalized"` für den letzten abgeschlossenen Block oder `"pending"`, `"earliest"` für Transaktionen, die noch nicht in einem Block sind.
-- `Adresse`: `DATA|Array`, 20 Bytes - (Optional) Vertragsadresse oder eine Liste von Adressen, von denen Protokolle stammen sollen.
-- `topics`: `Array of DATA`, - (Optional) Array von 32 Bytes `DATA`-Themen. Themen sind auftragsabhängig. Jedes Thema kann auch ein Array von DATEN mit „oder“-Optionen sein.
-- `blockhash`: `DATA`, 32 Bytes - (optional, **future**) Mit dem Hinzufügen von EIP-234 wird `blockHash` eine neue Filteroption sein, die die zurückgegebenen Protokolle auf den einzelnen Block mit dem 32-Byte-Hash `blockHash` beschränkt. Die Verwendung von `blockHash` entspricht `fromBlock` = `toBlock` = die Blocknummer mit Hash `blockHash`. Wenn `blockHash` in den Filterkriterien vorhanden ist, sind weder `fromBlock` noch `toBlock` zulässig.
+- `fromBlock`: `QUANTITY|TAG` – (optional, Standard: `"latest"`) ganzzahlige Blocknummer oder `"latest"` für den letzten vorgeschlagenen Block, `"safe"` für den letzten sicheren Block, `"finalized"` für den letzten finalisierten Block oder `"pending"`, `"earliest"` für Transaktionen, die noch nicht in einem Block sind.
+- `toBlock`: `QUANTITY|TAG` – (optional, Standard: `"latest"`) ganzzahlige Blocknummer oder `"latest"` für den letzten vorgeschlagenen Block, `"safe"` für den letzten sicheren Block, `"finalized"` für den letzten finalisierten Block oder `"pending"`, `"earliest"` für Transaktionen, die noch nicht in einem Block sind.
+- `address`: `DATA|Array`, 20 Bytes – (optional) Vertragsadresse oder eine Liste von Adressen, von denen Protokolle stammen sollen.
+- `topics`: `Array von DATA`, – (optional) Array von 32 Bytes `DATA` Themen. Themen sind auftragsabhängig. Jedes Thema kann auch ein Array von DATEN mit „oder“-Optionen sein.
+- `blockHash`: `DATA`, 32 Bytes – (optional, **zukünftig**) Mit der Hinzufügung von EIP-234 wird `blockHash` eine neue Filteroption sein, die die zurückgegebenen Protokolle auf den einzelnen Block mit dem 32-Byte-Hash `blockHash` beschränkt. Die Verwendung von `blockHash` ist äquivalent zu `fromBlock` = `toBlock` = der Blocknummer mit dem Hash `blockHash`. Wenn `blockHash` in den Filterkriterien vorhanden ist, sind weder `fromBlock` noch `toBlock` erlaubt.
```js
params: [
@@ -1612,12 +1736,13 @@ params: [
]
```
-**Rückgabewerte** Siehe [eth_getFilterChanges](#eth_getfilterchanges)
+**Rückgabewerte**
+Siehe [eth_getFilterChanges](#eth_getfilterchanges)
**Beispiel**
```js
-// Request
+// Anfrage
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getLogs","params":[{"topics":["0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"]}],"id":74}'
```
@@ -1625,11 +1750,11 @@ Ergebnis siehe [eth_getFilterChanges](#eth_getfilterchanges)
## Anwendungsbeispiel {#usage-example}
-### Einen Contract mit JSON_RPC bereitstellen {#deploying-contract}
+### Bereitstellen eines Vertrags mittels JSON-RPC {#deploying-contract}
-Dieser Abschnitt enthält eine Demonstration, wie ein Contract nur mithilfe der RPC-Schnittstelle bereitgestellt wird. Es gibt alternative Wege zur Bereitstellung von Contracts, bei denen diese Komplexität abstrahiert wird – zum Beispiel die Verwendung von Bibliotheken, die auf der RPC-Schnittstelle wie [web3.js](https://web3js.readthedocs.io/) und [web3.py](https://github.com/ethereum/web3.py) aufbauen. Diese Abstraktionen sind im Allgemeinen leichter zu verstehen und weniger fehleranfällig, es ist dennoch hilfreich, zu verstehen, was im Hintergrund passiert.
+Dieser Abschnitt enthält eine Demonstration, wie ein Contract nur mithilfe der RPC-Schnittstelle bereitgestellt wird. Es gibt alternative Wege zur Bereitstellung von Verträgen, bei denen diese Komplexität abstrahiert wird – zum Beispiel die Verwendung von Bibliotheken, die auf der RPC-Schnittstelle aufbauen, wie [web3.js](https://web3js.readthedocs.io/) und [web3.py](https://github.com/ethereum/web3.py). Diese Abstraktionen sind im Allgemeinen leichter zu verstehen und weniger fehleranfällig, es ist dennoch hilfreich, zu verstehen, was im Hintergrund passiert.
-Das Folgende ist ein unkomplizierter Smart Contract namens `Multiply7`, der über die JSON-RPC-Schnittstelle auf einem Ethereum-Knoten bereitgestellt wird. Dieses Tutorial geht davon aus, dass der Reader bereits einen Geth-Knoten ausführt. Weitere Informationen zu Nodes und Clients finden Sie [hier](/developers/docs/nodes-and-clients/run-a-node). Bitte sehen Sie in der jeweiligen [Client](/developers/docs/nodes-and-clients/)-Dokumentation nach, wie Sie den HTTP-JSON-RPC für Nicht-Geth-Clients starten. Die meisten Clients werden standardmäßig auf `localhost:8545` ausgeführt.
+Das Folgende ist ein unkomplizierter Smart Contract namens `Multiply7`, der über die JSON-RPC-Schnittstelle auf einem Ethereum-Knoten bereitgestellt wird. Dieses Tutorial geht davon aus, dass der Reader bereits einen Geth-Knoten ausführt. Weitere Informationen zu Nodes und Clients finden Sie [hier](/developers/docs/nodes-and-clients/run-a-node). Bitte sehen Sie in der jeweiligen [Client](/developers/docs/nodes-and-clients/)-Dokumentation nach, wie Sie den HTTP-JSON-RPC für Nicht-Geth-Clients starten. Die meisten Clients werden standardmäßig auf `localhost:8545` bereitgestellt.
```javascript
contract Multiply7 {
@@ -1649,10 +1774,10 @@ geth --http --dev console 2>>geth.log
Dadurch wird die HTTP-RPC-Schnittstelle auf `http://localhost:8545` gestartet.
-Wir können überprüfen, ob die Schnittstelle läuft, indem wir die Coinbase-Adresse und den Saldo mit [curl](https://curl.se) abrufen. Bitte beachten Sie, dass sich die Daten in diesen Beispielen auf Ihrem lokalen Knoten unterscheiden. Wenn Sie diese Befehle ausprobieren möchten, ersetzen Sie die Anfrageparameter in der zweiten Curl-Anfrage durch das Ergebnis, das von der ersten zurückgegeben wird.
+Wir können überprüfen, ob die Schnittstelle läuft, indem wir die Coinbase-Adresse (die erste Adresse aus dem Array der Konten) und das Guthaben mithilfe von [curl](https://curl.se) abrufen. Bitte beachten Sie, dass sich die Daten in diesen Beispielen auf Ihrem lokalen Knoten unterscheiden. Wenn Sie diese Befehle ausprobieren möchten, ersetzen Sie die Anfrageparameter in der zweiten Curl-Anfrage durch das Ergebnis, das von der ersten zurückgegeben wird.
```bash
-curl --data '{"jsonrpc":"2.0","method":"eth_coinbase", "id":1}' -H "Content-Type: application/json" localhost:8545
+curl --data '{"jsonrpc":"2.0","method":"eth_accounts","params":[], "id":1}' -H "Content-Type: application/json" localhost:8545
{"id":1,"jsonrpc":"2.0","result":["0x9b1d35635cc34752ca54713bb99d38614f63c955"]}
curl --data '{"jsonrpc":"2.0","method":"eth_getBalance", "params": ["0x9b1d35635cc34752ca54713bb99d38614f63c955", "latest"], "id":2}' -H "Content-Type: application/json" localhost:8545
@@ -1666,15 +1791,15 @@ web3.fromWei("0x1639e49bba16280000", "ether")
// "410"
```
-Jetzt, da es etwas Ether in unserer privaten Entwicklungs-Kette gibt, können wir den Contract bereitstellen. Der erste Schritt besteht darin, den Multiply7-Contract in Bytecode zu kompilieren, der an die EVM gesendet werden kann. Um Solc, den Solidity-Compiler, zu installieren, folgen Sie der [Solidity-Dokumentation](https://docs.soliditylang.org/en/latest/installing-solidity.html). (Möglicherweise möchten Sie eine ältere `solc`-Version verwenden, um der [Version des verwendeten Compilers für unser Beispiel zu entsprechen](https://github.com/ethereum/solidity/releases/tag/v0.4.20).)
+Jetzt, da es etwas Ether in unserer privaten Entwicklungs-Kette gibt, können wir den Contract bereitstellen. Der erste Schritt besteht darin, den Multiply7-Contract in Bytecode zu kompilieren, der an die EVM gesendet werden kann. Um solc, den Solidity-Compiler, zu installieren, folgen Sie der [Solidity-Dokumentation](https://docs.soliditylang.org/en/latest/installing-solidity.html). (Möglicherweise möchten Sie eine ältere `solc`-Version verwenden, um der [Version des für unser Beispiel verwendeten Compilers](https://github.com/ethereum/solidity/releases/tag/v0.4.20) zu entsprechen.)
-Der nächste Schritt besteht darin, den Multiply7-Contract in Bytecode zu kompilieren, der an die EVM gesendet werden kann.
+Der nächste Schritt besteht darin, den Multiply7-Vertrag in Bytecode zu kompilieren, der an die EVM gesendet werden kann.
```bash
echo 'pragma solidity ^0.4.16; contract Multiply7 { event Print(uint); function multiply(uint input) public returns (uint) { Print(input * 7); return input * 7; } }' | solc --bin
======= :Multiply7 =======
-Binary:
+Binär:
6060604052341561000f57600080fd5b60eb8061001d6000396000f300606060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063c6888fa1146044575b600080fd5b3415604e57600080fd5b606260048080359060200190919050506078565b6040518082815260200191505060405180910390f35b60007f24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da600783026040518082815260200191505060405180910390a16007820290509190505600a165627a7a7230582040383f19d9f65246752244189b02f56e8d0980ed44e7a56c0b200458caad20bb0029
```
@@ -1699,13 +1824,13 @@ curl --data '{"jsonrpc":"2.0","method": "eth_getTransactionReceipt", "params": [
{"jsonrpc":"2.0","id":7,"result":{"blockHash":"0x77b1a4f6872b9066312de3744f60020cbd8102af68b1f6512a05b7619d527a4f","blockNumber":"0x1","contractAddress":"0x4d03d617d700cf81935d7f797f4e2ae719648262","cumulativeGasUsed":"0x1c31e","from":"0x9b1d35635cc34752ca54713bb99d38614f63c955","gasUsed":"0x1c31e","logs":[],"logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","status":"0x1","to":null,"transactionHash":"0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf","transactionIndex":"0x0"}}
```
-Unser Contract wurde am `0x4d03d617d700cf81935d7f797f4e2ae719648262` erstellt. Ein Nullergebnis anstelle eines Belegs bedeutet, dass die Transaktion noch nicht in einen Block aufgenommen wurde. Warten Sie einen Moment, prüfen Sie, ob Ihr Konsens-Client ausgeführt wird, und versuchen Sie es erneut.
+Unser Vertrag wurde auf `0x4d03d617d700cf81935d7f797f4e2ae719648262` erstellt. Ein Nullergebnis anstelle eines Belegs bedeutet, dass die Transaktion noch nicht in einen Block aufgenommen wurde. Warten Sie einen Moment, prüfen Sie, ob Ihr Konsens-Client ausgeführt wird, und versuchen Sie es erneut.
#### Interaktion mit Smart Contracts {#interacting-with-smart-contract}
-In diesem Beispiel senden wir eine Transaktion mit `eth_sendTransaction` an die Methode `multiply` des Contracts.
+In diesem Beispiel werden wir eine Transaktion mit `eth_sendTransaction` an die `multiply`-Methode des Vertrags senden.
-`eth_sendTransaction` erfordert mehrere Argumente, speziell `from`, `to` und `data`. `From` ist die öffentliche Adresse unseres Kontos und `to` ist die Contract-Adresse. Das Argument `data` enthält eine Nutzlast, die definiert, welche Methode mit welchen Argumenten aufgerufen werden muss. An dieser Stelle kommt die [ABI (Application Binary Interface – binäre Anwendungsschnittstelle)](https://docs.soliditylang.org/en/latest/abi-spec.html) ins Spiel. Die ABI ist eine JSON-Datei, die festlegt, wie Daten für die EVM definiert und kodiert werden.
+`eth_sendTransaction` erfordert mehrere Argumente, insbesondere `from`, `to` und `data`. `From` ist die öffentliche Adresse unseres Kontos und `to` ist die Vertragsadresse. Das Argument `data` enthält eine Nutzlast, die definiert, welche Methode mit welchen Argumenten aufgerufen werden muss. Hier kommt das [ABI (Application Binary Interface)](https://docs.soliditylang.org/en/latest/abi-spec.html) ins Spiel. Die ABI ist eine JSON-Datei, die festlegt, wie Daten für die EVM definiert und kodiert werden.
Die Byte der Nutzlast definieren, welche Methode im Contract aufgerufen wird. Das sind die ersten 4 Byte aus dem Keccak-Hash über den Funktionsnamen und seine Argumenttypen, Hex-codiert. Die Multiplizieren-Funktion akzeptiert ein uint, welches ein Alias für uint256 ist. Damit bleibt uns:
@@ -1714,13 +1839,13 @@ web3.sha3("multiply(uint256)").substring(0, 10)
// "0xc6888fa1"
```
-Der nächste Schritt besteht darin, die Argumente zu codieren. Es gibt nur einen uint256, beispielsweise den Wert 6. Die ABI hat einen Abschnitt, der angibt, wie uint256-Typen codiert werden.
+Der nächste Schritt besteht darin, die Argumente zu kodieren. Es gibt nur einen uint256, beispielsweise den Wert 6. Die ABI hat einen Abschnitt, der angibt, wie uint256-Typen codiert werden.
-`int: enc(X)` ist die Big-Endian-Zweierkomplementcodierung von X, aufgefüllt auf der Seite höherer Ordnung (links) mit 0xff für negatives X und mit null > Byte für positives X, sodass die Länge ein Vielfaches von 32 Byte ist.
+`int: enc(X)` ist die Big-Endian-Zweierkomplement-Kodierung von X, die auf der höherwertigen (linken) Seite mit 0xff für negatives X und mit Null-Bytes für positives X aufgefüllt wird, so dass die Länge ein Vielfaches von 32 Bytes ist.
-Dies wird zu `0000000000000000000000000000000000000000000000000000000000006` codiert.
+Dies kodiert zu `0000000000000000000000000000000000000000000000000000000000000006`.
-Durch die Kombination des Funktionsselektors und des codierten Arguments werden unsere Daten zu `0xc6888fa10000000000000000000000000000000000000000000000000000000000006`.
+Durch die Kombination des Funktionsselektors und des kodierten Arguments lauten unsere Daten `0xc6888fa10000000000000000000000000000000000000000000000000000000000000006`.
Dies kann nun an den Knoten gesendet werden:
@@ -1753,7 +1878,7 @@ Da eine Transaktion gesendet wurde, wurde ein Transaktions-Hash zurückgegeben.
}
```
-Der Beleg enthält ein Protokoll. Dieses Protokoll wurde von der EVM bei der Transaktionsausführung generiert und in den Beleg aufgenommen. Die Funktion `multiply` zeigt, dass das Ereignis `Print` mit der Eingabe mal 7 ausgelöst wurde. Da das Argument für das Ereignis `Print` ein uint256 war, können wir es gemäß den ABI-Regeln dekodieren, was zu der erwarteten Dezimalzahl 42 führt. Abgesehen von den Daten ist es erwähnenswert, dass Themen verwendet werden können, um festzustellen, welches Ereignis das Protokoll erstellt hat:
+Der Beleg enthält ein Protokoll. Dieses Protokoll wurde von der EVM bei der Transaktionsausführung generiert und in den Beleg aufgenommen. Die `multiply`-Funktion zeigt, dass das `Print`-Ereignis mit der Eingabe mal 7 ausgelöst wurde. Da das Argument für das `Print`-Ereignis ein uint256 war, können wir es gemäß den ABI-Regeln dekodieren, was zu der erwarteten Dezimalzahl 42 führt. Abgesehen von den Daten ist es erwähnenswert, dass Themen verwendet werden können, um festzustellen, welches Ereignis das Protokoll erstellt hat:
```javascript
web3.sha3("Print(uint256)")
@@ -1765,7 +1890,7 @@ Das war nur eine kurze Einführung in einige der häufigsten Aufgaben, die die d
## Verwandte Themen {#related-topics}
- [JSON-RPC-Spezifikation](http://www.jsonrpc.org/specification)
-- [Knotenpunkte und Clients](/developers/docs/nodes-and-clients/)
+- [Nodes und Clients](/developers/docs/nodes-and-clients/)
- [JavaScript-APIs](/developers/docs/apis/javascript/)
- [Backend-APIs](/developers/docs/apis/backend/)
-- [Ausführende Clients](/developers/docs/nodes-and-clients/#execution-clients)
+- [Ausführungs-Clients](/developers/docs/nodes-and-clients/#execution-clients)
diff --git a/public/content/translations/de/developers/docs/blocks/index.md b/public/content/translations/de/developers/docs/blocks/index.md
index 8729bdf88cc..e43277f95ce 100644
--- a/public/content/translations/de/developers/docs/blocks/index.md
+++ b/public/content/translations/de/developers/docs/blocks/index.md
@@ -8,13 +8,14 @@ Blöcke sind Stapel von Transaktionen mit einem Hash des vorherigen Blocks in de
## Voraussetzungen {#prerequisites}
-Blöcke sind ein sehr anfängerfreundliches Thema. Um dir jedoch zu helfen, diese Seite besser zu verstehen, empfehlen wir, zuerst [ Konten](/developers/docs/accounts/), [Transaktionen](/developers/docs/transactions/) und unsere [Einführung in Ethereum](/developers/docs/intro-to-ethereum/) zu lesen.
+Blöcke sind ein sehr anfängerfreundliches Thema. Um diese Seite besser zu verstehen, empfehlen wir Ihnen jedoch, zuerst [Konten](/developers/docs/accounts/), [Transaktionen](/developers/docs/transactions/) und unsere [Einführung in Ethereum](/developers/docs/intro-to-ethereum/) zu lesen.
## Warum Blöcke? {#why-blocks}
Um sicherzustellen, dass alle Teilnehmer des Ethereum-Netzwerks einen synchronisierten Zustand beibehalten und sich über den genauen Verlauf der Transaktionen einig sind, fassen wir die Transaktionen in Blöcken zusammen. Das bedeutet, dass Dutzende (oder Hunderte) von Transaktionen in einem Durchgang übergeben, bestätigt und synchronisiert werden.
- _Diagramm angepasst von [Ethereum EVM illustriert](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+
+_Diagramm adaptiert von [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
Durch die zeitliche Verteilung der Commits geben wir allen Netzwerkteilnehmern genügend Zeit, einen Konsens zu erzielen: Obwohl Transaktionsanfragen dutzende Male pro Sekunde erfolgen, werden Blöcke auf Ethereum nur alle zwölf Sekunden erstellt und festgeschrieben.
@@ -24,7 +25,7 @@ Um die Transaktionsgeschichte zu erhalten, sind Blöcke streng sortiert (jeder n
Sobald ein Block von einem zufällig ausgewählten Validator im Netzwerk erstellt wird, wird er im gesamten Netzwerk verbreitet. Alle Knoten fügen diesen Block dann am Ende ihrer Blockchain hinzu und ein neuer Validator wird ausgewählt, um den nächsten Block zu erstellen. Der genaue Prozess der Blockzusammenstellung und Festlegung/Konsensbildung ist zurzeit in Ethereums Proof-of-Stake-Protokoll festgelegt.
-## Proof-of-Stake-Protokoll {#proof-of-work-protocol}
+## Proof-of-Stake-Protokoll {#proof-of-stake-protocol}
Proof-of-Stake bedeutet Folgendes:
@@ -33,30 +34,30 @@ Proof-of-Stake bedeutet Folgendes:
- Andere Validatoren, die von dem neuen Block erfahren, führen die Transaktionen erneut aus, um sicherzustellen, dass sie der vorgeschlagenen Änderung des globalen Zustands zustimmen. In der Annahme, dass der Block gültig ist, fügen sie ihn zu ihrer eigenen Datenbank hinzu.
- Wenn ein Validator von zwei konkurrierenden Blöcken für denselben Slot erfährt, wählt er mit seinem Fork-Wahlalgorithmus den Block aus, der von den meisten eingesetzten ETH unterstützt wird.
-[Mehr über Proof-of-Stake](/developers/docs/consensus-mechanisms/pos)
+[Mehr zu Proof-of-Stake](/developers/docs/consensus-mechanisms/pos)
## Was enthält ein Block? {#block-anatomy}
Ein Block enthält viele verschiedene Informationen. Auf oberster Ebene enthält ein Block folgende Felder:
-| Feld | Beschreibung |
-|:------------------- |:----------------------------------------------------------- |
-| `Zeitspanne (Slot)` | Der Slot, zu dem der Block gehört |
-| `proposer_index` | Die ID des Validators, der den Block vorschlägt |
-| `parent_root` | Der Hash des vorausgehenden Blocks |
-| `state_root` | Der Stamm-Hash des Zustandsobjekts |
-| `hauptteil` | Ein Objekt, das mehrere Felder enthält, wie unten definiert |
+| Feld | Beschreibung |
+| :--------------- | :---------------------------------------------------------- |
+| `slot` | Der Slot, zu dem der Block gehört |
+| `proposer_index` | Die ID des Validators, der den Block vorschlägt |
+| `parent_root` | Der Hash des vorausgehenden Blocks |
+| `state_root` | Der Stamm-Hash des Zustandsobjekts |
+| `hauptteil` | Ein Objekt, das mehrere Felder enthält, wie unten definiert |
-Der `Body` eines Blocks enthält selbst mehrere Felder:
+Der `body` eines Blocks enthält selbst mehrere Felder:
| Feld | Beschreibung |
-|:-------------------- |:-------------------------------------------------------------------------------- |
+| :------------------- | :------------------------------------------------------------------------------- |
| `randao_reveal` | Ein Wert, der zur Auswahl des nächsten Block-Vorschlagenden verwendet wird |
| `eth1_data` | Informationen zum Einzahlungsvertrag |
| `graffiti` | Beliebige Daten, die zum Markieren von Blöcken verwendet werden |
| `proposer_slashings` | Liste der zu streichenden Validatoren |
| `attester_slashings` | Liste der Attestierer für Slashing |
-| `beglaubigungen` | Liste der Bescheinigungen zugunsten des aktuellen Blocks |
+| `beglaubigungen` | Liste der Attestierungen, die für frühere Slots gemacht wurden |
| `einzahlungen` | Liste der neuen Einlagen zum Einzahlungsvertrag |
| `voluntary_exits` | Liste der Validatoren, die das Netzwerk verlassen |
| `sync_aggregate` | Teilmenge der Validatoren, die zur Bedienung von leichten Clients verwendet wird |
@@ -65,88 +66,88 @@ Der `Body` eines Blocks enthält selbst mehrere Felder:
Das Feld `attestations` enthält eine Liste aller Attestierungen im Block. Attestierungen haben ihren eigenen Datentyp der mehrere Datenteile enthält. Jede Attestierung enthält:
| Feld | Beschreibung |
-|:------------------ |:------------------------------------------------------------------------- |
+| :----------------- | :------------------------------------------------------------------------ |
| `aggregation_bits` | Eine Liste der Validatoren, die an dieser Attestierung teilgenommen haben |
| `daten` | Ein Container mit mehreren Unterfeldern |
-| `signature` | Kollektivsignatur aller bescheinigenden Validatoren |
+| `unterschrift` | Aggregierte Signatur einer Gruppe von Validatoren für den `data`-Teil |
-Das Feld `data` in `attestation` enthält folgende Elemente:
+Das `data`-Feld in der `attestation` enthält Folgendes:
-| Feld | Beschreibung |
-|:------------------- |:----------------------------------------------------------- |
-| `Zeitspanne (Slot)` | Der Slot, auf den sich die Attestierung bezieht |
-| `Index` | Indizes für die bescheinigenden Validatoren |
-| `beacon_block_root` | Der Stamm-Hash des Beacon-Blocks, der dieses Objekt enthält |
-| `quelle` | Der letzte berechtigte Kontrollpunkt |
-| `target` | Der Grenzblock der neuesten Epoche |
+| Feld | Beschreibung |
+| :------------------ | :--------------------------------------------------------------------- |
+| `slot` | Der Slot, auf den sich die Attestierung bezieht |
+| `index` | Indizes für die bescheinigenden Validatoren |
+| `beacon_block_root` | Der Root-Hash des Beacon-Blocks, der als Kopf der Kette angesehen wird |
+| `quelle` | Der letzte berechtigte Kontrollpunkt |
+| `target` | Der Grenzblock der neuesten Epoche |
-Die Ausführung der Transaktionen in der `execution_payload` aktualisiert den globalen Zustand. Alle Clients führen die Transaktionen in der `execution_payload` erneut aus, um sicherzustellen, dass der neue Zustand dem Zustand im neuen Block im Feld `state_root` entspricht. Auf diese Weise stellen Clients sicher, dass ein neuer Block gültig und sicher ist, um ihn der Blockchain hinzuzufügen. Der `execution payload` selbst ist ein Objekt mit mehreren Feldern. Es gibt auch einen `execution_payload_header`, der wichtige zusammengefasste Informationen über die auszuführenden Daten enthält. Diese Datenstrukturen sind wie folgt organisiert:
+Die Ausführung der Transaktionen in der `execution_payload` aktualisiert den globalen Zustand. Alle Clients führen die Transaktionen in der `execution_payload` erneut aus, um sicherzustellen, dass der neue Zustand dem im `state_root`-Feld des neuen Blocks entspricht. Auf diese Weise stellen Clients sicher, dass ein neuer Block gültig und sicher ist, um ihn der Blockchain hinzuzufügen. Die `execution_payload` selbst ist ein Objekt mit mehreren Feldern. Es gibt auch einen `execution_payload_header`, der wichtige zusammenfassende Informationen über die Ausführungsdaten enthält. Diese Datenstrukturen sind wie folgt organisiert:
Der `execution_payload_header` enthält die folgenden Felder:
-| Feld | Beschreibung |
-|:--------------------- |:------------------------------------------------------------------------------------- |
-| `übergeordneter_hash` | Hash des übergeordneten Blocks |
-| `fee_recipient` | Kontoadresse, an die die Transaktionsgebühren gezahlt werden |
-| `state_root` | Stamm-Hash für den globalen Zustand nach der Anwendung der Änderungen in diesem Block |
-| `receipts_root` | Hash des Transaktionsempfänger-Baums |
-| `logs_bloom` | Datenstruktur, die Ereignisprotokolle enthält |
-| `prev_randao` | Verwendeter Wert in einer zufälligen Validatorauswahl |
-| `block_number` | Die Nummer des aktuellen Blocks |
-| `gas_limit` | Maximales für diesen Block erlaubtes Gas |
-| `gas_used` | Die eingesetzte Menge an Gas in diesem Block |
-| `Zeitstempel` | Die Blockzeit |
-| `extra_data` | Beliebige zusätzliche Daten als rohe Bytes |
-| `base_fee_per_gas` | Der Basisgebührenwert |
-| `block_hash` | Hash des ausführenden Blocks |
-| `transactions_root` | Stamm-Hash der Transaktionen in der Nutzlast |
-| `withdrawal_root` | Stamm-Hash der Abhebungen in der Nutzlast |
-
-Die `execution_payload` selbst enthält Folgendes (das ist identisch zum Header, außer dass es anstatt des Stamm-Hash der Transaktionen die Liste der Transaktions- und Abhebungsinformationen enthält) :
-
-| Feld | Beschreibung |
-|:--------------------- |:------------------------------------------------------------------------------------- |
-| `übergeordneter_hash` | Hash des übergeordneten Blocks |
-| `fee_recipient` | Kontoadresse, an die die Transaktionsgebühren gezahlt werden |
-| `state_root` | Stamm-Hash für den globalen Zustand nach der Anwendung der Änderungen in diesem Block |
-| `receipts_root` | Hash des Transaktionsempfänger-Baums |
-| `logs_bloom` | Datenstruktur, die Ereignisprotokolle enthält |
-| `prev_randao` | Verwendeter Wert in einer zufälligen Validatorauswahl |
-| `block_number` | Die Nummer des aktuellen Blocks |
-| `gas_limit` | Maximales für diesen Block erlaubtes Gas |
-| `gas_used` | Die eingesetzte Menge an Gas in diesem Block |
-| `Zeitstempel` | Die Blockzeit |
-| `extra_data` | Beliebige zusätzliche Daten als rohe Bytes |
-| `base_fee_per_gas` | Der Basisgebührenwert |
-| `block_hash` | Hash des ausführenden Blocks |
-| `Transaktionen` | Liste der Transaktionen, die ausgeführt werden sollen |
-| `abhebungen` | Liste der Abhebungsobjekte |
-
-Die Liste `withdrawals` enthält `withdrawal`-Objekte, die wie folgt strukturiert sind:
+| Feld | Beschreibung |
+| :------------------- | :------------------------------------------------------------------------------------ |
+| `parent_hash` | Hash des übergeordneten Blocks |
+| `fee_recipient` | Kontoadresse, an die die Transaktionsgebühren gezahlt werden |
+| `state_root` | Stamm-Hash für den globalen Zustand nach der Anwendung der Änderungen in diesem Block |
+| `receipts_root` | Hash des Transaktionsempfänger-Baums |
+| `logs_bloom` | Datenstruktur, die Ereignisprotokolle enthält |
+| `prev_randao` | Verwendeter Wert in einer zufälligen Validatorauswahl |
+| `block_number` | Die Nummer des aktuellen Blocks |
+| `gas_limit` | Maximales für diesen Block erlaubtes Gas |
+| `gas_used` | Die eingesetzte Menge an Gas in diesem Block |
+| `timestamp` | Die Blockzeit |
+| `extra_data` | Beliebige zusätzliche Daten als rohe Bytes |
+| `base_fee_per_gas` | Der Basisgebührenwert |
+| `block_hash` | Hash des ausführenden Blocks |
+| `transactions_root` | Stamm-Hash der Transaktionen in der Nutzlast |
+| `withdrawal_root`},{ | Stamm-Hash der Abhebungen in der Nutzlast |
+
+Die `execution_payload` selbst enthält Folgendes (beachten Sie, dass diese mit dem Header identisch ist, außer dass sie anstelle des Root-Hashs der Transaktionen die tatsächliche Liste der Transaktionen und Auszahlungsinformationen enthält):
+
+| Feld | Beschreibung |
+| :----------------- | :------------------------------------------------------------------------------------ |
+| `parent_hash` | Hash des übergeordneten Blocks |
+| `fee_recipient` | Kontoadresse, an die die Transaktionsgebühren gezahlt werden |
+| `state_root` | Stamm-Hash für den globalen Zustand nach der Anwendung der Änderungen in diesem Block |
+| `receipts_root` | Hash des Transaktionsempfänger-Baums |
+| `logs_bloom` | Datenstruktur, die Ereignisprotokolle enthält |
+| `prev_randao` | Verwendeter Wert in einer zufälligen Validatorauswahl |
+| `block_number` | Die Nummer des aktuellen Blocks |
+| `gas_limit` | Maximales für diesen Block erlaubtes Gas |
+| `gas_used` | Die eingesetzte Menge an Gas in diesem Block |
+| `timestamp` | Die Blockzeit |
+| `extra_data` | Beliebige zusätzliche Daten als rohe Bytes |
+| `base_fee_per_gas` | Der Basisgebührenwert |
+| `block_hash` | Hash des ausführenden Blocks |
+| `transaktionen` | Liste der Transaktionen, die ausgeführt werden sollen |
+| `auszahlungen` | Liste der Abhebungsobjekte |
+
+Die `withdrawals`-Liste enthält `withdrawal`-Objekte, die wie folgt strukturiert sind:
| Feld | Beschreibung |
-|:---------------- |:---------------------------------------------- |
-| `address` | Kontoadresse, für die die Abhebung erfolgt ist |
-| `Betrag` | Abgehobener Betrag |
-| `Index` | Abhebungsindexwert |
+| :--------------- | :--------------------------------------------- |
+| `adresse` | Kontoadresse, für die die Abhebung erfolgt ist |
+| `amount` | Abgehobener Betrag |
+| `index` | Abhebungsindexwert |
| `validatorIndex` | Validatorindexwert |
-## Blockzeit {#block-time}
+## Block-Zeit {#block-time}
Die Blockzeit bezieht sich auf die Zeit zwischen Blöcken. In Ethereum wird Zeit in Einheiten zu je zwölf Sekunden aufgeteilt. Diese heißen "Slots". In jedem Slot wird ein Validator ausgewählt, der einen Block vorschlägt. Geht man davon aus, dass alle Validatoren online und voll funktionsfähig sind, wird es in jedem Slot einen Block gegen. Die zugehörige Blockzeit beträgt dann 12 Sekunden. Es kann jedoch vorkommen, dass Validatoren offline sind, wenn sie dazu aufgerufen werden einen Block vorzuschlagen. Der zugehörige Slot bleibt dann leer.
-Diese Implementierung unterscheidet sich von PoW-basierten Blockchain-Systemen, in denen die Erzeugung eines Blocks zu den probabilistischen Verfahren gehört, wodurch die Mining-Schwierigkeit des Protokolls ausgeglichen wird. Die [durchschnittliche Blockverbreitungszeit](https://etherscan.io/chart/blocktime) von Ethereum ist ein perfektes Beispiel für die Implementierung von Proof of Stake und damit für den Wechsel von Proof of Work (PoW) zu Proof of Stake (PoS), der durch eine weitere Anpassung der Blockverbreitungszeit auf 12 Sekunden ermöglicht wurde.
+Diese Implementierung unterscheidet sich von PoW-basierten Blockchain-Systemen, in denen die Erzeugung eines Blocks zu den probabilistischen Verfahren gehört, wodurch die Mining-Schwierigkeit des Protokolls ausgeglichen wird. Die [durchschnittliche Block-Zeit](https://etherscan.io/chart/blocktime) von Ethereum ist ein perfektes Beispiel dafür, wobei der Übergang von Proof-of-Work zu Proof-of-Stake anhand der Konsistenz der neuen 12-Sekunden-Block-Zeit deutlich abgeleitet werden kann.
## Blockgröße {#block-size}
-Ein finaler, wichtiger Hinweis ist, dass Blöcke selbst in ihrer Größe begrenzt sind. Jeder Block hat eine Zielgröße von 30 Millionen Gas, aber die Größe der Blöcke wird entsprechend der Netznachfrage erhöht oder verringert, bis zur Blockgrenze von 60 Millionen Gas (doppelte Zielblockgröße). Das Gas-Limit eines Blocks kann um den Faktor 1/1024 vom Gas-Limit des vorangegangenen Blocks nach oben oder unten justiert werden. Dadurch können Validatoren das Gas-Limit eines Blocks durch Konsens verändern. Die Gesamtmenge des von allen Transaktionen im Block verbrauchten Gases muss unter dem Blockgaslimit liegen. Das ist wichtig, weil dadurch sichergestellt wird, dass Blöcke nicht willkürlich groß sein können. Wenn Blöcke beliebig groß sein könnten, würden weniger leistungsstarke Knoten aufgrund von Platz- und Geschwindigkeitsanforderungen allmählich nicht mehr mit dem Netzwerk Schritt halten können. Je größer der Block, desto höher ist die erforderliche Verarbeitungsleistung, um den Block rechtzeitig für das nächste Zeitintervall zu berechnen. Das ist ein ganz zentraler Aspekt, der durch die Begrenzung der Blockgröße umgangen wird.
+Ein finaler, wichtiger Hinweis ist, dass Blöcke selbst in ihrer Größe begrenzt sind. Jeder Block hat eine Zielgröße von 30 Millionen Gas, aber die Größe der Blöcke wird entsprechend der Netznachfrage erhöht oder verringert, bis zur Blockgrenze von 60 Millionen Gas (doppelte Ziel-Blockgröße). Das Gas-Limit eines Blocks kann um den Faktor 1/1024 vom Gas-Limit des vorangegangenen Blocks nach oben oder unten justiert werden. Dadurch können Validatoren das Gas-Limit eines Blocks durch Konsens verändern. Die Gesamtmenge des von allen Transaktionen im Block verbrauchten Gases muss unter dem Blockgaslimit liegen. Das ist wichtig, weil dadurch sichergestellt wird, dass Blöcke nicht willkürlich groß sein können. Wenn Blöcke beliebig groß sein könnten, würden weniger leistungsstarke Knoten aufgrund von Platz- und Geschwindigkeitsanforderungen allmählich nicht mehr mit dem Netzwerk Schritt halten können. Je größer der Block, desto höher ist die erforderliche Verarbeitungsleistung, um den Block rechtzeitig für das nächste Zeitintervall zu berechnen. Das ist ein ganz zentraler Aspekt, der durch die Begrenzung der Blockgröße umgangen wird.
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
_Sie kennen Community-Resourcen die Ihnen geholfen haben? Bearbeiten Sie diese Seite und fügen Sie sie hinzu!_
## Verwandte Themen {#related-topics}
- [Transaktionen](/developers/docs/transactions/)
-- [Ressourcen](/developers/docs/gas/)
+- [Gas](/developers/docs/gas/)
- [Proof-of-Stake](/developers/docs/consensus-mechanisms/pos)
diff --git a/public/content/translations/de/developers/docs/bridges/index.md b/public/content/translations/de/developers/docs/bridges/index.md
new file mode 100644
index 00000000000..032faded200
--- /dev/null
+++ b/public/content/translations/de/developers/docs/bridges/index.md
@@ -0,0 +1,138 @@
+---
+title: Brücken
+description: Eine Übersicht über Bridging für Entwickler
+lang: de
+---
+
+Mit der Verbreitung von L1-Blockchains und L2-[Skalierungslösungen](/developers/docs/scaling/) sowie einer ständig wachsenden Zahl dezentralisierter Anwendungen, die kettenübergreifend arbeiten, ist die Notwendigkeit der Kommunikation und des Transfers von Vermögenswerten über Ketten hinweg zu einem wesentlichen Bestandteil der Netzwerkinfrastruktur geworden. Um dies zu ermöglichen, gibt es verschiedene Arten von Brücken (Bridges).
+
+## Notwendigkeit für kettenübergreifende Brücken {#need-for-bridges}
+
+Es gibt Bridges, um Blockchain-Netzwerke miteinander zu verbinden. Sie ermöglichen Konnektivität und Interoperabilität zwischen Blockchains.
+
+Blockchains existieren in isolierten Umgebungen. Das bedeutet, dass es für Blockchains keine Möglichkeit gibt, auf natürliche Weise mit anderen Blockchains zu transferieren und zu kommunizieren. Dies hat zur Folge, dass es innerhalb eines Ökosystems zwar erhebliche Aktivität und Innovation geben kann, diese aber durch die fehlende Konnektivität und Interoperabilität mit anderen Ökosystemen eingeschränkt ist.
+
+Bridges bieten eine Möglichkeit für isolierte Blockchain-Umgebungen, sich zu connecten. Sie stellen eine Transportroute zwischen Blockchains her, über die Token, Nachrichten, beliebige Daten und sogar [Smart-Contract-Aufrufe](/developers/docs/smart-contracts/) von einer Kette zur anderen übertragen werden können.
+
+## Vorteile von kettenübergreifenden Brücken {#benefits-of-bridges}
+
+Einfach ausgedrückt, ermöglichen Brücken zahlreiche Anwendungsfälle, indem sie es Blockchain-Netzwerken erlauben, Daten auszutauschen und Vermögenswerte zwischen ihnen zu transferieren.
+
+Blockchains haben einzigartige Stärken, Schwächen und Ansätze zum Aufbau von Anwendungen (wie Geschwindigkeit, Durchsatz, Kosten usw.). Bridges tragen zur Entwicklung des gesamten Krypto-Ökosystems bei, indem sie es Blockchains ermöglichen, die Innovationen der anderen zu nutzen.
+
+Für Entwickler ermöglichen Bridges Folgendes:
+
+- Die Übertragung von Daten, Informationen und Vermögenswerten über Ketten hinweg.
+- Die Erschließung neuer Funktionen und Anwendungsfälle für Protokolle, da Bridges den Gestaltungsspielraum für Protokolle erweitern. Zum Beispiel kann ein Protokoll für Yield Farming, das ursprünglich im Ethereum Mainnet eingesetzt wurde, Liquiditätspools über alle EVM-kompatiblen Chains hinweg anbieten.
+- Die Möglichkeit, die Stärken der verschiedenen Blockchains zu nutzen. So können Entwickler beispielsweise von den niedrigeren Gebühren der verschiedenen L2-Lösungen profitieren, indem sie ihre Dapps auf Rollups bzw. Sidechains deployen und Nutzer diese überbrücken können.
+- Zusammenarbeit zwischen Entwicklern aus verschiedenen Blockchain-Ökosystemen, um neue Produkte zu entwickeln.
+- Nutzer und Communities aus verschiedenen Ökosystemen für ihre Dapps gewinnen.
+
+## Wie funktionieren Bridges? {#how-do-bridges-work}
+
+Obwohl es viele [Arten von Designs für kettenübergreifende Brücken](https://li.fi/knowledge-hub/blockchain-bridges-and-classification/) gibt, stechen drei Möglichkeiten zur Vereinfachung des kettenübergreifenden Transfers von Vermögenswerten hervor:
+
+- **Sperren und Prägen –** Vermögenswerte auf der Quellkette sperren und auf der Zielkette prägen.
+- **Verbrennen und Prägen –** Vermögenswerte auf der Quellkette verbrennen und auf der Zielkette prägen.
+- **Atomare Swaps –** Tausch von Vermögenswerten auf der Quellkette gegen Vermögenswerte auf der Zielkette mit einer anderen Partei.
+
+## Arten von kettenübergreifenden Brücken {#bridge-types}
+
+Bridges lassen sich in der Regel in eine der folgenden Kategorien einordnen:
+
+- **Native kettenübergreifende Brücken –** Diese kettenübergreifenden Brücken werden in der Regel gebaut, um die Liquidität auf einer bestimmten Blockchain zu fördern, was es den Nutzern erleichtert, Gelder in das Ökosystem zu transferieren. Die [Arbitrum Bridge](https://bridge.arbitrum.io/) wurde beispielsweise gebaut, um es Nutzern zu erleichtern, von Ethereum Mainnet zu Arbitrum zu überbrücken. Andere solche kettenübergreifenden Brücken sind die Polygon PoS Bridge, das [Optimism Gateway](https://app.optimism.io/bridge) usw.
+- **Validator- oder Orakel-basierte kettenübergreifende Brücken –** Diese kettenübergreifenden Brücken stützen sich auf eine externe Gruppe von Validatoren oder Orakel, um kettenübergreifende Übertragungen zu validieren. Beispiele: Multichain und Across.
+- **Generalisierten kettenübergreifenden Brücken zur Nachrichtenübermittlung –** Diese kettenübergreifenden Brücken können Vermögenswerte zusammen mit Nachrichten und beliebigen Daten über Ketten hinweg übertragen. Beispiele: Axelar, LayerZero und Nomad.
+- **Liquiditätsnetzwerke –** Diese kettenübergreifenden Brücken konzentrieren sich in erster Linie auf die Übertragung von Vermögenswerten von einer Kette zur anderen über atomare Swaps. Im Allgemeinen unterstützen sie keine cross-chain Nachrichtenübermittlung. Beispiele: Connext und Hop.
+
+## Zu berücksichtigende Trade-offs {#trade-offs}
+
+Bei Bridges gibt es keine perfekten Lösungen. Vielmehr gibt es Kompromisse, die gemacht werden, um einen bestimmten Zweck zu erfüllen. Entwickler und Benutzer können Bridges anhand der folgenden Faktoren bewerten:
+
+- **Sicherheit –** Wer verifiziert das System? Durch externe Validatoren gesicherte Bridges sind in der Regel weniger sicher als Bridges, die lokal oder nativ durch die Validatoren der Blockchain gesichert sind.
+- **Bequemlichkeit –** Wie lange dauert der Abschluss einer Transaktion und wie viele Transaktionen musste ein Nutzer unterzeichnen? Wie lange braucht ein Entwickler, um eine Bridge zu integrieren, und wie komplex ist der Prozess?
+- **Konnektivität –** Welche verschiedenen Zielketten kann eine kettenübergreifende Brücke verbinden (d. h. Rollups, Sidechains, andere Layer-1-Blockchains usw.) und wie schwierig ist es, eine neue Blockchain zu integrieren?
+- **Fähigkeit, komplexere Daten zu übermitteln –** Kann eine kettenübergreifende Brücke die Übertragung von Nachrichten und komplexeren beliebigen Daten über Ketten hinweg ermöglichen oder unterstützt sie nur kettenübergreifende Vermögensübertragungen?
+- **Kosteneffizienz –** Wie viel kostet die Übertragung von Vermögenswerten über Ketten hinweg über eine kettenübergreifende Brücke? In der Regel erheben Bridges eine feste oder variable Gebühr, die sich nach den Gaskosten und der Liquidität bestimmter Routen richtet. Es ist auch wichtig, die Kosteneffizienz einer Bridge auf der Grundlage des zur Gewährleistung ihrer Sicherheit erforderlichen Kapitals zu bewerten.
+
+Grundlegend können Bridges in "trusted" und "trustless" Bridges unterteilt werden.
+
+- **Vertrauenswürdig –** Vertrauenswürdige kettenübergreifende Brücken werden extern verifiziert. Sie verwenden eine externe Gruppe von Verifizierern (Gruppen mit Mehrsignatur, Mehrparteien-Rechensysteme, Orakelnetzwerke), um Daten über Ketten hinweg zu senden. Infolgedessen können sie eine hohe Konnektivität bieten und eine vollständig generalisierte Nachrichtenübermittlung über Chains hinweg ermöglichen. Sie zeichnen sich auch durch hohe Geschwindigkeit und Kosteneffizienz aus. Dies geht jedoch auf Kosten der Sicherheit, da die Benutzer sich auf die Sicherheit der Bridge verlassen müssen.
+- **Vertrauenslos –** Diese kettenübergreifenden Brücken stützen sich auf die Blockchains, die sie verbinden, und deren Validatoren, um Nachrichten und Token zu übertragen. Sie sind "vertrauenslos", weil sie keine neuen Vertrauensannahmen (zusätzlich zu den Blockchains) hinzufügen. Folglich gelten trustless Bridges als sicherer als trusted Bridges.
+
+Um trustless Bridges auf der Grundlage anderer Faktoren zu bewerten, müssen wir sie in "Generalized message passing bridges" und "Liquidity networks" unterteilen.
+
+- **Generalisierte kettenübergreifende Brücken zur Nachrichtenübermittlung –** Diese kettenübergreifenden Brücken zeichnen sich durch Sicherheit und die Fähigkeit aus, komplexere Daten über Ketten hinweg zu übertragen. In der Regel sind sie auch sehr kosteneffizient. Diese Stärken gehen jedoch in der Regel auf Kosten der Konnektivität bei einfachen Client-Brücken (z. B. IBC) und der Geschwindigkeit bei optimistischen Brücken (z. B. Nomad), die Betrugsnachweise verwenden.
+- **Liquiditätsnetzwerke –** Diese kettenübergreifenden Brücken verwenden atomare Swaps für die Übertragung von Vermögenswerten und sind lokal verifizierte Systeme (d. h. sie verwenden die Validatoren der zugrunde liegenden Blockchains, um Transaktionen zu verifizieren). Daher zeichnen sie sich durch Sicherheit und Geschwindigkeit aus. Außerdem gelten sie als vergleichsweise kostengünstig und bieten eine gute Konnektivität. Der größte Nachteil ist jedoch ihre Unfähigkeit, komplexere Daten zu übertragen, da sie keine cross-chain Nachrichtenübermittlung unterstützen.
+
+## Risiken bei kettenübergreifenden Brücken {#risk-with-bridges}
+
+Kettenübergreifende Brücken sind für die drei [größten Hacks in DeFi](https://rekt.news/leaderboard/) verantwortlich und befinden sich noch in einem frühen Entwicklungsstadium. Die Verwendung von Bridges birgt die folgenden Risiken:
+
+- **Smart-Contract-Risiko –** Obwohl viele kettenübergreifende Brücken Audits erfolgreich bestanden haben, reicht ein einziger Fehler in einem Smart Contract aus, damit Vermögenswerte Hacks ausgesetzt sind (z. B. [Solanas Wormhole Bridge](https://rekt.news/wormhole-rekt/)).
+- **Systemische finanzielle Risiken** – Viele kettenübergreifende Brücken verwenden Wrapped Assets, um kanonische Versionen des ursprünglichen Vermögenswerts auf einer neuen Kette zu prägen. Dies setzt das Ökosystem einem systemischen Risiko aus, da wir gesehen haben, wie gewrappte Versionen von Token ausgenutzt wurden.
+- **Gegenparteirisiko –** Einige kettenübergreifende Brücken verwenden ein vertrauenswürdiges Design, bei dem sich Nutzer darauf verlassen müssen, dass die Validatoren nicht kollaborieren, um Nutzergelder zu stehlen. Da die Nutzer diesen Drittparteien vertrauen müssen, sind sie Risiken wie Absprachen, Zensur und anderen betrügerischen Aktivitäten ausgesetzt.
+- **Offene Fragen –** Da sich kettenübergreifende Brücken in einem frühen Entwicklungsstadium befinden, gibt es viele unbeantwortete Fragen dazu, wie sich kettenübergreifende Brücken unter verschiedenen Marktbedingungen verhalten werden, wie z. B. bei Netzwerküberlastung und bei unvorhergesehenen Ereignissen wie Angriffen auf Netzwerkebene oder State Rollbacks. Diese Ungewissheit birgt gewisse Risiken, deren Ausmaß noch unbekannt ist.
+
+## Wie können Dapps Brücken nutzen? {#how-can-dapps-use-bridges}
+
+Hier sind einige praktische Anwendungen, die Entwickler bei der Integration von Brücken für ihre Cross-Chain-Dapps berücksichtigen können:
+
+### Integration von kettenübergreifenden Brücken {#integrating-bridges}
+
+Entwickler haben verschiedene Möglichkeiten, Bridges zu implementieren:
+
+1. **Eine eigene kettenübergreifende Brücke bauen –** Der Bau einer sicheren und zuverlässigen kettenübergreifenden Brücke ist nicht einfach, besonders wenn man einen vertrauensminimierten Weg wählt. Dies erfordert umfangreiche Erfahrung und technisches Fachwissen in Bezug auf Skalierbarkeit und Interoperabilität. Zudem ist ein Team notwendig, das sich um die Wartung der Brücke kümmert und ausreichend Liquidität anzieht, um sie funktionsfähig zu machen.
+
+2. **Nutzern mehrere Optionen für kettenübergreifende Brücken anzeigen –** Viele [Dapps](/developers/docs/dapps/) erfordern, dass Nutzer ihre nativen Token besitzen, um mit ihnen zu interagieren. Um den Nutzern den Zugriff auf ihre Token zu ermöglichen, können sie verschiedene Bridge-Optionen auf ihrer Plattform anbieten. Diese Methode ist jedoch eine schnelle Lösung und lenkt den Nutzer von der Dapp-Oberfläche weg, da er weiterhin mit anderen Dapps und Bridges interagieren muss. Dies kann zu einem umständlichen Onboarding-Erlebnis mit erhöhtem Fehlerpotenzial führen.
+
+3. **Eine kettenübergreifende Brücke integrieren –** Diese Lösung erfordert nicht, dass die Dapp Nutzer an die externen Schnittstellen der kettenübergreifenden Brücke und DEX sendet. Sie ermöglicht es Dapps, das Onboarding-Erlebnis der Benutzer zu verbessern. Dieser Ansatz hat jedoch seine Grenzen:
+
+ - Die Bewertung und Pflege von Bridges ist schwierig und zeitaufwändig.
+ - Die Auswahl einer Bridge führt zu einem Single Point of Failure und zu Abhängigkeiten.
+ - Die Dapp ist durch die Fähigkeiten der Bridge begrenzt.
+ - Bridges allein reichen möglicherweise nicht aus. Dapps benötigen möglicherweise DEXs, um weitere Funktionen wie Cross-Chain-Swaps anzubieten.
+
+4. **Mehrere kettenübergreifende Brücken integrieren –** Diese Lösung löst viele Probleme, die mit der Integration einer einzigen kettenübergreifenden Brücke verbunden sind. Sie hat jedoch auch ihre Grenzen, da die Integration mehrerer Bridges ressourcenintensiv ist und einen technischen und kommunikativen Mehraufwand für Entwickler bedeutet - die knappste Ressource in der Kryptowirtschaft.
+
+5. **Einen Aggregator für kettenübergreifende Brücken integrieren –** Eine weitere Option für Dapps ist die Integration einer Aggregationslösung für kettenübergreifende Brücken, die ihnen Zugang zu mehreren kettenübergreifenden Brücken gibt. Bridge-Aggregatoren erben die Stärken aller Bridges und sind daher nicht durch die Fähigkeiten einer einzelnen Bridge eingeschränkt. Die Bridge-Aggregatoren übernehmen in der Regel die Wartung der Bridge-Integrationen und ersparen der App damit den Aufwand, sich um die technischen und betrieblichen Aspekte einer Bridge-Integration zu kümmern.
+
+Abgesehen davon haben Bridge-Aggregatoren auch ihre Grenzen. So können sie zwar mehr Bridge-Optionen anbieten, aber auf dem Markt sind in der Regel viel mehr Bridges verfügbar als die, die auf der Plattform des Aggregators angeboten werden. Darüber hinaus sind Bridge-Aggregatoren, genau wie Bridges, auch Smart-Contract- und Technologierisiken ausgesetzt (mehr Smart Contracts = mehr Risiken).
+
+Wenn eine Dapp den Weg der Integration einer Bridge oder eines Aggregators einschlägt, gibt es verschiedene Optionen, je nachdem, wie umfassend die Integration sein soll. Wenn es sich zum Beispiel nur um eine Front-End-Integration handelt, um das Onboarding-Erlebnis des Nutzers zu verbessern, würde eine Dapp das Widget integrieren. Wenn die Integration jedoch tiefergehende cross-chain Strategien wie Staking, Yield Farming usw. umfassen soll, integriert die Dapp das SDK oder die API.
+
+### Eine Dapp auf mehreren Chains bereitstellen {#deploying-a-dapp-on-multiple-chains}
+
+Um eine Dapp auf mehreren Chains bereitzustellen, können Entwickler Entwicklungsplattformen wie [Alchemy](https://www.alchemy.com/), [Hardhat](https://hardhat.org/), [Moralis](https://moralis.io/) usw. verwenden. Diese Plattformen verfügen in der Regel über modulare Plugins, mit denen Dapps cross-chain eingesetzt werden können. Zum Beispiel können Entwickler einen deterministischen Bereitstellungs-Proxy verwenden, der vom [hardhat-deploy-Plugin](https://github.com/wighawag/hardhat-deploy) angeboten wird.
+
+#### Beispiele:
+
+- [Wie man kettenübergreifende Dapps baut](https://moralis.io/how-to-build-cross-chain-dapps/)
+- [Aufbau eines kettenübergreifenden NFT-Marktplatzes](https://youtu.be/WZWCzsB1xUE)
+- [Moralis: Kettenübergreifende NFT-Dapps bauen](https://www.youtube.com/watch?v=ehv70kE1QYo)
+
+### Überwachung der Vertragsaktivität über Ketten hinweg {#monitoring-contract-activity-across-chains}
+
+Zur Überwachung der chain-übergreifenden Contract-Aktivitäten können Entwickler Subgraphen und Entwicklerplattformen wie Tenderly verwenden, um Smart Contracts in Echtzeit zu beobachten. Solche Plattformen verfügen auch über Tools, die eine erweiterte Datenüberwachungsfunktionalität für kettenübergreifende Aktivitäten bieten, wie z. B. die Überprüfung von [Ereignissen, die von Verträgen ausgegeben werden](https://docs.soliditylang.org/en/v0.8.14/contracts.html?highlight=events#events), usw.
+
+#### Tools
+
+- [The Graph](https://thegraph.com/en/)
+- [Tenderly](https://tenderly.co/)
+
+## Weiterführende Lektüre {#further-reading}
+
+- [Blockchain-Brücken](/bridges/) – ethereum.org
+- [L2Beat Bridge Risk Framework](https://l2beat.com/bridges/summary)
+- [Blockchain-Brücken: Aufbau von Netzwerken aus Kryptonetzwerken](https://medium.com/1kxnetwork/blockchain-bridges-5db6afac44f8) - 8. Sep. 2021 – Dmitriy Berenzon
+- [Das Interoperabilitäts-Trilemma](https://blog.connext.network/the-interoperability-trilemma-657c2cf69f17) - 1. Okt. 2021 – Arjun Bhuptani
+- [Cluster: Wie vertrauenswürdige und vertrauensminimierte kettenübergreifende Brücken die Multi-Chain-Landschaft gestalten](https://blog.celestia.org/clusters/) - 4. Okt. 2021 – Mustafa Al-Bassam
+- [LI.FI: Bei kettenübergreifenden Brücken ist Vertrauen ein Spektrum](https://blog.li.fi/li-fi-with-bridges-trust-is-a-spectrum-354cd5a1a6d8) - 28. Apr. 2022 – Arjun Chand
+- [Der Stand der Rollup-Interoperabilitätslösungen](https://web.archive.org/web/20250428015516/https://research.2077.xyz/the-state-of-rollup-interoperability) - 20. Juni 2024 – Alex Hook
+- [Nutzung gemeinsamer Sicherheit für sichere kettenübergreifende Interoperabilität: Lagrange State Committees und darüber hinaus](https://web.archive.org/web/20250125035123/https://research.2077.xyz/harnessing-shared-security-for-secure-blockchain-interoperability) - 12. Juni 2024 – Emmanuel Awosika
+
+Zusätzlich finden Sie hier einige aufschlussreiche Präsentationen von [James Prestwich](https://twitter.com/_prestwich), die helfen können, ein tieferes Verständnis für kettenübergreifende Brücken zu entwickeln:
+
+- [Brücken bauen, keine ummauerten Gärten](https://youtu.be/ZQJWMiX4hT0)
+- [Brücken analysieren](https://youtu.be/b0mC-ZqN8Oo)
+- [Warum brennen die Brücken](https://youtu.be/c7cm2kd20j8)
diff --git a/public/content/translations/de/developers/docs/consensus-mechanisms/index.md b/public/content/translations/de/developers/docs/consensus-mechanisms/index.md
index ffbf5c088ab..37989263990 100644
--- a/public/content/translations/de/developers/docs/consensus-mechanisms/index.md
+++ b/public/content/translations/de/developers/docs/consensus-mechanisms/index.md
@@ -8,7 +8,7 @@ Der Begriff „Konsensmechanismus“ wird oft umgangssprachlich verwendet, um
## Voraussetzungen {#prerequisites}
-Um diese Seite besser zu verstehen, empfehlen wir dir, zuerst unsere [Einleitung zu Ethereum](/developers/docs/intro-to-ethereum/) zu lesen.
+Um diese Seite besser zu verstehen, empfehlen wir dir, zuerst unsere [Einführung in Ethereum](/developers/docs/intro-to-ethereum/) zu lesen.
## Was ist ein Konsens? {#what-is-consensus}
@@ -30,25 +30,25 @@ Diese Komponenten bilden zusammen den Konsensmechanismus.
## Arten von Konsensmechanismen {#types-of-consensus-mechanisms}
-### Proof-of-Work-basiert {#proof-of-work}
+### Auf Proof-of-Work basierend {#proof-of-work}
-Wie Bitcoin nutzte auch Ethereum früher ein auf **Proof-of-Work (PoW)** basierendes Konsensprotokoll.
+Wie Bitcoin hat auch Ethereum früher ein auf **Proof-of-Work (PoW)** basierendes Konsensprotokoll verwendet.
-#### Blockerstellung {#pow-block-creation}
+#### Block-Erstellung {#pow-block-creation}
-Miner konkurrieren darum, neue Blöcke voll mit verarbeiteten Transaktionen zu erstellen. Der Gewinner teilt den neuen Block mit dem Rest des Netzwerks und verdient einige frisch geprägte ETH. Das Rennen wird von dem Computer gewonnen, der ein mathematisches Rätsel am schnellsten lösen kann. Dies erzeugt die kryptografische Verbindung zwischen dem aktuellen Block und dem vorherigen Block. Die Lösung dieses Rätsels ist die Arbeit („Work“) in „Proof-of-Work“. Die kanonische Chain wird dann durch eine Abspaltungs-Wahl-Regel bestimmt, bei der die Reihe von Blöcken ausgewählt wird, für deren Mining die meiste Arbeit geleistet wurde.
+Miner konkurrieren darum, neue Blöcke voll mit verarbeiteten Transaktionen zu erstellen. Der Gewinner teilt den neuen Block mit dem Rest des Netzwerks und verdient einige frisch geminte ETH. Das Rennen wird von dem Computer gewonnen, der ein mathematisches Rätsel am schnellsten lösen kann. Dies erzeugt die kryptografische Verbindung zwischen dem aktuellen Block und dem vorherigen Block. Die Lösung dieses Rätsels ist die Arbeit („Work“) in „Proof-of-Work“. Die kanonische Chain wird dann durch eine Abspaltungs-Wahl-Regel bestimmt, bei der die Reihe von Blöcken ausgewählt wird, für deren Mining die meiste Arbeit geleistet wurde.
#### Sicherheit {#pow-security}
Die Sicherheit des Netzwerks wird dadurch gewährleistet, dass Sie 51 % der Rechenleistung des Netzwerks brauchen, um die Chain zu betrügen. Das würde so große Investitionen in Ausrüstung und Energie erfordern, dass Sie wahrscheinlich mehr ausgeben würden, als Sie einnehmen.
-Mehr über [Proof-of-Work](/developers/docs/consensus-mechanisms/pow/)
+Mehr zu [Proof-of-Work](/developers/docs/consensus-mechanisms/pow/)
-### Proof-of-Stake-basiert {#proof-of-stake}
+### Auf Proof-of-Stake basierend {#proof-of-stake}
Ethereum verwendet jetzt ein auf **Proof-of-Stake (PoS)** basierendes Konsensprotokoll.
-#### Blockerstellung {#pos-block-creation}
+#### Block-Erstellung {#pos-block-creation}
Validatoren erstellen Blöcke. In jedem Slot wird zufällig ein Validator als Block-Proposer ausgewählt. Ihr Konsens-Client fordert ein Bündel von Transaktionen als „Ausführungsnutzlast“ von ihrem gekoppelten Ausführungs-Client an. Sie verpacken dies in Konsensdaten, um einen Block zu bilden, den sie an andere Nodes im Ethereum-Netzwerk senden. Diese Blockproduktion wird mit ETH belohnt. In seltenen Fällen, wenn für einen einzigen Slot mehrere mögliche Blöcke existieren oder Nodes zu unterschiedlichen Zeiten von Blöcken erfahren, wählt der Abspaltungs-Wahl-Algorithmus den Block aus, der die Chain mit dem größten Gewicht an Attestierungen bildet (wobei das Gewicht die Anzahl der attestierenden Validatoren ist, skaliert nach ihrem ETH-Guthaben).
@@ -58,35 +58,35 @@ Ein Proof-of-Stake-System ist kryptoökonomisch sicher, weil ein Angreifer, der
Mehr zu [Proof-of-Stake](/developers/docs/consensus-mechanisms/pos/)
-### Ein visueller Leitfaden {#types-of-consensus-video}
+### Eine visuelle Anleitung {#types-of-consensus-video}
Erfahren Sie mehr über die verschiedenen Arten von Konsensmechanismen, die auf Ethereum verwendet werden:
-Proof-of-Work ist nicht mehr der zugrunde liegende Konsensmechanismus von Ethereum, was bedeutet, dass das Mining ausgeschaltet wurde. Stattdessen wird Ethereum von Validatoren gesichert, die ETH staken. Du kannst schon heute mit dem Staking deiner ETH beginnen. Lese mehr dazu unter den Merge, Proof-of-Stake, und Staking. Diese Seite dient ausschließlich zu Archivierungszwecken, um Ereignisse rund um Ethereum zu dokumentieren.
+Proof-of-Work ist nicht mehr der zugrunde liegende Konsensmechanismus von Ethereum, was bedeutet, dass das Mining ausgeschaltet wurde. Stattdessen wird Ethereum von Validatoren gesichert, die ETH staken. Sie können schon heute mit dem Staking von ETH beginnen. Lese mehr dazu unter den Merge, Proof-of-Stake, und Staking. Diese Seite dient ausschließlich dem geschichtlichen Interesse.
## Voraussetzungen {#prerequisites}
-Um diese Seite besser zu verstehen, empfehlen wir dir, zuerst [Transaktionen](/developers/docs/transactions/), [Blöcke](/developers/docs/blocks/) und [Proof-of-Work](/developers/docs/consensus-mechanisms/pow/) zu lesen.
+Um diese Seite besser zu verstehen, empfehlen wir Ihnen, sich zunächst über [Transaktionen](/developers/docs/transactions/), [Blöcke](/developers/docs/blocks/) und [Proof-of-Work](/developers/docs/consensus-mechanisms/pow/) zu informieren.
## Was ist Ethereum-Mining? {#what-is-ethereum-mining}
@@ -31,41 +31,41 @@ Mining ist das Lebenselixier jeder Proof-of-Work Blockchain. Ethereum-Miner –
In dezentralisierten Systemen wie Ethereum müssen wir sicherstellen, dass jeder mit der Reihenfolge der Transaktionen einverstanden ist. Miner halfen dabei, indem sie rechnerisch schwierige Puzzles lösten, um Blöcke zu produzieren und dabei das Netzwerk vor Attacken zu schützen.
-[Mehr zu Proof-of-Work](/developers/docs/consensus-mechanisms/pow/)
+[Mehr über Proof-of-Work](/developers/docs/consensus-mechanisms/pow/)
Zuvor war es jedem möglich, mit dem eigenen Computer im Ethereum-Netzwerk zu minen. Allerdings konnte nicht jeder profitabel Ether (ETH) minen. In den meisten Fällen mussten Miner dedizierte Computer-Hardware kauften und Zugang zu günstigen Energiequellen haben. Es war unwahrscheinlich, dass ein durchschnittlicher Computer genug Blockbelohnungen verdienen konnte, um die Kosten für das Mining zu kompensieren.
-### Mining-Kosten {#cost-of-mining}
+### Kosten des Minings {#cost-of-mining}
- Mögliche Kosten für die Hardware, die für den Bau und die Wartung einer Mining-Anlage erforderlich ist
- Stromkosten für den Betrieb der Mining-Anlage
- Wenn man Miner in einem Pool war, erhob der Pool üblicherweise eine pauschale prozentuale Gebühr für jeden im Pool generierten Block
- Mögliche Kosten für die Ausrüstung zur Unterstützung der Mining-Anlage (Belüftung, Energieüberwachung, elektrische Verkabelung usw.)
-Um die Rentabilität des Minings weiterzuerkunden, können Sie einen Mining-Rechner verwenden, beispielsweise den von [Etherscan](https://etherscan.io/ether-mining-calculator).
+Um die Rentabilität des Minings weiter zu erkunden, verwenden Sie einen Mining-Rechner, wie ihn [Etherscan](https://etherscan.io/ether-mining-calculator) zur Verfügung stellt.
## Wie Ethereum-Transaktionen gemint wurden {#how-ethereum-transactions-were-mined}
Im Folgenden wird ein Überblick darüber gegeben, wie Transaktionen in Ethereum-Proof-of-Work gemint wurden. Eine analoge Beschreibung dieses Prozesses für Ethereum-Proof-of-Stake finden Sie [hier](/developers/docs/consensus-mechanisms/pos/#transaction-execution-ethereum-pos).
-1. Ein Benutzer schreibt und signiert eine Anfrage für eine [Transaktion](/developers/docs/transactions/) mit seinem privaten Schlüssel von einem [Konto](/developers/docs/accounts/).
-2. Der Benutzer überträgt die Transaktionsanfrage von einigen [Nodes](/developers/docs/nodes-and-clients/) an das gesamte Ethereum-Netzwerk.
+1. Ein Benutzer schreibt und signiert eine [Transaktions](/developers/docs/transactions/)anfrage mit dem privaten Schlüssel eines [Kontos](/developers/docs/accounts/).
+2. Der Benutzer überträgt die Transaktionsanfrage von einem [Node](/developers/docs/nodes-and-clients/) aus an das gesamte Ethereum-Netzwerk.
3. Wenn sie von der neuen Transaktionsanfrage hören, fügen alle Nodes die Anfrage ihrem lokalen Mempool (eine Liste aller Transaktionsanfragen, die noch nicht an die Blockchain übertragen wurden, von denen sie gehört haben) hinzu.
-4. Irgendwann fasst ein Mining-Node mehrere Dutzend oder Hundert Transaktionsanfragen in einem potenziellen [Block](/developers/docs/blocks/) zusammen, sodass die [Transaktionsentgelte](/developers/docs/gas/), die sie verdienen, maximiert werden, während sie unter dem Block-Ressourcen-Limit bleiben. Zu diesem Zeitpunkt tut der Mining-Node Folgendes:
- 1. Er überprüft die Gültigkeit jeder Transaktionsanfrage (z. B. es versucht keiner, die Ether von einem Konto ohne Signatur zu transferieren, die Anfrage ist nicht fehlerhaft etc.), führt dann den Code der Anfrage aus und ändert den Status ihrer lokalen Kopie der EVM. Die Miner erhalten die Transaktionsentgelte für jede dieser Transaktionsanfragen auf ihr eigenes Konto.
+4. Irgendwann fasst ein Mining-Node mehrere Dutzend oder Hundert Transaktionsanfragen in einem potenziellen [Block](/developers/docs/blocks/) so zusammen, dass die [Transaktionsgebühren](/developers/docs/gas/), die er verdient, maximiert werden, während das Gaslimit des Blocks eingehalten wird. Zu diesem Zeitpunkt tut der Mining-Node Folgendes:
+ 1. Überprüft die Gültigkeit jeder Transaktionsanfrage (d. h., niemand versucht, Ether von einem Konto zu überweisen, für das keine Signatur erstellt wurde, die Anfrage nicht fehlerhaft ist usw.), und führt dann den Code der Anfrage aus, was den Zustand der lokalen Kopie der EVM ändert. Die Miner erhalten die Transaktionsentgelte für jede dieser Transaktionsanfragen auf ihr eigenes Konto.
2. Startet den Prozess der Erstellung des Proof-of-Work "Nachweiszertifikat der Legitimität" für den potenziellen Block, sobald alle Transaktionsanfragen in dem Block verifiziert und in der lokalen EVM-Kopie ausgeführt wurden.
5. Letztendlich wird ein Miner ein Zertifikat für einen Block erstellen, der unsere spezifische Transaktionsanfrage enthält. Dieser Miner sendet dann den vollendeten Block, der das Zertifikat und eine Prüfsumme des beanspruchten neuen EVM-Status enthält.
6. Andere Nodes hören von dem neuen Block. Sie prüfen das Zertifikat, führen alle Transaktionen in dem Block selbst aus (einschließlich der ursprünglich von unserem Nutzer übermittelten Transaktion) und überprüfen, ob die Prüfsumme von ihrem neuem EVM-Status nach der Ausführung aller Transaktionen mit der Prüfsumme aus dem vom Miner-Block selbst behaupteten Status übereinstimmt. Nur dann fügen diese Nodes den Block an den Schwanz ihrer Blockchain an und akzeptieren den neuen EVM-Status als kanonischen Status.
7. Jeder Node entfernt alle Transaktionen in dem neuen Block aus seinem lokalen Mempool aus unerfüllten Transaktionsanfragen.
8. Neue Knoten, die dem Netzwerk beitreten, laden alle Blöcke in Reihenfolge herunter, einschließlich des Blocks mit der von uns vefolgten Transaktion. Sie initialisieren eine lokale EVM-Kopie (diese startet als ein leerer EVM-Status), gehen dann durch den Ausführungsprozess jeder Transaktion in jedem Block an der Spitze der lokalen EVM-Kopie und überprüfen dabei in jedem Block die Prüfsummenstatus.
-Jede Transaktion wird einmal gemint (in einen neuen Block eingeschlossen und zum ersten Mal propagiert), aber von jedem Teilnehmer im Prozess der Weitergabe des kanonischen EVM-Status ausgeführt und verifiziert. Dies hebt eines der wichtigsten Mantras der Blockchain hervor: **Nicht vertrauen – prüfen**.
+Jede Transaktion wird einmal gemint (in einen neuen Block eingeschlossen und zum ersten Mal propagiert), aber von jedem Teilnehmer im Prozess der Weitergabe des kanonischen EVM-Status ausgeführt und verifiziert. Dies unterstreicht eines der zentralen Mantras der Blockchain: **Nicht vertrauen, sondern verifizieren**.
-## Ommer(Onkel)-Blöcke {#ommer-blocks}
+## Ommer-Blöcke (Onkel-Blöcke) {#ommer-blocks}
-Das Mining von Blöcken bei Proof-of-Work war probabilistisch, was bedeutet, dass manchmal aufgrund von Netzwerklatenz gleichzeitig zwei gültige Blöcke veröffentlicht wurden. In diesem Fall musste das Protokoll die längste (und daher „gültigste“) Kette bestimmen und gleichzeitig Fairness gegenüber den Minern gewährleisten, indem es den vorgeschlagenen, aber nicht einbezogenen gültigen Block teilweise belohnte. Das förderte eine weitere Dezentralisierung des Netzwerks, da kleinere Miner, die möglicherweise mit größerer Latenz konfrontiert sind, immer noch Erträge durch [Ommer](/glossary/#ommer)-Blockbelohnungen generieren konnten.
+Das Mining von Blöcken bei Proof-of-Work war probabilistisch, was bedeutet, dass manchmal aufgrund von Netzwerklatenz gleichzeitig zwei gültige Blöcke veröffentlicht wurden. In diesem Fall musste das Protokoll die längste (und daher „gültigste“) Kette bestimmen und gleichzeitig Fairness gegenüber den Minern gewährleisten, indem es den vorgeschlagenen, aber nicht einbezogenen gültigen Block teilweise belohnte. Dies förderte die weitere Dezentralisierung des Netzwerks, da kleinere Miner, die möglicherweise mit einer größeren Latenz konfrontiert sind, über [Ommer](/glossary/#ommer)-Blockbelohnungen immer noch Renditen erwirtschaften konnten.
-Der Begriff „Ommer" ist der bevorzugte geschlechtsneutrale Begriff für das Geschwisterteil eines Elternblocks, aber manchmal ist auch die Rede von „Onkel". **Seit dem Übergang von Ethereum zu Proof-of-Stake werden keine Ommer-Blöcke mehr gemint**, da in jedem Slot nur ein Vorschlaggeber gewählt wird. Sie können diese Veränderung im [Geschichtsdiagramm](https://ycharts.com/indicators/ethereum_uncle_rate) der geminten Ommer-Blöcke einsehen.
+Der Begriff „Ommer" ist der bevorzugte geschlechtsneutrale Begriff für das Geschwisterteil eines Elternblocks, aber manchmal ist auch die Rede von „Onkel". **Seit dem Übergang von Ethereum auf Proof-of-Stake werden keine Ommer-Blöcke mehr gemint**, da in jedem Slot nur ein Vorschlaggeber gewählt wird. Diese Änderung können Sie im [historischen Diagramm](https://ycharts.com/indicators/ethereum_uncle_rate) der geminten Ommer-Blöcke einsehen.
## Eine visuelle Demo {#a-visual-demo}
@@ -75,12 +75,12 @@ Sehen Sie Austin bei einer Führung durch das Mining und die Proof-of-Work-Block
## Der Mining-Algorithmus {#mining-algorithm}
-Das Ethereum-Mainnet hat immer nur einen Mining-Algorithmus verwendet – [„Ethash“](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/). Ethash war der Nachfolger eines ursprünglichen Algorithmus für Forschung und Entwicklung namens [„Dagger-Hashimoto“](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/).
+Das Ethereum Mainnet hat immer nur einen einzigen Mining-Algorithmus verwendet – ['Ethash'](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/). Ethash war der Nachfolger eines ursprünglichen F&E-Algorithmus, der als ['Dagger-Hashimoto'](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/) bekannt war.
[Mehr über Mining-Algorithmen](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/).
## Verwandte Themen {#related-topics}
-- [Ressourcen](/developers/docs/gas/)
+- [Gas](/developers/docs/gas/)
- [EVM](/developers/docs/evm/)
-- [Proof-of-Work (Arbeitsnachweis)](/developers/docs/consensus-mechanisms/pow/)
+- [Proof-of-Work](/developers/docs/consensus-mechanisms/pow/)
diff --git a/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md b/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md
index 4279b0f0273..199e970d62d 100644
--- a/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md
+++ b/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md
@@ -4,32 +4,32 @@ description: Dagger-Hashimoto-Algorithmus im Detail.
lang: de
---
-Dagger-Hashimoto war die ursprüngliche Forschungsimplementierung und Spezifikation für den Mining-Algorithmus von Ethereum. Dagger-Hashimoto wurde durch [Ethash](#ethash) abgelöst. Das Mining wurde mit [der Zusammenführung](/roadmap/merge/) am 15. September 2022 komplett ausgeschaltet. Seitdem wird die Sicherheit von Ethereum durch einen [Proof-of-Stake](/developers/docs/consensus-mechanisms/pos)-Mechanismus gewährleistet. Diese Seite dient dem geschichtlichen Interesse – die Informationen hier sind seit der Zusammenführung für Ethereum nicht mehr relevant.
+Dagger-Hashimoto war die ursprüngliche Forschungsimplementierung und Spezifikation für den Mining-Algorithmus von Ethereum. Dagger-Hashimoto wurde durch [Ethash](#ethash) abgelöst. Das Mining wurde mit [der Zusammenführung](/roadmap/merge/) am 15. September 2022 komplett abgeschaltet. Seitdem wird Ethereum stattdessen über einen [Proof-of-Stake](/developers/docs/consensus-mechanisms/pos)-Mechanismus gesichert. Diese Seite dient dem geschichtlichen Interesse – die Informationen hier sind seit der Zusammenführung für Ethereum nicht mehr relevant.
## Voraussetzungen {#prerequisites}
-Um diese Seite besser zu verstehen, empfehlen wir Ihnen, sich zunächst in den [Proof-of-Work-Konsens](/developers/docs/consensus-mechanisms/pow), das [Mining](/developers/docs/consensus-mechanisms/pow/mining) und [Mining-Algorithmen](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms) einzulesen.
+Um diese Seite besser zu verstehen, empfehlen wir Ihnen, sich zunächst über den [Proof-of-Work-Konsens](/developers/docs/consensus-mechanisms/pow), das [Mining](/developers/docs/consensus-mechanisms/pow/mining) und [Mining-Algorithmen](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms) zu informieren.
## Dagger-Hashimoto {#dagger-hashimoto}
Dagger-Hashimoto will zwei Ziele erreichen:
-1. **ASIC-Resistenz**: Der Vorteil der Erstellung von spezieller Hardware für den Algorithmus sollte so gering wie möglich sein.
-2. **Light-Client-Verifizierbarkeit**: Ein Block sollte durch einen Light-Client effizient verifiziert werden können.
+1. **ASIC-Resistenz**: Der Nutzen aus der Erstellung spezialisierter Hardware für den Algorithmus sollte so gering wie möglich sein.
+2. **Light-Client-Verifizierbarkeit**: Ein Block sollte durch einen Light-Client effizient verifiziert werden können.
Durch eine weitere Modifikation spezifizieren wir außerdem, wie – sofern gewünscht – ein drittes Ziel erreicht wird, was jedoch zusätzliche Komplexität mit sich bringt:
-**Speichern der vollen Kette**: Mining sollte das Speichern des gesamten Blockchain-Status erfordern (wegen der irregulären Struktur des Ethereum-Statusbaums wird erwartet, dass einige Kürzungen möglich sein werden, insbedondere von eingen oft genutzten Contracts; dies soll aber minimiert werden).
+**Speicherung der gesamten Kette**: Mining sollte die Speicherung des kompletten Blockchain-Zustands erfordern (aufgrund der unregelmäßigen Struktur des Ethereum State-Tries gehen wir davon aus, dass ein gewisses Pruning möglich sein wird, insbesondere bei einigen häufig genutzten Contracts, aber wir wollen dies minimieren).
## DAG-Generierung {#dag-generation}
-Der Code für den Algorithmus wird unten in Python definiert. Zunächst geben wir `encode_int` zur Anordnung nicht unterzeichneter Einheiten spezifizierter Präzision an Strings. Die entsprechend Umkehrung wird ebenfalls bereitgestellt:
+Der Code für den Algorithmus wird unten in Python definiert. Zuerst stellen wir `encode_int` für das Marshalling von vorzeichenlosen Ganzzahlen (unsigned ints) mit festgelegter Präzision in Zeichenketten (Strings) bereit. Die entsprechend Umkehrung wird ebenfalls bereitgestellt:
```python
NUM_BITS = 512
def encode_int(x):
- "Encode an integer x as a string of 64 characters using a big-endian scheme"
+ "Kodiert eine Ganzzahl x als eine Zeichenkette von 64 Zeichen unter Verwendung eines Big-Endian-Schemas"
o = ''
for _ in range(NUM_BITS / 8):
o = chr(x % 256) + o
@@ -37,7 +37,7 @@ def encode_int(x):
return o
def decode_int(s):
- "Unencode an integer x from a string using a big-endian scheme"
+ "Dekodiert eine Ganzzahl x aus einer Zeichenkette unter Verwendung eines Big-Endian-Schemas"
x = 0
for c in s:
x *= 256
@@ -45,7 +45,7 @@ def decode_int(s):
return x
```
-Als Nächstes gehen wir davon aus, dass `sah3` eine Funktion ist, die eine Ganzzahl bezieht und eine Ganzzahl ausgibt, und `dbl_sah3` eine Doppelt-sah3-Funktion ist; wenn man diesen Referenzcode in eine Implementierungsanwendung umwandelt:
+Als Nächstes nehmen wir an, dass `sha3` eine Funktion ist, die eine Ganzzahl als Eingabe nimmt und eine Ganzzahl ausgibt, und `dbl_sha3` eine doppelte sha3-Funktion ist. Wenn Sie diesen Referenzcode in eine Implementierung umwandeln, verwenden Sie:
```python
from pyethereum import utils
@@ -65,26 +65,25 @@ def dbl_sha3(x):
Folgende Parameter werden für den Algorithmus verwendet:
```python
-SAFE_PRIME_512 = 2**512 - 38117 # Largest Safe Prime less than 2**512
+SAFE_PRIME_512 = 2**512 - 38117 # Größte sichere Primzahl kleiner als 2**512
params = {
- "n": 4000055296 * 8 // NUM_BITS, # Size of the dataset (4 Gigabytes); MUST BE MULTIPLE OF 65536
- "n_inc": 65536, # Increment in value of n per period; MUST BE MULTIPLE OF 65536
- # with epochtime=20000 gives 882 MB growth per year
- "cache_size": 2500, # Size of the light client's cache (can be chosen by light
- # client; not part of the algo spec)
- "diff": 2**14, # Difficulty (adjusted during block evaluation)
- "epochtime": 100000, # Length of an epoch in blocks (how often the dataset is updated)
- "k": 1, # Number of parents of a node
- "w": w, # Used for modular exponentiation hashing
- "accesses": 200, # Number of dataset accesses during hashimoto
- "P": SAFE_PRIME_512 # Safe Prime for hashing and random number generation
+ "n": 4000055296 * 8 // NUM_BITS, # Größe des Datensatzes (4 Gigabyte); MUSS EIN VIELFACHES VON 65536 SEIN
+ "n_inc": 65536, # Inkrement des Wertes n pro Periode; MUSS EIN VIELFACHES VON 65536 SEIN
+ # bei epochtime=20000 ergibt dies ein Wachstum von 882 MB pro Jahr
+ "cache_size": 2500, # Größe des Caches des Light-Clients (kann vom Light-Client gewählt werden; nicht Teil der Algo-Spezifikation)
+ "diff": 2**14, # Schwierigkeit (wird während der Blockauswertung angepasst)
+ "epochtime": 100000, # Länge einer Epoche in Blöcken (wie oft der Datensatz aktualisiert wird)
+ "k": 1, # Anzahl der Eltern eines Knotens
+ "w": w, # Wird für modulares Exponentiations-Hashing verwendet
+ "accesses": 200, # Anzahl der Datensatzzugriffe während Hashimoto
+ "P": SAFE_PRIME_512 # Sichere Primzahl für Hashing und Zufallszahlengenerierung
}
```
-`P` ist in diesem Fall eine Primzahl, die so gewählt wurde, dass `log₂(P)` nur etwas geringer als 512 ist, was den 512 Bits entspricht, die wir zur Darstellung unserer Zahlen nutzen. Beachten Sie, dass nur die zweite Hälfte des DAG tatsächlich gespeichert werden muss, sodass der tatsächliche RAM-Bedarf bei 1 GB beginnt und um 441 MB pro Jahr wächst.
+`P` ist in diesem Fall eine Primzahl, die so gewählt wurde, dass `log₂(P)` nur geringfügig kleiner als 512 ist, was den 512 Bits entspricht, die wir zur Darstellung unserer Zahlen verwendet haben. Beachten Sie, dass nur die zweite Hälfte des DAG tatsächlich gespeichert werden muss, sodass der tatsächliche RAM-Bedarf bei 1 GB beginnt und um 441 MB pro Jahr wächst.
-### Bau eines Dagger-Graphen {#dagger-graph-building}
+### Dagger-Graph-Erstellung {#dagger-graph-building}
Der Primitiv des Baus eines Dagger-Graphen ist wie folgt definiert:
@@ -101,11 +100,11 @@ def produce_dag(params, seed, length):
return o
```
-Im Wesentlichen wird ein Graph mit einem einzigen Knoten begonnen, `sha3(seed)`, und von dort aus werden nacheinander weitere Knoten auf der Grundlage zufälliger vorheriger Knoten hinzugefügt. Wenn ein neuer Knoten erstellt wird, wird eine modulare Potenz des Seeds berechnet, um zufällig einige Indizes auszuwählen, die kleiner sind als `i` (bei Verwendung von `x % i` oben), und die Werte der Knoten an diesen Indizes werden in einer Berechnung verwendet, um einen neuen Wert für `x` zu generieren, welcher dann in eine kleine Proof-of-Work-Funktion (auf XOR-Basis) hinzugegeben wird, um letztlich den Wert des Graphen an Index `i` zu generieren. Der Grundgedanke hinter diesem speziellen Design ist, einen sequentiellen Zugriff auf den DAG zu erzwingen; der nächste Wert des DAG, auf den zugegriffen wird, kann nicht bestimmt werden, bis der aktuelle Wert bekannt ist. Schließlich wird das Ergebnis durch modulare Potenzierung weiter gehasht.
+Im Wesentlichen beginnt ein Graph mit einem einzigen Knoten, `sha3(seed)`, und von dort aus werden nacheinander weitere Knoten auf der Grundlage zufälliger vorheriger Knoten hinzugefügt. Wenn ein neuer Knoten erstellt wird, wird eine modulare Potenz des Seeds berechnet, um zufällig einige Indizes kleiner als `i` auszuwählen (unter Verwendung von `x % i` oben). Die Werte der Knoten an diesen Indizes werden in einer Berechnung verwendet, um einen neuen Wert für `x` zu generieren, der dann in eine kleine Proof-of-Work-Funktion (basierend auf XOR) eingespeist wird, um schließlich den Wert des Graphen am Index `i` zu erzeugen. Der Grundgedanke hinter diesem speziellen Design ist, einen sequentiellen Zugriff auf den DAG zu erzwingen; der nächste Wert des DAG, auf den zugegriffen wird, kann nicht bestimmt werden, bis der aktuelle Wert bekannt ist. Schließlich wird das Ergebnis durch modulare Potenzierung weiter gehasht.
Dieser Algorithmus stützt sich auf mehrere Ergebnisse aus der Zahlentheorie. Schauen Sie sich den unteren Zusatz mit einer Diskussion an.
-## Light-Client-Bewertung {#light-client-evaluation}
+## Light-Client-Evaluierung {#light-client-evaluation}
Die oben beschriebene Konstruktion des Graphen soll es ermöglichen, jeden Knoten des Graphen zu rekonstruieren, indem ein Unterbaum mit nur wenigen Knoten berechnet wird und wobei nur nur eine geringe Menge an Zusatzspeicher notig ist. Beachten Sie, dass mit „k=1“ dieser Unterbaum nur eine Kette von Werten ist, die sich bis zum ersten Element im DAG hochziehen.
@@ -131,11 +130,11 @@ def quick_calc(params, seed, p):
return quick_calc_cached(p)
```
-Im Wesentlichen handelt es sich einfach um eine neue Implementierung des obigen Algorithmus, bei der die Schleife zur Berechnung der Werte für den gesamten DAG entfällt und die frühere Knotensuche durch einen rekursiven Aufruf oder eine Cache-Suche ersetzt wird. Beachten Sie, dass für `k=1` der Cache unnötig ist, obwohl eine weitere Optimierung die ersten paar Tausend Werte der DAG vorab berechnet und diese als statischen Cache für Berechnungen aufbewahrt; im Zusatz finden Sie eine entsprechende Code-Implementierung.
+Im Wesentlichen handelt es sich einfach um eine neue Implementierung des obigen Algorithmus, bei der die Schleife zur Berechnung der Werte für den gesamten DAG entfällt und die frühere Knotensuche durch einen rekursiven Aufruf oder eine Cache-Suche ersetzt wird. Beachten Sie, dass für `k=1` der Cache unnötig ist, obwohl eine weitere Optimierung tatsächlich die ersten paar tausend Werte des DAG vorab berechnet und diese als statischen Cache für Berechnungen behält; eine Code-Implementierung hierfür finden Sie im Anhang.
-## Doppelte DAG-Puffer {#double-buffer}
+## Doppelpuffer von DAGs {#double-buffer}
-In einem vollen Client wird ein [_doppelter Puffer_](https://wikipedia.org/wiki/Multiple_buffering) von 2 DAGs verwendet, die mithilfe der obigen Formel produziert wurden. Der Gedanke dahinter ist, dass DAGs jede `epochtime` Anzahl von Blöcken entsprechend den obigen Parametern erzeugt werden. Der Client verwendet nicht den zuletzt erstellten DAG, sondern den vorherigen. Das hat den Vorteil, dass die DAGs im Laufe der Zeit ersetzt werden können, ohne dass ein Schritt eingefügt werden muss, bei dem Miner plötzlich alle Daten neu berechnen müssen. Andernfalls besteht die Gefahr einer abrupten, vorübergehenden Verlangsamung der Chain-Verarbeitung in regelmäßigen Abständen und einer dramatisch zunehmenden Zentralisierung. Dadurch könnte es 51-%-Angriffe in diesen wenigen Minuten geben, bevor alle Daten neu berechnet sind.
+In einem Full-Client wird ein [_Doppelpuffer_](https://wikipedia.org/wiki/Multiple_buffering) aus 2 DAGs verwendet, die mit der obigen Formel erzeugt werden. Die Idee ist, dass DAGs alle `epochtime` Blöcke gemäß der obigen Parameter erzeugt werden. Der Client verwendet nicht den zuletzt erstellten DAG, sondern den vorherigen. Das hat den Vorteil, dass die DAGs im Laufe der Zeit ersetzt werden können, ohne dass ein Schritt eingefügt werden muss, bei dem Miner plötzlich alle Daten neu berechnen müssen. Andernfalls besteht die Gefahr einer abrupten, vorübergehenden Verlangsamung der Chain-Verarbeitung in regelmäßigen Abständen und einer dramatisch zunehmenden Zentralisierung. Dadurch könnte es 51-%-Angriffe in diesen wenigen Minuten geben, bevor alle Daten neu berechnet sind.
Der Algorithmus für das Generieren des DAG-Sets zur Berechnung der Arbeit für einen Block ist wie folgt:
@@ -254,56 +253,52 @@ Beachten Sie außerdem, dass Dagger-Hashimoto zusätzliche Anforderungen an den
- Damit eine Verifizierung mit zwei Ebenen funktioniert, muss ein Block-Header sowohl die Nonce als auch den mittleren Wert vor sha3 haben.
- Irgendwo muss ein Block-Header den sha3 des aktuellen Seed-Sets speichern.
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
-_Kennst du eine Community-Ressource, die dir geholfen hat? Bearbeite diese Seite und füge sie hinzu!_
+_Sie kennen Community-Resourcen die Ihnen geholfen haben? Bearbeiten Sie diese Seite und fügen Sie sie hinzu!_
## Anhang {#appendix}
-Wie oben erwähnt, basiert der für die DAG-Generierung verwendete RNG auf einigen Ergebnissen aus der Zahlentheorie. Zunächst stellen wir sicher, dass der Lehmer-RNG, welcher die Grundlage für die Variable `picker` bildet, eine lange Periode besitzt. Im zweiten Schritt zeigen wir, dass `pow(x,3,P)` `x` nicht `1` oder `P-1` zuordnet, sofern `x ∈ [2,P-2]` als Startwert gilt. Schließlich zeigen wir, dass `pow(x,3,P)` eine niedrige Kollisionsrate hat, wenn es als Hashing-Funktion behandelt wird.
+Wie oben erwähnt, basiert der für die DAG-Generierung verwendete RNG auf einigen Ergebnissen aus der Zahlentheorie. Zunächst stellen wir sicher, dass der Lehmer-RNG, der die Grundlage für die `picker`-Variable ist, eine lange Periode hat. Zweitens zeigen wir, dass `pow(x,3,P)` `x` nicht auf `1` oder `P-1` abbildet, vorausgesetzt `x ∈ [2,P-2]` ist der Startwert. Schließlich zeigen wir, dass `pow(x,3,P)` eine niedrige Kollisionsrate aufweist, wenn es als Hashing-Funktion behandelt wird.
### Lehmer-Zufallszahlengenerator {#lehmer-random-number}
Obwohl die Funktion `produce_dag` keine unverzerrten Zufallszahlen erzeugen muss, besteht eine potenzielle Gefahr darin, dass `seed**i % P` nur eine Handvoll Werte annimmt. Dies könnte Minern, die das Muster erkennen, einen Vorteil gegenüber denen verschaffen, die es nicht tun.
-Um dies zu vermeiden, wird auf ein Ergebnis aus der Zahlentheorie zurückgegriffen. Eine [_sichere Primzahl_](https://en.wikipedia.org/wiki/Safe_prime) ist definiert als eine Primzahl `P`, sodass `(P-1)/2` ebenfalls eine Primzahl ist. Die _Reihenfolge_ eines Mitglieds `x` der [multiplikativen Gruppe](https://en.wikipedia.org/wiki/Multiplicative_group_of_integers_modulo_n) `ℤ/nℤ` ist definiert als das minimale `m`, sodass xᵐ mod P ≡ 1
-Angesichts dieser Definitionen haben wir:
+Um dies zu vermeiden, wird auf ein Ergebnis aus der Zahlentheorie zurückgegriffen. Eine [_sichere Primzahl_](https://en.wikipedia.org/wiki/Safe_prime) ist definiert als eine Primzahl `P`, für die `(P-1)/2` ebenfalls eine Primzahl ist. Die _Ordnung_ eines Elements `x` der [multiplikativen Gruppe](https://en.wikipedia.org/wiki/Multiplicative_group_of_integers_modulo_n) `ℤ/nℤ` ist definiert als das minimale `m`, sodass xᵐ mod P ≡ 1
+Ausgehend von diesen Definitionen gilt:
-> Beobachtung 1. Lassen Sie `x` ein Mitglied der multiplikativen Gruppe `ℤ/Pℤ` für eine sichere Primzahl `P` sein. Bei `x mod P ≠ 1 mod P` und `x mod P ≠ P-1 mod P` ist die Ordnung von `x` entweder `P-1` oder `(P-1)/2`.
+> Beobachtung 1. `x` sei ein Element der multiplikativen Gruppe `ℤ/Pℤ` für eine sichere Primzahl `P`. Wenn `x mod P ≠ 1 mod P` und `x mod P ≠ P-1 mod P`, dann ist die Ordnung von `x` entweder `P-1` oder `(P-1)/2`.
-_Beweis_. Da `P` eine sichere Primzahl ist, gilt nach dem \[Satz von Lagrange\]\[lagrange\], dass die Ordnung von `x` entweder `1`, `2`, `(P-1)/2` oder `P-1` ist.
+_Beweis_. Da `P` eine sichere Primzahl ist, ist nach dem [Satz von Lagrange][lagrange] die Ordnung von `x` entweder `1`, `2`, `(P-1)/2` oder `P-1`.
-Die Ordnung von `x` kann nicht `1` sein, da wir gemäß dem Little Theorem von Fermat Folgendes haben:
+Die Ordnung von `x` kann nicht `1` sein, da nach dem kleinen Satz von Fermat gilt:
xP-1 mod P ≡ 1
-Daher muss `x` eine multiplikative Identität von `ℤ/nℤ` sein, die eindeutig ist. Da wir angenommen haben, dass `x ≠ 1`, ist dies nicht möglich.
+Daher muss `x` eine multiplikative Identität von `ℤ/nℤ` sein, die eindeutig ist. Da wir per Annahme `x ≠ 1` vorausgesetzt haben, ist dies nicht möglich.
-Die Ordnung von `x` kann nicht `2` sein, es sei denn, `x = P-1`, weil dies die Aussage verletzen würde, dass `P` eine Primzahl ist.
+Die Ordnung von `x` kann nicht `2` sein, es sei denn, `x = P-1`, da dies der Annahme, dass `P` eine Primzahl ist, widersprechen würde.
-Aus dem obigen Vorschlag können wir erkennen, dass die Iteration von `(picker * init) % P` eine Zykluslänge von mindestens `(P-1)/2` hat. Das liegt daran, dass wir `P` als sichere Primzahl gewählt haben, die etwa einer höheren Potenz von zwei entspricht, und `init` im Intervall `[2,2**256+1]` liegt. Angesichts der Größe von `P` sollten wir niemals einen Zyklus aus der modularen Potenzierung erwarten.
+Aus der obigen Aussage können wir erkennen, dass die Iteration von `(picker * init) % P` eine Zykluslänge von mindestens `(P-1)/2` haben wird. Das liegt daran, dass wir `P` als eine sichere Primzahl gewählt haben, die ungefähr einer höheren Zweierpotenz entspricht, und `init` im Intervall `[2,2**256+1]` liegt. Angesichts der Größenordnung von `P` sollten wir niemals einen Zyklus bei der modularen Exponentiation erwarten.
-Wenn wir die erste Zelle im DAG zuweisen (die Variable mit der Bezeichnung `init`), berechnen wir `pow(sha3(seed) + 2, 3, P)`. Auf den ersten Blick stellt dies nicht sicher, dass das Ergebnis weder `1` noch `P-1` ist. Da `P-1` jedoch eine sichere Primzahl ist, haben wir die folgende zusätzliche Sicherheit, die eine Folgerung aus Beobachtung 1 ist:
+Wenn wir die erste Zelle im DAG zuweisen (die Variable mit der Bezeichnung `init`), berechnen wir `pow(sha3(seed) + 2, 3, P)`. Auf den ersten Blick garantiert dies nicht, dass das Ergebnis weder `1` noch `P-1` ist. Da `P-1` jedoch eine sichere Primzahl ist, haben wir die folgende zusätzliche Zusicherung, die ein Korollar von Beobachtung 1 ist:
-> Beobachtung 2. `x` sei ein Element der multiplikativen Gruppe `ℤ/Pℤ` für eine sichere Primzahl `P`, und `w` sei eine natürliche Zahl. Wenn `x mod P ≠ 1 mod P` und `x mod P ≠ P-1 mod P` sowie `w mod P ≠ P-1 mod P` und `w mod P ≠ 0 mod P`, dann `xʷ mod P ≠ 1 mod P` und `xʷ mod P ≠ P-1 mod P`.
+> Beobachtung 2. `x` sei ein Element der multiplikativen Gruppe `ℤ/Pℤ` für eine sichere Primzahl `P`, und `w` sei eine natürliche Zahl. Wenn `x mod P ≠ 1 mod P` und `x mod P ≠ P-1 mod P`, sowie `w mod P ≠ P-1 mod P` und `w mod P ≠ 0 mod P`, dann `xʷ mod P ≠ 1 mod P` und `xʷ mod P ≠ P-1 mod P`
-### Modulare Potenzierung als Hash-Funktion {#modular-exponentiation}
+### Modulare Exponentiation als Hash-Funktion {#modular-exponentiation}
-Bei bestimmten Werten von `P` und `w` kann es bei der Funktion `pow(x, w, P)` zu zahlreichen Kollisionen kommen. Beispielsweise nimmt `pow(x,9,19)` nur die Werte `{1,18}` an.
+Für bestimmte Werte von `P` und `w` kann die Funktion `pow(x, w, P)` viele Kollisionen aufweisen. Beispielsweise nimmt `pow(x,9,19)` nur die Werte `{1,18}` an.
-Wenn `P` eine Primzahl ist, kann ein geeignetes `w` für eine Hash-Funktion zur modularen Potenzierung mithilfe des folgenden Ergebnisses ausgewählt werden:
+Vorausgesetzt, dass `P` eine Primzahl ist, kann ein geeignetes `w` für eine Hash-Funktion mit modularer Exponentiation unter Verwendung des folgenden Ergebnisses gewählt werden:
-> Beobachtung 3. `P` sei eine Primzahl; `w` und `P-1` sind nur dann teilerfremd, wenn für alle `a` und `b` in `ℤ/Pℤ` Folgendes gilt:
->
->
-> „aʷ mod P ≡ bʷ mod P“ gilt nur dann, wenn „a mod P ≡ b mod P“
->
+> Beobachtung 3. `P` sei eine Primzahl; `w` und `P-1` sind genau dann teilerfremd, wenn für alle `a` und `b` in `ℤ/Pℤ` gilt:`aʷ mod P ≡ bʷ mod P` genau dann, wenn `a mod P ≡ b mod P`
-Da `P` eine Primzahl ist und `w` teilerfremd zu `P-1` ist, gilt, dass `|{pow(x, w, P) : x ∈ ℤ}| = P`, was bedeutet, dass die Hashing-Funktion die minimal mögliche Kollisionsrate aufweist.
+Wenn also `P` eine Primzahl ist und `w` teilerfremd zu `P-1` ist, dann gilt `|{pow(x, w, P) : x ∈ ℤ}| = P`, was bedeutet, dass die Hashing-Funktion die geringstmögliche Kollisionsrate hat.
-Im speziellen Fall, dass `P` eine sichere Primzahl ist, wie wir sie ausgewählt haben, hat `P-1` nur die Faktoren 1, 2, `(P-1)/2` und `P-1`. Da `P` > 7 ist, wissen wir, dass 3 teilerfremd zu `P-1` ist, daher erfüllt `w=3` die obige Aussage.
+Im Sonderfall, dass `P` eine sichere Primzahl ist, wie wir sie gewählt haben, hat `P-1` nur die Faktoren 1, 2, `(P-1)/2` und `P-1`. Da `P` > 7, wissen wir, dass 3 teilerfremd zu `P-1` ist, daher erfüllt `w=3` die obige Aussage.
-## Effizienterer cache-basierter Auswertungsalgorithmus {#cache-based-evaluation}
+## Effizienterer Cache-basierter Auswertungsalgorithmus {#cache-based-evaluation}
```python
def quick_calc(params, seed, p):
diff --git a/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md b/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md
index b42bba6a799..ff1ddddd9a1 100644
--- a/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md
+++ b/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md
@@ -8,12 +8,12 @@ lang: de
- Ethash war der Proof-of-Work-Mining-Algorithmus von Ethereum. Proof-of-work wurde nun **komplett abgeschaltet** und Ethereum wird jetzt stattdessen durch [Proof-of-Stake](/developers/docs/consensus-mechanisms/pos/) gesichert. Lesen Sie mehr über [die Zusammenführung](/roadmap/merge/), [Proof-of-Stake](/developers/docs/consensus-mechanisms/pos/) und [Staking](/staking/). Diese Seite dient dem geschichtlichen Interesse!
+ Ethash war der Proof-of-Work-Mining-Algorithmus von Ethereum. Proof-of-Work wurde mittlerweile **komplett abgeschaltet** und Ethereum wird nun durch [Proof-of-Stake](/developers/docs/consensus-mechanisms/pos/) gesichert. Lesen Sie mehr über [The Merge](/roadmap/merge/), [Proof-of-Stake](/developers/docs/consensus-mechanisms/pos/) und [Staking](/staking/). Diese Seite dient dem geschichtlichen Interesse!
-Ethash ist eine modifizierte Version des [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto)-Algorithmus. Ethash-Proof-of-Work ist [speicherhart](https://wikipedia.org/wiki/Memory-hard_function), was die Algorithmus-ASIC resistent machen sollte. Zwar wurden schließlich Ethash-ASICs entwickelt, aber GPU-Mining war weiterhin eine gangbare Option, bis Proof-of-Work abgeschaltet wurde. Ethash wird immer noch verwendet, um andere Coins zu minen, die nicht auf Proof-of-Work-Netzwerken von Ethereum laufen.
+Ethash ist eine modifizierte Version des [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto)-Algorithmus. Der Ethash-Proof-of-Work ist [speicherhart](https://wikipedia.org/wiki/Memory-hard_function), weshalb angenommen wurde, dass der Algorithmus ASIC-resistent ist. Zwar wurden schließlich Ethash-ASICs entwickelt, aber GPU-Mining war weiterhin eine gangbare Option, bis Proof-of-Work abgeschaltet wurde. Ethash wird immer noch verwendet, um andere Coins zu minen, die nicht auf Proof-of-Work-Netzwerken von Ethereum laufen.
## Wie funktioniert Ethash? {#how-does-ethash-work}
@@ -21,9 +21,9 @@ Speicherhärte wird durch einen Proof-of-Work-Algorithmus erreicht, der das Ausw
Die allgemeine Route, die der Algorithmus nimmt, ist wie folgt:
-1. Es gibt einen **Seed**, welcher für jeden Block berechnet werden kann, indem die Block-Header bis zu diesem Punkt durchsucht werden.
-2. Aus dem Seed kann ein **16 MB großer pseudozufälliger Cache** berechnet werden. Light-Clients speichern den Cache.
-3. Aus dem Cache können wir einen **1 GB großen Datensatz** mit der Eigenschaft generieren, dass jedes Element im Datensatz nur von einer sehr kleinen Anzahl an Elementen aus dem Cache abhängt. Volle Clients und Miner speichern den Datensatz. Der Datensatz wächst linear über die Zeit.
+1. Es existiert ein **Seed**, der für jeden Block berechnet werden kann, indem die Block-Header bis zu diesem Punkt durchsucht werden.
+2. Aus dem Seed kann ein **pseudozufälliger 16-MB-Cache** berechnet werden. Light-Clients speichern den Cache.
+3. Aus dem Cache können wir einen **1-GB-Datensatz** mit der Eigenschaft generieren, dass jedes Element im Datensatz nur von einer kleinen Anzahl von Elementen aus dem Cache abhängt. Volle Clients und Miner speichern den Datensatz. Der Datensatz wächst linear über die Zeit.
4. Beim Mining werden zufällige Ausschnitte aus dem Datensatz entnommen und zu einem Hash zusammengefügt. Die Verifizierung kann mit wenig Speicher durchgeführt werden, indem der Cache verwendet wird, um die spezifischen Teile des Datensatzes, die Sie benötigen, neu zu generieren, sodass Sie nur den Cache speichern müssen.
Der große Datensatz wird alle 30.000 Blöcke aktualisiert, sodass der größte Teil der Arbeit eines Miners darin besteht, den Datensatz zu lesen, und nicht darin, ihn zu verändern.
@@ -33,23 +33,23 @@ Der große Datensatz wird alle 30.000 Blöcke aktualisiert, sodass der größte
Wir verwenden die folgenden Definitionen:
```
-WORD_BYTES = 4 # bytes in word
-DATASET_BYTES_INIT = 2**30 # bytes in dataset at genesis
-DATASET_BYTES_GROWTH = 2**23 # dataset growth per epoch
-CACHE_BYTES_INIT = 2**24 # bytes in cache at genesis
-CACHE_BYTES_GROWTH = 2**17 # cache growth per epoch
-CACHE_MULTIPLIER=1024 # Size of the DAG relative to the cache
-EPOCH_LENGTH = 30000 # blocks per epoch
-MIX_BYTES = 128 # width of mix
-HASH_BYTES = 64 # hash length in bytes
-DATASET_PARENTS = 256 # number of parents of each dataset element
-CACHE_ROUNDS = 3 # number of rounds in cache production
-ACCESSES = 64 # number of accesses in hashimoto loop
+WORD_BYTES = 4 # Bytes im Wort
+DATASET_BYTES_INIT = 2**30 # Bytes im Datensatz bei Genesis
+DATASET_BYTES_GROWTH = 2**23 # Datensatzwachstum pro Epoche
+CACHE_BYTES_INIT = 2**24 # Bytes im Cache bei Genesis
+CACHE_BYTES_GROWTH = 2**17 # Cache-Wachstum pro Epoche
+CACHE_MULTIPLIER=1024 # Größe des DAG relativ zum Cache
+EPOCH_LENGTH = 30000 # Blöcke pro Epoche
+MIX_BYTES = 128 # Breite des Mix
+HASH_BYTES = 64 # Hash-Länge in Bytes
+DATASET_PARENTS = 256 # Anzahl der Parents jedes Datensatzelements
+CACHE_ROUNDS = 3 # Anzahl der Runden in der Cache-Erstellung
+ACCESSES = 64 # Anzahl der Zugriffe in der Hashimoto-Schleife
```
-### Die Verwendung von „SHA3“ {#sha3}
+### Die Verwendung von 'SHA3' {#sha3}
-Die Entwicklung von Ethereum fiel mit der Entwicklung des SHA3-Standards zusammen, und im Verlauf des Standardisierungsprozesses wurde eine späte Änderung im Padding des finalen Hash-Algorithmus vorgenommen. Daher sind Ethereums „sha3_256“- und „sha3_512“-Hashes keine standardmäßigen SHA3-Hashes, sondern eine Abwandlung, die in anderen Zusammenhängen oft als „Keccak-256“ und „Keccak-512“ bezeichnet wird. Die Diskussion finden Sie beispielsweise [hier](https://eips.ethereum.org/EIPS/eip-1803), [hier](http://ethereum.stackexchange.com/questions/550/which-cryptographic-hash-function-does-ethereum-use) oder [hier](http://bitcoin.stackexchange.com/questions/42055/what-is-the-approach-to-calculate-an-ethereum-address-from-a-256-bit-private-key/42057#42057).
+Die Entwicklung von Ethereum fiel mit der Entwicklung des SHA3-Standards zusammen, und im Verlauf des Standardisierungsprozesses wurde eine späte Änderung im Padding des finalen Hash-Algorithmus vorgenommen. Daher sind Ethereums „sha3_256“- und „sha3_512“-Hashes keine standardmäßigen SHA3-Hashes, sondern eine Abwandlung, die in anderen Zusammenhängen oft als „Keccak-256“ und „Keccak-512“ bezeichnet wird. Siehe Diskussion, z. B. [hier](https://eips.ethereum.org/EIPS/eip-1803), [hier](http://ethereum.stackexchange.com/questions/550/which-cryptographic-hash-function-does-ethereum-use) oder [hier](http://bitcoin.stackexchange.com/questions/42055/what-is-the-approach-to-calculate-an-ethereum-address-from-a-256-bit-private-key/42057#42057).
Bitte behalten Sie das im Hinterkopf, da im Folgenden bei der Beschreibung des Algorithmus auf „sha3“-Hashes Bezug genommen wird.
@@ -75,7 +75,7 @@ def get_full_size(block_number):
Tabellen mit Werten zu Datensatz- und Cache-Größe finden Sie im Zusatz.
-## Cache-Gegerierung {#cache-generation}
+## Cache-Generierung {#cache-generation}
Nun geben wir die Funktion zur Erzeugung eines Cache an:
@@ -83,12 +83,12 @@ Nun geben wir die Funktion zur Erzeugung eines Cache an:
def mkcache(cache_size, seed):
n = cache_size // HASH_BYTES
- # Sequentially produce the initial dataset
+ # Sequenziell den initialen Datensatz erstellen
o = [sha3_512(seed)]
for i in range(1, n):
o.append(sha3_512(o[-1]))
- # Use a low-round version of randmemohash
+ # Eine Version von randmemohash mit wenigen Runden verwenden
for _ in range(CACHE_ROUNDS):
for i in range(n):
v = o[i][0] % n
@@ -97,9 +97,9 @@ def mkcache(cache_size, seed):
return o
```
-Der Cache-Produktionsprozess des Cache umfasst zunächst das sequenzielle Auffüllen von 32 MB Speicher und dann das Ausführen von zwei Durchläufen des _RandMemoHash_-Algorithmus von Sergio Demian Lerner aus [_Strict Memory Hard Hashing Functions_ (2014)](http://www.hashcash.org/papers/memohash.pdf). Die Ausgabe ist ein Satz von 524288 64-Byte-Werten.
+Der Prozess der Cache-Erstellung beinhaltet zunächst das sequenzielle Füllen von 32 MB Speicher und anschließend die Durchführung von zwei Durchläufen des _RandMemoHash_-Algorithmus von Sergio Demian Lerner aus [_Strict Memory Hard Hashing Functions_ (2014)](http://www.hashcash.org/papers/memohash.pdf). Die Ausgabe ist ein Satz von 524288 64-Byte-Werten.
-## Funktion der Datenaggregation {#date-aggregation-function}
+## Datenaggregationsfunktion {#date-aggregation-function}
Wir verwenden in einigen Fällen einen vom [FNV-Hash](https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function) inspirierten Algorithmus als nicht-assoziativen Ersatz für XOR. Beachten Sie, dass wir die Primzahl mit dem vollständigen 32-Bit-Input multiplizieren, im Gegensatz zur FNV-1-Spezifikation, die die Primzahl wiederum mit einem Byte (Oktett) multipliziert.
@@ -112,7 +112,7 @@ def fnv(v1, v2):
Bitte beachten Sie, dass selbst das Yellow Paper fnv als v1\*(FNV_PRIME ^ v2) spezifiziert, alle aktuellen Implementierungen verwenden durchgängig die obige Definition.
-## Berechnung des gesamten Datensatzes {#full-dataset-calculation}
+## Berechnung des vollständigen Datensatzes {#full-dataset-calculation}
Jedes 64-Byte-Element im vollständigen 1-GB-Datensatz wird wie folgt berechnet:
@@ -120,11 +120,11 @@ Jedes 64-Byte-Element im vollständigen 1-GB-Datensatz wird wie folgt berechnet:
def calc_dataset_item(cache, i):
n = len(cache)
r = HASH_BYTES // WORD_BYTES
- # initialize the mix
+ # den Mix initialisieren
mix = copy.copy(cache[i % n])
mix[0] ^= i
mix = sha3_512(mix)
- # fnv it with a lot of random cache nodes based on i
+ # FNV mit vielen zufälligen Cache-Nodes basierend auf i anwenden
for j in range(DATASET_PARENTS):
cache_index = fnv(i ^ j, mix[j % r])
mix = map(fnv, mix, cache[cache_index % n])
@@ -140,27 +140,27 @@ def calc_dataset(full_size, cache):
## Hauptschleife {#main-loop}
-Nun legen wir die „Hashimoto“-ähnliche Hauptschleife fest, in der wir Daten aus dem gesamten Datensatz aggregieren, um unseren endgültigen Wert für einen bestimmten Header und eine bestimmte Nonce zu ermitteln. Im folgenden Code stellt `header` den SHA3-256-_Hash_ der RLP-Darstellung eines _abgeschnittenen_ Block-Headers dar, d. h. eines Headers ohne die Felder **mixHash** und **nonce**. `nonce` sind die acht Byte einer vorzeichenlosen 64-Bit-Ganzzahl in Big-Endian-Reihenfolge. Daher ist `nonce[::-1]` die Little-Endian-Darstellung dieses Werts mit acht Byte:
+Nun legen wir die „Hashimoto“-ähnliche Hauptschleife fest, in der wir Daten aus dem gesamten Datensatz aggregieren, um unseren endgültigen Wert für einen bestimmten Header und eine bestimmte Nonce zu ermitteln. Im nachstehenden Code stellt `header` den SHA3-256-_Hash_ der RLP-Darstellung eines _abgeschnittenen_ Block-Headers dar, d. h. eines Headers ohne die Felder **mixHash** und **nonce**. `nonce` sind die acht Bytes einer vorzeichenlosen 64-Bit-Ganzzahl in Big-Endian-Reihenfolge. Daher ist `nonce[::-1]` die Acht-Byte-Little-Endian-Darstellung dieses Wertes:
```python
def hashimoto(header, nonce, full_size, dataset_lookup):
n = full_size / HASH_BYTES
w = MIX_BYTES // WORD_BYTES
mixhashes = MIX_BYTES / HASH_BYTES
- # combine header+nonce into a 64 byte seed
+ # header+nonce zu einem 64-Byte-Seed kombinieren
s = sha3_512(header + nonce[::-1])
- # start the mix with replicated s
+ # den Mix mit repliziertem s starten
mix = []
for _ in range(MIX_BYTES / HASH_BYTES):
mix.extend(s)
- # mix in random dataset nodes
+ # zufällige Datensatz-Nodes einmischen
for i in range(ACCESSES):
p = fnv(i ^ s[0], mix[i % w]) % (n // mixhashes) * mixhashes
newdata = []
for j in range(MIX_BYTES / HASH_BYTES):
newdata.extend(dataset_lookup(p + j))
mix = map(fnv, mix, newdata)
- # compress mix
+ # Mix komprimieren
cmix = []
for i in range(0, len(mix), 4):
cmix.append(fnv(fnv(fnv(mix[i], mix[i+1]), mix[i+2]), mix[i+3]))
@@ -176,9 +176,9 @@ def hashimoto_full(full_size, dataset, header, nonce):
return hashimoto(header, nonce, full_size, lambda x: dataset[x])
```
-Im Wesentlichen halten wir einen 128 Byte breiten „Mix“ aufrecht und holen wiederholt sequentiell 128 Byte aus dem vollständigen Datensatz, um sie mithilfe der `fnv`-Funktion mit dem Mix zu kombinieren. Es werden 128 Byte sequentieller Zugriff verwendet, sodass bei jeder Runde des Algorithmus immer eine vollständige Seite aus dem RAM geholt wird, wodurch Fehlübersetzungen im Lookaside-Puffer, die ASICs theoretisch vermeiden könnten, minimiert werden.
+Im Wesentlichen pflegen wir einen 128 Byte breiten \"Mix\", rufen wiederholt sequenziell 128 Bytes aus dem vollständigen Datensatz ab und kombinieren sie mithilfe der `fnv`-Funktion mit dem Mix. Es werden 128 Byte sequentieller Zugriff verwendet, sodass bei jeder Runde des Algorithmus immer eine vollständige Seite aus dem RAM geholt wird, wodurch Fehlübersetzungen im Lookaside-Puffer, die ASICs theoretisch vermeiden könnten, minimiert werden.
-Liegt das Ergebnis dieses Algorithmus unter dem gewünschten Zielwert, so ist die Nonce gültig. Beachten Sie, dass die zusätzliche Anwendung von `sha3_256` am Ende sicherstellt, dass es eine Zwischen-Nonce gibt, die bereitgestellt werden kann, um zu beweisen, dass zumindest etwas Arbeit geleistet wurde; diese schnelle äußere PoW-Verifizierung kann für Anti-DoS-Zwecke verwendet werden. Ein weiterer Zweck ist die statistische Sicherheit darüber, dass das Ergebnis eine unverzerrte 256-Bit-Zahl ist.
+Liegt das Ergebnis dieses Algorithmus unter dem gewünschten Zielwert, so ist die Nonce gültig. Beachten Sie, dass die zusätzliche Anwendung von `sha3_256` am Ende sicherstellt, dass eine intermediäre Nonce existiert, die bereitgestellt werden kann, um zu beweisen, dass zumindest ein geringer Arbeitsaufwand erbracht wurde; diese schnelle äußere PoW-Verifizierung kann für Anti-DDoS-Zwecke verwendet werden. Ein weiterer Zweck ist die statistische Sicherheit darüber, dass das Ergebnis eine unverzerrte 256-Bit-Zahl ist.
## Mining {#mining}
@@ -186,7 +186,7 @@ Der Mining-Algorithmus wird wie folgt definiert:
```python
def mine(full_size, dataset, header, difficulty):
- # zero-pad target to compare with hash on the same digit
+ # Ziel mit Nullen auffüllen, um es mit dem Hash an derselben Ziffer zu vergleichen
target = zpad(encode_int(2**256 // difficulty), 64)[::-1]
from random import randint
nonce = randint(0, 2**64)
@@ -195,7 +195,7 @@ def mine(full_size, dataset, header, difficulty):
return nonce
```
-## Seed-Hashes definieren {#seed-hash}
+## Definition des Seed-Hashes {#seed-hash}
Um den Seed-Hash zu berechnen, der für das Mining auf einem bestimmten Block verwendet wird, nutzen wir den folgenden Algorithmus:
@@ -209,18 +209,18 @@ Um den Seed-Hash zu berechnen, der für das Mining auf einem bestimmten Block ve
Beachten Sie, dass wir für reibungsloses Mining und Überprüfen empfehlen, zukünftige Seed-Hashes und Datensätze in einem separaten Thread vorab zu berechnen.
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
-_Kennen Sie eine Community-Ressource, die Ihnen geholfen hat? Bearbeiten Sie diese Seite und fügen Sie sie hinzu._
+_Sie kennen Community-Resourcen die Ihnen geholfen haben? Bearbeiten Sie diese Seite und fügen Sie sie hinzu!_
-## Zusatz {#appendix}
+## Anhang {#appendix}
Der folgende Code sollte vorangestellt werden, wenn Sie daran interessiert sind, die obige Python-Spezifikation als Code auszuführen.
```python
import sha3, copy
-# Assumes little endian bit ordering (same as Intel architectures)
+# Setzt Little-Endian-Bit-Reihenfolge voraus (wie bei Intel-Architekturen)
def decode_int(s):
return int(s[::-1].encode('hex'), 16) if s else 0
@@ -248,7 +248,7 @@ def serialize_cache(ds):
serialize_dataset = serialize_cache
-# sha3 hash function, outputs 64 bytes
+# SHA3-Hash-Funktion, gibt 64 Bytes aus
def sha3_512(x):
return hash_words(lambda v: sha3.sha3_512(v).digest(), 64, x)
@@ -751,269 +751,268 @@ cache_sizes = [
70907968, 71040832, 71171648, 71303104, 71432512, 71564992, 71695168,
71826368, 71958464, 72089536, 72219712, 72350144, 72482624, 72613568,
72744512, 72875584, 73006144, 73138112, 73268672, 73400128, 73530944,
-73662272, 73793344, 73924544, 74055104, 74185792, 74316992, 74448832,
-74579392, 74710976, 74841664, 74972864, 75102784, 75233344, 75364544,
-75497024, 75627584, 75759296, 75890624, 76021696, 76152256, 76283072,
-76414144, 76545856, 76676672, 76806976, 76937792, 77070016, 77200832,
-77331392, 77462464, 77593664, 77725376, 77856448, 77987776, 78118336,
-78249664, 78380992, 78511424, 78642496, 78773056, 78905152, 79033664,
-79166656, 79297472, 79429568, 79560512, 79690816, 79822784, 79953472,
-80084672, 80214208, 80346944, 80477632, 80608576, 80740288, 80870848,
-81002048, 81133504, 81264448, 81395648, 81525952, 81657536, 81786304,
-81919808, 82050112, 82181312, 82311616, 82443968, 82573376, 82705984,
-82835776, 82967744, 83096768, 83230528, 83359552, 83491264, 83622464,
-83753536, 83886016, 84015296, 84147776, 84277184, 84409792, 84540608,
-84672064, 84803008, 84934336, 85065152, 85193792, 85326784, 85458496,
-85589312, 85721024, 85851968, 85982656, 86112448, 86244416, 86370112,
-86506688, 86637632, 86769344, 86900672, 87031744, 87162304, 87293632,
-87424576, 87555392, 87687104, 87816896, 87947968, 88079168, 88211264,
-88341824, 88473152, 88603712, 88735424, 88862912, 88996672, 89128384,
-89259712, 89390272, 89521984, 89652544, 89783872, 89914816, 90045376,
-90177088, 90307904, 90438848, 90569152, 90700096, 90832832, 90963776,
-91093696, 91223744, 91356992, 91486784, 91618496, 91749824, 91880384,
-92012224, 92143552, 92273344, 92405696, 92536768, 92666432, 92798912,
-92926016, 93060544, 93192128, 93322816, 93453632, 93583936, 93715136,
-93845056, 93977792, 94109504, 94240448, 94371776, 94501184, 94632896,
-94764224, 94895552, 95023424, 95158208, 95287744, 95420224, 95550016,
-95681216, 95811904, 95943872, 96075328, 96203584, 96337856, 96468544,
-96599744, 96731072, 96860992, 96992576, 97124288, 97254848, 97385536,
-97517248, 97647808, 97779392, 97910464, 98041408, 98172608, 98303168,
-98434496, 98565568, 98696768, 98827328, 98958784, 99089728, 99220928,
-99352384, 99482816, 99614272, 99745472, 99876416, 100007104,
-100138048, 100267072, 100401088, 100529984, 100662592, 100791872,
-100925248, 101056064, 101187392, 101317952, 101449408, 101580608,
-101711296, 101841728, 101973824, 102104896, 102235712, 102366016,
-102498112, 102628672, 102760384, 102890432, 103021888, 103153472,
-103284032, 103415744, 103545152, 103677248, 103808576, 103939648,
-104070976, 104201792, 104332736, 104462528, 104594752, 104725952,
-104854592, 104988608, 105118912, 105247808, 105381184, 105511232,
-105643072, 105774784, 105903296, 106037056, 106167872, 106298944,
-106429504, 106561472, 106691392, 106822592, 106954304, 107085376,
-107216576, 107346368, 107478464, 107609792, 107739712, 107872192,
-108003136, 108131392, 108265408, 108396224, 108527168, 108657344,
-108789568, 108920384, 109049792, 109182272, 109312576, 109444928,
-109572928, 109706944, 109837888, 109969088, 110099648, 110230976,
-110362432, 110492992, 110624704, 110755264, 110886208, 111017408,
-111148864, 111279296, 111410752, 111541952, 111673024, 111803456,
-111933632, 112066496, 112196416, 112328512, 112457792, 112590784,
-112715968, 112852672, 112983616, 113114944, 113244224, 113376448,
-113505472, 113639104, 113770304, 113901376, 114031552, 114163264,
-114294592, 114425536, 114556864, 114687424, 114818624, 114948544,
-115080512, 115212224, 115343296, 115473472, 115605184, 115736128,
-115867072, 115997248, 116128576, 116260288, 116391488, 116522944,
-116652992, 116784704, 116915648, 117046208, 117178304, 117308608,
-117440192, 117569728, 117701824, 117833024, 117964096, 118094656,
-118225984, 118357312, 118489024, 118617536, 118749632, 118882112,
-119012416, 119144384, 119275328, 119406016, 119537344, 119668672,
-119798464, 119928896, 120061376, 120192832, 120321728, 120454336,
-120584512, 120716608, 120848192, 120979136, 121109056, 121241408,
-121372352, 121502912, 121634752, 121764416, 121895744, 122027072,
-122157632, 122289088, 122421184, 122550592, 122682944, 122813888,
-122945344, 123075776, 123207488, 123338048, 123468736, 123600704,
-123731264, 123861952, 123993664, 124124608, 124256192, 124386368,
-124518208, 124649024, 124778048, 124911296, 125041088, 125173696,
-125303744, 125432896, 125566912, 125696576, 125829056, 125958592,
-126090304, 126221248, 126352832, 126483776, 126615232, 126746432,
-126876608, 127008704, 127139392, 127270336, 127401152, 127532224,
-127663552, 127794752, 127925696, 128055232, 128188096, 128319424,
-128449856, 128581312, 128712256, 128843584, 128973632, 129103808,
-129236288, 129365696, 129498944, 129629888, 129760832, 129892288,
-130023104, 130154048, 130283968, 130416448, 130547008, 130678336,
-130807616, 130939456, 131071552, 131202112, 131331776, 131464384,
-131594048, 131727296, 131858368, 131987392, 132120256, 132250816,
-132382528, 132513728, 132644672, 132774976, 132905792, 133038016,
-133168832, 133299392, 133429312, 133562048, 133692992, 133823296,
-133954624, 134086336, 134217152, 134348608, 134479808, 134607296,
-134741056, 134872384, 135002944, 135134144, 135265472, 135396544,
-135527872, 135659072, 135787712, 135921472, 136052416, 136182848,
-136313792, 136444864, 136576448, 136707904, 136837952, 136970048,
-137099584, 137232064, 137363392, 137494208, 137625536, 137755712,
-137887424, 138018368, 138149824, 138280256, 138411584, 138539584,
-138672832, 138804928, 138936128, 139066688, 139196864, 139328704,
-139460032, 139590208, 139721024, 139852864, 139984576, 140115776,
-140245696, 140376512, 140508352, 140640064, 140769856, 140902336,
-141032768, 141162688, 141294016, 141426496, 141556544, 141687488,
-141819584, 141949888, 142080448, 142212544, 142342336, 142474432,
-142606144, 142736192, 142868288, 142997824, 143129408, 143258944,
-143392448, 143523136, 143653696, 143785024, 143916992, 144045632,
-144177856, 144309184, 144440768, 144570688, 144701888, 144832448,
-144965056, 145096384, 145227584, 145358656, 145489856, 145620928,
-145751488, 145883072, 146011456, 146144704, 146275264, 146407232,
-146538176, 146668736, 146800448, 146931392, 147062336, 147193664,
-147324224, 147455936, 147586624, 147717056, 147848768, 147979456,
-148110784, 148242368, 148373312, 148503232, 148635584, 148766144,
-148897088, 149028416, 149159488, 149290688, 149420224, 149551552,
-149683136, 149814976, 149943616, 150076352, 150208064, 150338624,
-150470464, 150600256, 150732224, 150862784, 150993088, 151125952,
-151254976, 151388096, 151519168, 151649728, 151778752, 151911104,
-152042944, 152174144, 152304704, 152435648, 152567488, 152698816,
-152828992, 152960576, 153091648, 153222976, 153353792, 153484096,
-153616192, 153747008, 153878336, 154008256, 154139968, 154270912,
-154402624, 154533824, 154663616, 154795712, 154926272, 155057984,
-155188928, 155319872, 155450816, 155580608, 155712064, 155843392,
-155971136, 156106688, 156237376, 156367424, 156499264, 156630976,
-156761536, 156892352, 157024064, 157155008, 157284416, 157415872,
-157545536, 157677248, 157810496, 157938112, 158071744, 158203328,
-158334656, 158464832, 158596288, 158727616, 158858048, 158988992,
-159121216, 159252416, 159381568, 159513152, 159645632, 159776192,
-159906496, 160038464, 160169536, 160300352, 160430656, 160563008,
-160693952, 160822208, 160956352, 161086784, 161217344, 161349184,
-161480512, 161611456, 161742272, 161873216, 162002752, 162135872,
-162266432, 162397888, 162529216, 162660032, 162790976, 162922048,
-163052096, 163184576, 163314752, 163446592, 163577408, 163707968,
-163839296, 163969984, 164100928, 164233024, 164364224, 164494912,
-164625856, 164756672, 164887616, 165019072, 165150016, 165280064,
-165412672, 165543104, 165674944, 165805888, 165936832, 166067648,
-166198336, 166330048, 166461248, 166591552, 166722496, 166854208,
-166985408, 167116736, 167246656, 167378368, 167508416, 167641024,
-167771584, 167903168, 168034112, 168164032, 168295744, 168427456,
-168557632, 168688448, 168819136, 168951616, 169082176, 169213504,
-169344832, 169475648, 169605952, 169738048, 169866304, 169999552,
-170131264, 170262464, 170393536, 170524352, 170655424, 170782016,
-170917696, 171048896, 171179072, 171310784, 171439936, 171573184,
-171702976, 171835072, 171966272, 172097216, 172228288, 172359232,
-172489664, 172621376, 172747712, 172883264, 173014208, 173144512,
-173275072, 173407424, 173539136, 173669696, 173800768, 173931712,
-174063424, 174193472, 174325696, 174455744, 174586816, 174718912,
-174849728, 174977728, 175109696, 175242688, 175374272, 175504832,
-175636288, 175765696, 175898432, 176028992, 176159936, 176291264,
-176422592, 176552512, 176684864, 176815424, 176946496, 177076544,
-177209152, 177340096, 177470528, 177600704, 177731648, 177864256,
-177994816, 178126528, 178257472, 178387648, 178518464, 178650176,
-178781888, 178912064, 179044288, 179174848, 179305024, 179436736,
-179568448, 179698496, 179830208, 179960512, 180092608, 180223808,
-180354752, 180485696, 180617152, 180748096, 180877504, 181009984,
-181139264, 181272512, 181402688, 181532608, 181663168, 181795136,
-181926592, 182057536, 182190016, 182320192, 182451904, 182582336,
-182713792, 182843072, 182976064, 183107264, 183237056, 183368384,
-183494848, 183631424, 183762752, 183893824, 184024768, 184154816,
-184286656, 184417984, 184548928, 184680128, 184810816, 184941248,
-185072704, 185203904, 185335616, 185465408, 185596352, 185727296,
-185859904, 185989696, 186121664, 186252992, 186383552, 186514112,
-186645952, 186777152, 186907328, 187037504, 187170112, 187301824,
-187429184, 187562048, 187693504, 187825472, 187957184, 188087104,
-188218304, 188349376, 188481344, 188609728, 188743616, 188874304,
-189005248, 189136448, 189265088, 189396544, 189528128, 189660992,
-189791936, 189923264, 190054208, 190182848, 190315072, 190447424,
-190577984, 190709312, 190840768, 190971328, 191102656, 191233472,
-191364032, 191495872, 191626816, 191758016, 191888192, 192020288,
-192148928, 192282176, 192413504, 192542528, 192674752, 192805952,
-192937792, 193068608, 193198912, 193330496, 193462208, 193592384,
-193723456, 193854272, 193985984, 194116672, 194247232, 194379712,
-194508352, 194641856, 194772544, 194900672, 195035072, 195166016,
-195296704, 195428032, 195558592, 195690304, 195818176, 195952576,
-196083392, 196214336, 196345792, 196476736, 196607552, 196739008,
-196869952, 197000768, 197130688, 197262784, 197394368, 197523904,
-197656384, 197787584, 197916608, 198049472, 198180544, 198310208,
-198442432, 198573632, 198705088, 198834368, 198967232, 199097792,
-199228352, 199360192, 199491392, 199621696, 199751744, 199883968,
-200014016, 200146624, 200276672, 200408128, 200540096, 200671168,
-200801984, 200933312, 201062464, 201194944, 201326144, 201457472,
-201588544, 201719744, 201850816, 201981632, 202111552, 202244032,
-202374464, 202505152, 202636352, 202767808, 202898368, 203030336,
-203159872, 203292608, 203423296, 203553472, 203685824, 203816896,
-203947712, 204078272, 204208192, 204341056, 204472256, 204603328,
-204733888, 204864448, 204996544, 205125568, 205258304, 205388864,
-205517632, 205650112, 205782208, 205913536, 206044736, 206176192,
-206307008, 206434496, 206569024, 206700224, 206831168, 206961856,
-207093056, 207223616, 207355328, 207486784, 207616832, 207749056,
-207879104, 208010048, 208141888, 208273216, 208404032, 208534336,
-208666048, 208796864, 208927424, 209059264, 209189824, 209321792,
-209451584, 209582656, 209715136, 209845568, 209976896, 210106432,
-210239296, 210370112, 210501568, 210630976, 210763712, 210894272,
-211024832, 211156672, 211287616, 211418176, 211549376, 211679296,
-211812032, 211942592, 212074432, 212204864, 212334016, 212467648,
-212597824, 212727616, 212860352, 212991424, 213120832, 213253952,
-213385024, 213515584, 213645632, 213777728, 213909184, 214040128,
-214170688, 214302656, 214433728, 214564544, 214695232, 214826048,
-214956992, 215089088, 215219776, 215350592, 215482304, 215613248,
-215743552, 215874752, 216005312, 216137024, 216267328, 216399296,
-216530752, 216661696, 216790592, 216923968, 217054528, 217183168,
-217316672, 217448128, 217579072, 217709504, 217838912, 217972672,
-218102848, 218233024, 218364736, 218496832, 218627776, 218759104,
-218888896, 219021248, 219151936, 219281728, 219413056, 219545024,
-219675968, 219807296, 219938624, 220069312, 220200128, 220331456,
-220461632, 220592704, 220725184, 220855744, 220987072, 221117888,
-221249216, 221378368, 221510336, 221642048, 221772736, 221904832,
-222031808, 222166976, 222297536, 222428992, 222559936, 222690368,
-222820672, 222953152, 223083968, 223213376, 223345984, 223476928,
-223608512, 223738688, 223869376, 224001472, 224132672, 224262848,
-224394944, 224524864, 224657344, 224788288, 224919488, 225050432,
-225181504, 225312704, 225443776, 225574592, 225704768, 225834176,
-225966784, 226097216, 226229824, 226360384, 226491712, 226623424,
-226754368, 226885312, 227015104, 227147456, 227278528, 227409472,
-227539904, 227669696, 227802944, 227932352, 228065216, 228196288,
-228326464, 228457792, 228588736, 228720064, 228850112, 228981056,
-229113152, 229243328, 229375936, 229505344, 229636928, 229769152,
-229894976, 230030272, 230162368, 230292416, 230424512, 230553152,
-230684864, 230816704, 230948416, 231079616, 231210944, 231342016,
-231472448, 231603776, 231733952, 231866176, 231996736, 232127296,
-232259392, 232388672, 232521664, 232652608, 232782272, 232914496,
-233043904, 233175616, 233306816, 233438528, 233569984, 233699776,
-233830592, 233962688, 234092224, 234221888, 234353984, 234485312,
-234618304, 234749888, 234880832, 235011776, 235142464, 235274048,
-235403456, 235535936, 235667392, 235797568, 235928768, 236057152,
-236190272, 236322752, 236453312, 236583616, 236715712, 236846528,
-236976448, 237108544, 237239104, 237371072, 237501632, 237630784,
-237764416, 237895232, 238026688, 238157632, 238286912, 238419392,
-238548032, 238681024, 238812608, 238941632, 239075008, 239206336,
-239335232, 239466944, 239599168, 239730496, 239861312, 239992384,
-240122816, 240254656, 240385856, 240516928, 240647872, 240779072,
-240909632, 241040704, 241171904, 241302848, 241433408, 241565248,
-241696192, 241825984, 241958848, 242088256, 242220224, 242352064,
-242481856, 242611648, 242744896, 242876224, 243005632, 243138496,
-243268672, 243400384, 243531712, 243662656, 243793856, 243924544,
-244054592, 244187072, 244316608, 244448704, 244580032, 244710976,
-244841536, 244972864, 245104448, 245233984, 245365312, 245497792,
-245628736, 245759936, 245889856, 246021056, 246152512, 246284224,
-246415168, 246545344, 246675904, 246808384, 246939584, 247070144,
-247199552, 247331648, 247463872, 247593536, 247726016, 247857088,
-247987648, 248116928, 248249536, 248380736, 248512064, 248643008,
-248773312, 248901056, 249036608, 249167552, 249298624, 249429184,
-249560512, 249692096, 249822784, 249954112, 250085312, 250215488,
-250345792, 250478528, 250608704, 250739264, 250870976, 251002816,
-251133632, 251263552, 251395136, 251523904, 251657792, 251789248,
-251919424, 252051392, 252182464, 252313408, 252444224, 252575552,
-252706624, 252836032, 252968512, 253099712, 253227584, 253361728,
-253493056, 253623488, 253754432, 253885504, 254017216, 254148032,
-254279488, 254410432, 254541376, 254672576, 254803264, 254933824,
-255065792, 255196736, 255326528, 255458752, 255589952, 255721408,
-255851072, 255983296, 256114624, 256244416, 256374208, 256507712,
-256636096, 256768832, 256900544, 257031616, 257162176, 257294272,
-257424448, 257555776, 257686976, 257818432, 257949632, 258079552,
-258211136, 258342464, 258473408, 258603712, 258734656, 258867008,
-258996544, 259127744, 259260224, 259391296, 259522112, 259651904,
-259784384, 259915328, 260045888, 260175424, 260308544, 260438336,
-260570944, 260700992, 260832448, 260963776, 261092672, 261226304,
-261356864, 261487936, 261619648, 261750592, 261879872, 262011968,
-262143424, 262274752, 262404416, 262537024, 262667968, 262799296,
-262928704, 263061184, 263191744, 263322944, 263454656, 263585216,
-263716672, 263847872, 263978944, 264108608, 264241088, 264371648,
-264501184, 264632768, 264764096, 264895936, 265024576, 265158464,
-265287488, 265418432, 265550528, 265681216, 265813312, 265943488,
-266075968, 266206144, 266337728, 266468032, 266600384, 266731072,
-266862272, 266993344, 267124288, 267255616, 267386432, 267516992,
-267648704, 267777728, 267910592, 268040512, 268172096, 268302784,
-268435264, 268566208, 268696256, 268828096, 268959296, 269090368,
-269221312, 269352256, 269482688, 269614784, 269745856, 269876416,
-270007616, 270139328, 270270272, 270401216, 270531904, 270663616,
-270791744, 270924736, 271056832, 271186112, 271317184, 271449536,
-271580992, 271711936, 271843136, 271973056, 272105408, 272236352,
-272367296, 272498368, 272629568, 272759488, 272891456, 273022784,
-273153856, 273284672, 273415616, 273547072, 273677632, 273808448,
-273937088, 274071488, 274200896, 274332992, 274463296, 274595392,
-274726208, 274857536, 274988992, 275118656, 275250496, 275382208,
-275513024, 275643968, 275775296, 275906368, 276037184, 276167872,
-276297664, 276429376, 276560576, 276692672, 276822976, 276955072,
-277085632, 277216832, 277347008, 277478848, 277609664, 277740992,
-277868608, 278002624, 278134336, 278265536, 278395328, 278526784,
-278657728, 278789824, 278921152, 279052096, 279182912, 279313088,
-279443776, 279576256, 279706048, 279838528, 279969728, 280099648,
-280230976, 280361408, 280493632, 280622528, 280755392, 280887104,
-281018176, 281147968, 281278912, 281411392, 281542592, 281673152,
-281803712, 281935552, 282066496, 282197312, 282329024, 282458816,
-282590272, 282720832, 282853184, 282983744, 283115072, 283246144,
-283377344, 283508416, 283639744, 283770304, 283901504, 284032576,
-284163136, 284294848, 284426176, 284556992, 284687296, 284819264,
-284950208, 285081536]
+73662272, 73793344, 74055104, 74185792, 74316992, 74448832, 74579392,
+74710976, 74841664, 74972864, 75102784, 75233344, 75364544, 75497024,
+75627584, 75759296, 75890624, 76021696, 76152256, 76283072, 76414144,
+76545856, 76676672, 76806976, 76937792, 77070016, 77200832, 77331392,
+77462464, 77593664, 77725376, 77856448, 77987776, 78118336, 78249664,
+78380992, 78511424, 78642496, 78773056, 78905152, 79033664, 79166656,
+79297472, 79429568, 79560512, 79690816, 79822784, 79953472, 80084672,
+80214208, 80346944, 80477632, 80608576, 80740288, 80870848, 81002048,
+81133504, 81264448, 81395648, 81525952, 81657536, 81786304, 81919808,
+82050112, 82181312, 82311616, 82443968, 82573376, 82705984, 82835776,
+82967744, 83096768, 83230528, 83359552, 83491264, 83622464, 83753536,
+83886016, 84015296, 84147776, 84277184, 84409792, 84540608, 84672064,
+84803008, 84934336, 85065152, 85193792, 85326784, 85458496, 85589312,
+85721024, 85851968, 85982656, 86112448, 86244416, 86370112, 86506688,
+86637632, 86769344, 86900672, 87031744, 87162304, 87293632, 87424576,
+87555392, 87687104, 87816896, 87947968, 88079168, 88211264, 88341824,
+88473152, 88603712, 88735424, 88862912, 88996672, 89128384, 89259712,
+89390272, 89521984, 89652544, 89783872, 89914816, 90045376, 90177088,
+90307904, 90438848, 90569152, 90700096, 90832832, 90963776, 91093696,
+91223744, 91356992, 91486784, 91618496, 91749824, 91880384, 92012224,
+92143552, 92273344, 92405696, 92536768, 92666432, 92798912, 92926016,
+93060544, 93192128, 93322816, 93453632, 93583936, 93715136, 93845056,
+93977792, 94109504, 94240448, 94371776, 94501184, 94632896, 94764224,
+94895552, 95023424, 95158208, 95287744, 95420224, 95550016, 95681216,
+95811904, 95943872, 96075328, 96203584, 96337856, 96468544, 96599744,
+96731072, 96860992, 96992576, 97124288, 97254848, 97385536, 97517248,
+97647808, 97779392, 97910464, 98041408, 98172608, 98303168, 98434496,
+98565568, 98696768, 98827328, 98958784, 99089728, 99220928, 99352384,
+99482816, 99614272, 99745472, 99876416, 100007104, 100138048, 100267072,
+100401088, 100529984, 100662592, 100791872, 100925248, 101056064, 101187392,
+101317952, 101449408, 101580608, 101711296, 101841728, 101973824,
+102104896, 102235712, 102366016, 102498112, 102628672, 102760384,
+102890432, 103021888, 103153472, 103284032, 103415744, 103545152,
+103677248, 103808576, 103939648, 104070976, 104201792, 104332736,
+104462528, 104594752, 104725952, 104854592, 104988608, 105118912,
+105247808, 105381184, 105511232, 105643072, 105774784, 105903296,
+106037056, 106167872, 106298944, 106429504, 106561472, 106691392,
+106822592, 106954304, 107085376, 107216576, 107346368, 107478464,
+107609792, 107739712, 107872192, 108003136, 108131392, 108265408,
+108396224, 108527168, 108657344, 108789568, 108920384, 109049792,
+109182272, 109312576, 109444928, 109572928, 109706944, 109837888,
+109969088, 110099648, 110230976, 110362432, 110492992, 110624704,
+110755264, 110886208, 111017408, 111148864, 111279296, 111410752,
+111541952, 111673024, 111803456, 111933632, 112066496, 112196416,
+112328512, 112457792, 112590784, 112715968, 112852672, 112983616,
+113114944, 113244224, 113376448, 113505472, 113639104, 113770304,
+113901376, 114031552, 114163264, 114294592, 114425536, 114556864,
+114687424, 114818624, 114948544, 115080512, 115212224, 115343296,
+115473472, 115605184, 115736128, 115867072, 115997248, 116128576,
+116260288, 116391488, 116522944, 116652992, 116784704, 116915648,
+117046208, 117178304, 117308608, 117440192, 117569728, 117701824,
+117833024, 117964096, 118094656, 118225984, 118357312, 118489024,
+118617536, 118749632, 118882112, 119012416, 119144384, 119275328,
+119406016, 119537344, 119668672, 119798464, 119928896, 120061376,
+120192832, 120321728, 120454336, 120584512, 120716608, 120848192,
+120979136, 121109056, 121241408, 121372352, 121502912, 121634752,
+121764416, 121895744, 122027072, 122157632, 122289088, 122421184,
+122550592, 122682944, 122813888, 122945344, 123075776, 123207488,
+123338048, 123468736, 123600704, 123731264, 123861952, 123993664,
+124124608, 124256192, 124386368, 124518208, 124649024, 124778048,
+124911296, 125041088, 125173696, 125303744, 125432896, 125566912,
+125696576, 125829056, 125958592, 126090304, 126221248, 126352832,
+126483776, 126615232, 126746432, 126876608, 127008704, 127139392,
+127270336, 127401152, 127532224, 127663552, 127794752, 127925696,
+128055232, 128188096, 128319424, 128449856, 128581312, 128712256,
+128843584, 128973632, 129103808, 129236288, 129365696, 129498944,
+129629888, 129760832, 129892288, 130023104, 130154048, 130283968,
+130416448, 130547008, 130678336, 130807616, 130939456, 131071552,
+131202112, 131331776, 131464384, 131594048, 131727296, 131858368,
+131987392, 132120256, 132250816, 132382528, 132513728, 132644672,
+132774976, 132905792, 133038016, 133168832, 133299392, 133429312,
+133562048, 133692992, 133823296, 133954624, 134086336, 134217152,
+134348608, 134479808, 134607296, 134741056, 134872384, 135002944,
+135134144, 135265472, 135396544, 135527872, 135659072, 135787712,
+135921472, 136052416, 136182848, 136313792, 136444864, 136576448,
+136707904, 136837952, 136970048, 137099584, 137232064, 137363392,
+137494208, 137625536, 137755712, 137887424, 138018368, 138149824,
+138280256, 138411584, 138539584, 138672832, 138804928, 138936128,
+139066688, 139196864, 139328704, 139460032, 139590208, 139721024,
+139852864, 139984576, 140115776, 140245696, 140376512, 140508352,
+140640064, 140769856, 140902336, 141032768, 141162688, 141294016,
+141426496, 141556544, 141687488, 141819584, 141949888, 142080448,
+142212544, 142342336, 142474432, 142606144, 142736192, 142868288,
+142997824, 143129408, 143258944, 143392448, 143523136, 143653696,
+143785024, 143916992, 144045632, 144177856, 144309184, 144440768,
+144570688, 144701888, 144832448, 144965056, 145096384, 145227584,
+145358656, 145489856, 145620928, 145751488, 145883072, 146011456,
+146144704, 146275264, 146407232, 146538176, 146668736, 146800448,
+146931392, 147062336, 147193664, 147324224, 147455936, 147586624,
+147717056, 147848768, 147979456, 148110784, 148242368, 148373312,
+148503232, 148635584, 148766144, 148897088, 149028416, 149159488,
+149290688, 149420224, 149551552, 149683136, 149814976, 149943616,
+150076352, 150208064, 150338624, 150470464, 150600256, 150732224,
+150862784, 150993088, 151125952, 151254976, 151388096, 151519168,
+151649728, 151778752, 151911104, 152042944, 152174144, 152304704,
+152435648, 152567488, 152698816, 152828992, 152960576, 153091648,
+153222976, 153353792, 153484096, 153616192, 153747008, 153878336,
+154008256, 154139968, 154270912, 154402624, 154533824, 154663616,
+154795712, 154926272, 155057984, 155188928, 155319872, 155450816,
+155580608, 155712064, 155843392, 155971136, 156106688, 156237376,
+156367424, 156499264, 156630976, 156761536, 156892352, 157024064,
+157155008, 157284416, 157415872, 157545536, 157677248, 157810496,
+157938112, 158071744, 158203328, 158334656, 158464832, 158596288,
+158727616, 158858048, 158988992, 159121216, 159252416, 159381568,
+159513152, 159645632, 159776192, 159906496, 160038464, 160169536,
+160300352, 160430656, 160563008, 160693952, 160822208, 160956352,
+161086784, 161217344, 161349184, 161480512, 161611456, 161742272,
+161873216, 162002752, 162135872, 162266432, 162397888, 162529216,
+162660032, 162790976, 162922048, 163052096, 163184576, 163314752,
+163446592, 163577408, 163707968, 163839296, 163969984, 164100928,
+164233024, 164364224, 164494912, 164625856, 164756672, 164887616,
+165019072, 165150016, 165280064, 165412672, 165543104, 165674944,
+165805888, 165936832, 166067648, 166198336, 166330048, 166461248,
+166591552, 166722496, 166854208, 166985408, 167116736, 167246656,
+167378368, 167508416, 167641024, 167771584, 167903168, 168034112,
+168164032, 168295744, 168427456, 168557632, 168688448, 168819136,
+168951616, 169082176, 169213504, 169344832, 169475648, 169605952,
+169738048, 169866304, 169999552, 170131264, 170262464, 170393536,
+170524352, 170655424, 170782016, 170917696, 171048896, 171179072,
+171310784, 171439936, 171573184, 171702976, 171835072, 171966272,
+172097216, 172228288, 172359232, 172489664, 172621376, 172747712,
+172883264, 173014208, 173144512, 173275072, 173407424, 173539136,
+173669696, 173800768, 173931712, 174063424, 174193472, 174325696,
+174455744, 174586816, 174718912, 174849728, 174977728, 175109696,
+175242688, 175374272, 175504832, 175636288, 175765696, 175898432,
+176028992, 176159936, 176291264, 176422592, 176552512, 176684864,
+176815424, 176946496, 177076544, 177209152, 177340096, 177470528,
+177600704, 177731648, 177864256, 177994816, 178126528, 178257472,
+178387648, 178518464, 178650176, 178781888, 178912064, 179044288,
+179174848, 179305024, 179436736, 179568448, 179698496, 179830208,
+179960512, 180092608, 180223808, 180354752, 180485696, 180617152,
+180748096, 180877504, 181009984, 181139264, 181272512, 181402688,
+181532608, 181663168, 181795136, 181926592, 182057536, 182190016,
+182320192, 182451904, 182582336, 182713792, 182843072, 182976064,
+183107264, 183237056, 183368384, 183494848, 183631424, 183762752,
+183893824, 184024768, 184154816, 184286656, 184417984, 184548928,
+184680128, 184810816, 184941248, 185072704, 185203904, 185335616,
+185465408, 185596352, 185727296, 185859904, 185989696, 186121664,
+186252992, 186383552, 186514112, 186645952, 186777152, 186907328,
+187037504, 187170112, 187301824, 187429184, 187562048, 187693504,
+187825472, 187957184, 188087104, 188218304, 188349376, 188481344,
+188609728, 188743616, 188874304, 189005248, 189136448, 189265088,
+189396544, 189528128, 189660992, 189791936, 189923264, 190054208,
+190182848, 190315072, 190447424, 190577984, 190709312, 190840768,
+190971328, 191102656, 191233472, 191364032, 191495872, 191626816,
+191758016, 191888192, 192020288, 192148928, 192282176, 192413504,
+192542528, 192674752, 192805952, 192937792, 193068608, 193198912,
+193330496, 193462208, 193592384, 193723456, 193854272, 193985984,
+194116672, 194247232, 194379712, 194508352, 194641856, 194772544,
+194900672, 195035072, 195166016, 195296704, 195428032, 195558592,
+195690304, 195818176, 195952576, 196083392, 196214336, 196345792,
+196476736, 196607552, 196739008, 196869952, 197000768, 197130688,
+197262784, 197394368, 197523904, 197656384, 197787584, 197916608,
+198049472, 198180544, 198310208, 198442432, 198573632, 198705088,
+198834368, 198967232, 199097792, 199228352, 199360192, 199491392,
+199621696, 199751744, 199883968, 200014016, 200146624, 200276672,
+200408128, 200540096, 200671168, 200801984, 200933312, 201062464,
+201194944, 201326144, 201457472, 201588544, 201719744, 201850816,
+201981632, 202111552, 202244032, 202374464, 202505152, 202636352,
+202767808, 202898368, 203030336, 203159872, 203292608, 203423296,
+203553472, 203685824, 203816896, 203947712, 204078272, 204208192,
+204341056, 204472256, 204603328, 204733888, 204864448, 204996544,
+205125568, 205258304, 205388864, 205517632, 205650112, 205782208,
+205913536, 206044736, 206176192, 206307008, 206434496, 206569024,
+206700224, 206831168, 206961856, 207093056, 207223616, 207355328,
+207486784, 207616832, 207749056, 207879104, 208010048, 208141888,
+208273216, 208404032, 208534336, 208666048, 208796864, 208927424,
+209059264, 209189824, 209321792, 209451584, 209582656, 209715136,
+209845568, 209976896, 210106432, 210239296, 210370112, 210501568,
+210630976, 210763712, 210894272, 211024832, 211156672, 211287616,
+211418176, 211549376, 211679296, 211812032, 211942592, 212074432,
+212204864, 212334016, 212467648, 212597824, 212727616, 212860352,
+212991424, 213120832, 213253952, 213385024, 213515584, 213645632,
+213777728, 213909184, 214040128, 214170688, 214302656, 214433728,
+214564544, 214695232, 214826048, 214956992, 215089088, 215219776,
+215350592, 215482304, 215613248, 215743552, 215874752, 216005312,
+216137024, 216267328, 216399296, 216530752, 216661696, 216790592,
+216923968, 217054528, 217183168, 217316672, 217448128, 217579072,
+217709504, 217838912, 217972672, 218102848, 218233024, 218364736,
+218496832, 218627776, 218759104, 218888896, 219021248, 219151936,
+219281728, 219413056, 219545024, 219675968, 219807296, 219938624,
+220069312, 220200128, 220331456, 220461632, 220592704, 220725184,
+220855744, 220987072, 221117888, 221249216, 221378368, 221510336,
+221642048, 221772736, 221904832, 222031808, 222166976, 222297536,
+222428992, 222559936, 222690368, 222820672, 222953152, 223083968,
+223213376, 223345984, 223476928, 223608512, 223738688, 223869376,
+224001472, 224132672, 224262848, 224394944, 224524864, 224657344,
+224788288, 224919488, 225050432, 225181504, 225312704, 225443776,
+225574592, 225704768, 225834176, 225966784, 226097216, 226229824,
+226360384, 226491712, 226623424, 226754368, 226885312, 227015104,
+227147456, 227278528, 227409472, 227539904, 227669696, 227802944,
+227932352, 228065216, 228196288, 228326464, 228457792, 228588736,
+228720064, 228850112, 228981056, 229113152, 229243328, 229375936,
+229505344, 229636928, 229769152, 229894976, 230030272, 230162368,
+230292416, 230424512, 230553152, 230684864, 230816704, 230948416,
+231079616, 231210944, 231342016, 231472448, 231603776, 231733952,
+231866176, 231996736, 232127296, 232259392, 232388672, 232521664,
+232652608, 232782272, 232914496, 233043904, 233175616, 233306816,
+233438528, 233569984, 233699776, 233830592, 233962688, 234092224,
+234221888, 234353984, 234485312, 234618304, 234749888, 234880832,
+235011776, 235142464, 235274048, 235403456, 235535936, 235667392,
+235797568, 235928768, 236057152, 236190272, 236322752, 236453312,
+236583616, 236715712, 236846528, 236976448, 237108544, 237239104,
+237371072, 237501632, 237630784, 237764416, 237895232, 238026688,
+238157632, 238286912, 238419392, 238548032, 238681024, 238812608,
+238941632, 239075008, 239206336, 239335232, 239466944, 239599168,
+239730496, 239861312, 239992384, 240122816, 240254656, 240385856,
+240516928, 240647872, 240779072, 240909632, 241040704, 241171904,
+241302848, 241433408, 241565248, 241696192, 241825984, 241958848,
+242088256, 242220224, 242352064, 242481856, 242611648, 242744896,
+242876224, 243005632, 243138496, 243268672, 243400384, 243531712,
+243662656, 243793856, 243924544, 244054592, 244187072, 244316608,
+244448704, 244580032, 244710976, 244841536, 244972864, 245104448,
+245233984, 245365312, 245497792, 245628736, 245759936, 245889856,
+246021056, 246152512, 246284224, 246415168, 246545344, 246675904,
+246808384, 246939584, 247070144, 247199552, 247331648, 247463872,
+247593536, 247726016, 247857088, 247987648, 248116928, 248249536,
+248380736, 248512064, 248643008, 248773312, 248901056, 249036608,
+249167552, 249298624, 249429184, 249560512, 249692096, 249822784,
+249954112, 250085312, 250215488, 250345792, 250478528, 250608704,
+250739264, 250870976, 251002816, 251133632, 251263552, 251395136,
+251523904, 251657792, 251789248, 251919424, 252051392, 252182464,
+252313408, 252444224, 252575552, 252706624, 252836032, 252968512,
+253099712, 253227584, 253361728, 253493056, 253623488, 253754432,
+253885504, 254017216, 254148032, 254279488, 254410432, 254541376,
+254672576, 254803264, 254933824, 255065792, 255196736, 255326528,
+255458752, 255589952, 255721408, 255851072, 255983296, 256114624,
+256244416, 256374208, 256507712, 256636096, 256768832, 256900544,
+257031616, 257162176, 257294272, 257424448, 257555776, 257686976,
+257818432, 257949632, 258079552, 258211136, 258342464, 258473408,
+258603712, 258734656, 258867008, 258996544, 259127744, 259260224,
+259391296, 259522112, 259651904, 259784384, 259915328, 260045888,
+260175424, 260308544, 260438336, 260570944, 260700992, 260832448,
+260963776, 261092672, 261226304, 261356864, 261487936, 261619648,
+261750592, 261879872, 262011968, 262143424, 262274752, 262404416,
+262537024, 262667968, 262799296, 262928704, 263061184, 263191744,
+263322944, 263454656, 263585216, 263716672, 263847872, 263978944,
+264108608, 264241088, 264371648, 264501184, 264632768, 264764096,
+264895936, 265024576, 265158464, 265287488, 265418432, 265550528,
+265681216, 265813312, 265943488, 266075968, 266206144, 266337728,
+266468032, 266600384, 266731072, 266862272, 266993344, 267124288,
+267255616, 267386432, 267516992, 267648704, 267777728, 267910592,
+268040512, 268172096, 268302784, 268435264, 268566208, 268696256,
+268828096, 268959296, 269090368, 269221312, 269352256, 269482688,
+269614784, 269745856, 269876416, 270007616, 270139328, 270270272,
+270401216, 270531904, 270663616, 270791744, 270924736, 271056832,
+271186112, 271317184, 271449536, 271580992, 271711936, 271843136,
+271973056, 272105408, 272236352, 272367296, 272498368, 272629568,
+272759488, 272891456, 273022784, 273153856, 273284672, 273415616,
+273547072, 273677632, 273808448, 273937088, 274071488, 274200896,
+274332992, 274463296, 274595392, 274726208, 274857536, 274988992,
+275118656, 275250496, 275382208, 275513024, 275643968, 275775296,
+275906368, 276037184, 276167872, 276297664, 276429376, 276560576,
+276692672, 276822976, 276955072, 277085632, 277216832, 277347008,
+277478848, 277609664, 277740992, 277868608, 278002624, 278134336,
+278265536, 278395328, 278526784, 278657728, 278789824, 279052096,
+279182912, 279313088, 279443776, 279576256, 279706048, 279838528,
+279969728, 280099648, 280230976, 280361408, 280493632, 280622528,
+280755392, 280887104, 281018176, 281147968, 281278912, 281411392,
+281542592, 281673152, 281803712, 281935552, 282066496, 282197312,
+282329024, 282458816, 282590272, 282720832, 282853184, 282983744,
+283115072, 283246144, 283377344, 283508416, 283639744, 283770304,
+283901504, 284032576, 284163136, 284294848, 284426176, 284556992,
+284687296, 284819264, 284950208, 285081536]
```
diff --git a/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md b/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md
index b7edea0d218..edbaeff9b34 100644
--- a/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md
+++ b/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md
@@ -8,7 +8,7 @@ lang: de
-Proof-of-work ist nicht länger Ethereums Konsensmechanismus. Dies bedeutet, dass das Minen abgeschaltet wurde. Ethereum wird stattdessen durch Validatoren gesichert, die ETH einsetzen. Sie können schon heute mit dem Staking von ETH beginnen. Lese mehr dazu unter den Merge, Proof-of-Stake, und Staking. Diese Seite dient ausschließlich dem geschichtlichen Interesse.
+Proof-of-Work ist nicht mehr der zugrunde liegende Konsensmechanismus von Ethereum, was bedeutet, dass das Mining ausgeschaltet wurde. Stattdessen wird Ethereum von Validatoren gesichert, die ETH staken. Sie können schon heute mit dem Staking von ETH beginnen. Lese mehr dazu unter den Merge, Proof-of-Stake, und Staking. Diese Seite dient ausschließlich dem geschichtlichen Interesse.
@@ -17,26 +17,26 @@ Ethereum-Mining nutzte einen Algorithmus namens Ethash. Die Grundidee des Algori
## Voraussetzungen {#prerequisites}
-Um diese Seite besser zu verstehen, empfehlen wir, dass Sie zunächst etwas über den [Proof-of-Work-Konsens](/developers/docs/consensus-mechanisms/pow) und [das Mining](/developers/docs/consensus-mechanisms/pow/mining) lesen.
+Um diese Seite besser zu verstehen, empfehlen wir Ihnen, sich zunächst über den [Proof-of-Work-Konsens](/developers/docs/consensus-mechanisms/pow) und das [Mining](/developers/docs/consensus-mechanisms/pow/mining) zu informieren.
-## Dagger-Hashimoto {#dagger-hashimoto}
+## Dagger Hashimoto {#dagger-hashimoto}
Dagger Hashimoto war ein Wegbereiter-Forschungsalgorithmus für das Ethereum-Mining, der von Ethash abgelöst wurde. Er war eine Verschmelzung zweier anderer Algorithmen: Dagger und Hashimoto. Er war stets nur eine Forschungsimplementierung und wurde mit Veröffentlichung des Ethereum-Mainnets von Ethash abgelöst.
-[Dagger](http://www.hashcash.org/papers/dagger.html) beinhaltet unter anderem die Generierung eines [Directed Acyclic Graph](https://en.wikipedia.org/wiki/Directed_acyclic_graph), von dem zufällige Teile zu einem Hash-Wert zusammengefügt werden. Der Grundgedanke beruht darauf, dass jede Nonce nur einen kleinen Abschnitt eines großen Gesamt-Datenbaums benötigt. Den Unterbaum für jede Nonce neu zu berechnen, würde Mining unmöglich machen – weshalb der Baum gespeichert werden muss –, doch für die Verifizierung einer einzigen Nonce ist dieser Vorgang in Ordnung. Dagger wurde als Alternative zu bestehenden Algorithmen wie Scrypt entwickelt, die speicherhart, aber schwer zu verifizieren sind, wenn ihre Speicherhärte auf tatsächlich sichere Ebenen ansteigt. Dagger hatte jedoch Schwachstellen durch Hardwarebeschleunigung in Shared-Memory-Umgebungen und wurde daher durch andere Methoden in der Forschung ersetzt.
+[Dagger](http://www.hashcash.org/papers/dagger.html) beinhaltet die Erzeugung eines [gerichteten azyklischen Graphen](https://en.wikipedia.org/wiki/Directed_acyclic_graph), dessen zufällige Ausschnitte zusammengehasht werden. Der Grundgedanke beruht darauf, dass jede Nonce nur einen kleinen Abschnitt eines großen Gesamt-Datenbaums benötigt. Den Unterbaum für jede Nonce neu zu berechnen, würde Mining unmöglich machen – weshalb der Baum gespeichert werden muss –, doch für die Verifizierung einer einzigen Nonce ist dieser Vorgang in Ordnung. Dagger wurde als Alternative zu bestehenden Algorithmen wie Scrypt entwickelt, die speicherhart, aber schwer zu verifizieren sind, wenn ihre Speicherhärte auf tatsächlich sichere Ebenen ansteigt. Dagger hatte jedoch Schwachstellen durch Hardwarebeschleunigung in Shared-Memory-Umgebungen und wurde daher durch andere Methoden in der Forschung ersetzt.
-[Hashimoto](http://diyhpl.us/%7Ebryan/papers2/bitcoin/meh/hashimoto.pdf) ist ein Algorithmus, der durch I/O-Limitierung ASIC-resistent ist (d. h., Speicherzugriffe sind der limitierende Faktor während des Miningprozesses). Die Theorie dahinter besagt, dass RAM leichter verfügbar ist als Rechenleistung; durch milliardenschwere Forschung wurde bereits untersucht, inwieweit sich RAM für verschiedene Nutzungsszenarien optimieren lässt, die häufig annähernd zufällige Zugriffsmuster nutzen (daher „Random Access Memory“). Daraus folgt, dass bestehende RAM-Lösungen wahrscheinlich annähernd optimal für die Bewertung des Algorithmus sind. Hashimoto nutzt die Blockchain als Datenquelle, was sowohl den Punkt (1) als auch (3) weiter oben erfüllt.
+[Hashimoto](http://diyhpl.us/%7Ebryan/papers2/bitcoin/meh/hashimoto.pdf) ist ein Algorithmus, der durch seine I/O-Limitierung ASIC-resistent ist (d. h. Speicherlesevorgänge sind der limitierende Faktor im Mining-Prozess). Die Theorie dahinter besagt, dass RAM leichter verfügbar ist als Rechenleistung; durch milliardenschwere Forschung wurde bereits untersucht, inwieweit sich RAM für verschiedene Nutzungsszenarien optimieren lässt, die häufig annähernd zufällige Zugriffsmuster nutzen (daher „Random Access Memory“). Daraus folgt, dass bestehende RAM-Lösungen wahrscheinlich annähernd optimal für die Bewertung des Algorithmus sind. Hashimoto nutzt die Blockchain als Datenquelle, was sowohl den Punkt (1) als auch (3) weiter oben erfüllt.
-Dagger-Hashimoto verwendete abgeänderte Versionen der Algorithmen von Dagger und Hashimoto. Der Unterschied zwischen Dagger-Hashimoto und Hashimoto besteht darin, dass Dagger-Hashimoto anstatt der Blockchain einen spezifischen Datensatz nutzt, der entsprechend den Blockdaten alle n Blöcke eine Aktualisierung durchführt. Der Datensatz wird durch den Dagger-Algorithmus generiert, was die effiziente Berechnung einer Untergruppe für jede Nonce für den Verifizierungsalgorithmus des Light-Clients ermöglicht. Der Unterschied zwischen Dagger-Hashimoto und Dagger besteht darin, dass – anders als im originalen Dagger – der Datensatz, der für die Anfrage an den Block genutzt wird, semi-permanent ist und nur gelegentlich aktualisiert wird (beispielsweise einmal pro Woche). Das bedeutet, dass der Anteil des Aufwands für die Generierung des Datensatzes annähernd null ist, weshalb Sergio Lerners Argumente in Bezug auf Geschwindigkeitszuwächse durch Shared-Memory vernachlässigbar sind.
+Dagger-Hashimoto verwendete abgeänderte Versionen der Algorithmen von Dagger und Hashimoto. Der Unterschied zwischen Dagger-Hashimoto und Hashimoto besteht darin, dass Dagger-Hashimoto anstatt der Blockchain einen spezifischen Datensatz nutzt, der entsprechend den Blockdaten alle n Blöcke eine Aktualisierung durchführt. Der Datensatz wird durch den Dagger-Algorithmus generiert, was die effiziente Berechnung einer Untergruppe für jede Nonce für den Verifizierungsalgorithmus des Light-Clients ermöglicht. Der Unterschied zwischen Dagger-Hashimoto und Dagger besteht darin, dass, anders als beim ursprünglichen Dagger, der zur Abfrage des Blocks verwendete Datensatz semi-permanent ist und nur in gelegentlichen Abständen (z. B. einmal pro Woche) aktualisiert wird. Das bedeutet, dass der Anteil des Aufwands für die Generierung des Datensatzes annähernd null ist, weshalb Sergio Lerners Argumente in Bezug auf Geschwindigkeitszuwächse durch Shared-Memory vernachlässigbar sind.
-Erfahren Sie mehr über [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto).
+Mehr über [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto).
## Ethash {#ethash}
-Ethash war der Mining-Algorithmus, der tatsächlich auf dem echten Ethereum-Mainnet unter der inzwischen veralteten Proof-of-Work-Architektur verwendet wurde. Ethash war im Grunde ein neuer Name, der einer bestimmten Version von Dagger-Hashimoto gegeben wurde, nachdem der Algorithmus signifikant aktualisiert worden war, aber noch immer die grundlegenden Prinzipien seines Vorgängers befolgte. Das Ethereum-Mainnet hat immer ausschließlich Ethash verwendet – Dagger-Hashimoto war eine Forschungs- und Entwicklungsversion des Mining-Algorithmus, die noch vor dem Mining auf dem Ethereum-Mainnet ersetzt wurde.
+Ethash war der Mining-Algorithmus, der tatsächlich auf dem echten Ethereum-Mainnet unter der inzwischen veralteten Proof-of-Work-Architektur verwendet wurde. Ethash war im Grunde ein neuer Name, der einer bestimmten Version von Dagger-Hashimoto gegeben wurde, nachdem der Algorithmus signifikant aktualisiert worden war, aber noch immer die grundlegenden Prinzipien seines Vorgängers befolgte. Das Ethereum-Mainnet hat ausschließlich Ethash verwendet – Dagger Hashimoto war eine F&E-Version des Mining-Algorithmus, die abgelöst wurde, bevor das Mining im Ethereum-Mainnet startete.
-[Mehr über Ethash](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash).
+Mehr über [Ethash](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash).
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
-_Kennen Sie eine Community Ressource, die Ihnen geholfen hat? Bearbeite diese Seite und füge sie hinzu!_
+_Sie kennen Community-Resourcen die Ihnen geholfen haben? Bearbeiten Sie diese Seite und fügen Sie sie hinzu!_
diff --git a/public/content/translations/de/developers/docs/dapps/index.md b/public/content/translations/de/developers/docs/dapps/index.md
index 934f383496c..90697938693 100644
--- a/public/content/translations/de/developers/docs/dapps/index.md
+++ b/public/content/translations/de/developers/docs/dapps/index.md
@@ -1,27 +1,27 @@
---
-title: Einführung in Dapps
+title: Technische Grundlagen von DApps
description:
lang: de
---
-Eine dezentralisierte Anwendung (dapp) ist eine Anwendung, die auf einem dezentralisierten Netzwerk aufgebaut ist. Dies kombiniert einen [Smart Contract](/developers/docs/smart-contracts/) und eine Frontend-Benutzeroberfläche. Beachte, dass Smart Contracts in Ethereum zugänglich und transparent sind – wie offene APIs –, also kann deine Dapp sogar einen Smart Contract enthalten, den eine andere Person geschrieben hat.
+Eine dezentralisierte Anwendung (Dapp) ist eine Anwendung, die auf einem dezentralen Netzwerk aufbaut und einen [Smart Contract](/developers/docs/smart-contracts/) mit einer Frontend-Benutzeroberfläche kombiniert. Beachte, dass Smart Contracts in Ethereum zugänglich und transparent sind – wie offene APIs –, also kann deine Dapp sogar einen Smart Contract enthalten, den eine andere Person geschrieben hat.
## Voraussetzungen {#prerequisites}
-Bevor du mehr über Dapps lernst, solltest du die [Blockchain-Basics](/developers/docs/intro-to-ethereum/) kennen und dir durchlesen, was das Ethereum-Netzwerk ist und wie es dezentralisiert wird.
+Bevor du mehr über Dapps lernst, solltest du dich mit den [Grundlagen der Blockchain](/developers/docs/intro-to-ethereum/) vertraut machen und mehr über das Ethereum-Netzwerk und seine Dezentralisierung erfahren.
## Definition einer Dapp {#definition-of-a-dapp}
Eine Dapp hat ihren Backend-Code auf einem dezentralisierten Peer-to-Peer-Netzwerk laufen. Vergleiche das mit einer App, bei der der Backend-Code auf dezentralisierten Servern läuft.
-Eine Dapp kann Frontend-Code und eine Benutzeroberfläche in jeder beliebigen Sprache haben (genau wie eine App), die Aufrufe in ihrem Backend tätigen können. Darüber hinaus kann das Frontend auf dezentralisiertem Speicher wie [IPFS](https://ipfs.io/) gehostet werden.
+Eine Dapp kann Frontend-Code und eine Benutzeroberfläche in jeder beliebigen Sprache haben (genau wie eine App), die Aufrufe in ihrem Backend tätigen können. Darüber hinaus kann das Frontend auf dezentralem Speicher wie [IPFS](https://ipfs.io/) gehostet werden.
-- **Dezentralisiert** – Dapps arbeiten auf Ethereum, einer offenen, öffentlichen und dezentralen Plattform, auf der keine Person oder Gruppe die Kontrolle hat.
+- **Dezentralisiert** – Dapps laufen auf Ethereum, einer offenen, öffentlichen, dezentralen Plattform, bei der keine einzelne Person oder Gruppe die Kontrolle hat.
- **Deterministisch** – Dapps führen dieselbe Funktion aus, unabhängig von der Umgebung, in der sie ausgeführt werden.
-- **Turing-Vollständigkeit** – Dapps können jede Aktion ausführen, wenn die erforderlichen Ressourcen vorhanden sind.
-- **Isoliert** – Dapps werden in einer virtuellen Umgebung ausgeführt, die als Ethereum Virtual Machine bekannt ist, so dass ein Fehler im Smart Contract die normale Funktion des Blockchain-Netzwerks nicht beeinträchtigt.
+- **Turing-vollständig** – Dapps können jede Aktion ausführen, sofern die erforderlichen Ressourcen vorhanden sind.
+- **Isoliert** – Dapps werden in einer virtuellen Umgebung namens Ethereum Virtual Machine ausgeführt. Wenn der Smart Contract also einen Fehler aufweist, wird die normale Funktion des Blockchain-Netzwerks dadurch nicht beeinträchtigt.
-### Smart Contracts {#on-smart-contracts}
+### Über Smart Contracts {#on-smart-contracts}
Um Dapps einzuführen, müssen wir auch Smart Contracts vorstellen – das Backend einer Dapp. Einen detaillierten Überblick findest du in unserem Abschnitt über [Smart Contracts](/developers/docs/smart-contracts/).
@@ -29,64 +29,64 @@ Ein Smart Contract ist ein Code, der auf der Ethereum-Blockchain existiert und g
## Vorteile der Dapp-Entwicklung {#benefits-of-dapp-development}
-- **Zero downtime** - Sobald der Smart Contract auf der Blockchain implementiert ist, kann das gesamte Netzwerk jederzeit Kunden bedienen, die mit dem Vertrag interagieren wollen. Böswillige Akteure können daher keine "Denial-of-Service"-Angriffe starten, die auf einzelne Dapps abzielen.
-- **Privatsphäre** – Du musst keine echte Identität zur Verfügung stellen, um eine Dapp bereitzustellen oder mit einer zu interagieren.
-- **Resistenz gegen Zensur** - keine einzige Entität im Netzwerk kann Benutzer daran hindern, Transaktionen zu übertragen, Dapps bereitzustellen oder Daten der Blockchain auszulesen.
-- **Komplette Datenintegrität** – Daten, die auf der Blockchain gespeichert sind, sind unveränderbar und unbestreitbar, dank kryptographischer Primitivität. Böswillige Akteure können keine Transaktionen oder andere Daten, die bereits öffentlich gemacht wurden, fälschen.
-- **Vertrauenslose Berechnung/überprüfbares Verhalten** – Smart Contracts können analysiert werden und garantieren, dass sie auf vorhersehbare Weise ausgeführt werden, ohne dass dafür das Vertrauen in eine zentrale Autorität vorausgesetzt wird. Das ist bei traditionellen Modellen nicht der Fall. Wenn wir zum Beispiel Online-Banking-Systeme nutzen, müssen wir darauf vertrauen, dass die Finanzinstitute unsere Finanzdaten nicht missbrauchen, keine Aufzeichnungen manipulieren und uns nicht hacken.
+- **Keine Ausfallzeiten** – Sobald der Smart Contract in der Blockchain bereitgestellt ist, kann das Netzwerk als Ganzes immer Clients bedienen, die mit dem Vertrag interagieren möchten. Böswillige Akteure können daher keine "Denial-of-Service"-Angriffe starten, die auf einzelne Dapps abzielen.
+- **Datenschutz** – Du musst keine echte Identität angeben, um eine Dapp bereitzustellen oder mit ihr zu interagieren.
+- **Zensurresistenz** – Keine einzelne Entität im Netzwerk kann Nutzer daran hindern, Transaktionen zu übermitteln, Dapps bereitzustellen oder Daten aus der Blockchain zu lesen.
+- **Vollständige Datenintegrität** – Auf der Blockchain gespeicherte Daten sind dank kryptografischer Primitive unveränderlich und unbestreitbar. Böswillige Akteure können keine Transaktionen oder andere Daten, die bereits öffentlich gemacht wurden, fälschen.
+- **Vertrauenslose Berechnung/verifizierbares Verhalten** – Smart Contracts können analysiert werden und werden garantiert auf vorhersehbare Weise ausgeführt, ohne dass man einer zentralen Instanz vertrauen muss. Das ist bei traditionellen Modellen nicht der Fall. Wenn wir zum Beispiel Online-Banking-Systeme nutzen, müssen wir darauf vertrauen, dass die Finanzinstitute unsere Finanzdaten nicht missbrauchen, keine Aufzeichnungen manipulieren und uns nicht hacken.
## Nachteile der Dapp-Entwicklung {#drawbacks-of-dapp-development}
-- **Wartung** – Dapps können schwieriger zu warten sein, weil der Code und die Daten, die auf der Blockchain veröffentlicht werden, schwerer zu ändern sind. Für Entwickler ist es schwierig ihre dApps (oder die zugrunde liegenden Daten, die von einer dApp gespeichert werden) zu aktualisieren, sobald sie bereitgestellt wurden, selbst wenn in einer alten Version Fehler oder Sicherheitsrisiken festgestellt werden.
-- **Performance-Overhead** – Es gibt einen enormen Performance-Overhead und die Skalierung ist sehr schwierig. Um den Grad an Sicherheit, Integrität, Transparenz und Zuverlässigkeit zu erreichen, den Ethereum anstrebt, führt jeder Node jede Transaktion aus und speichert sie. Hinzu kommt, dass der Proof-of-Stake-Konsens ebenfalls Zeit benötigt.
-- **Netzüberlastung** – Wenn eine Dapp zu viele Rechenressourcen verbraucht, gerät das gesamte Netzwerk ins Stocken. Derzeit kann das Netzwerk nur etwa 10 bis 15 Transaktionen pro Sekunde verarbeiten; wenn Transaktionen schneller eingehen, kann der Pool an unbestätigten Transaktionen schnell anschwellen.
-- **Benutzererfahrung** – Es könnte schwieriger sein, eine benutzerfreundliche Erfahrung zu entwickeln, weil es für den durchschnittlichen Endbenutzer zu schwer sein könnte, die notwendigen Tools für eine wirklich sichere Interaktion mit der Blockchain einzurichten.
-- **Zentralisierung** – Benutzer- und entwicklerfreundliche Lösungen, die auf der Basisschicht von Ethereum aufgebaut sind, könnten am Ende ohnehin wie zentralisierte Dienste aussehen. Solche Dienste können zum Beispiel Schlüssel oder andere sensible Informationen serverseitig speichern, ein Frontend über einen zentralen Server bedienen oder wichtige Geschäftslogik auf einem zentralen Server ausführen, bevor sie in die Blockchain geschrieben werden. Durch die Zentralisierung werden viele (wenn nicht alle) Vorteile der Blockchain gegenüber dem traditionellen Modell aufgehoben.
+- **Wartung** – Dapps können schwieriger zu warten sein, da der auf der Blockchain veröffentlichte Code und die Daten schwerer zu ändern sind. Für Entwickler ist es schwierig ihre dApps (oder die zugrunde liegenden Daten, die von einer dApp gespeichert werden) zu aktualisieren, sobald sie bereitgestellt wurden, selbst wenn in einer alten Version Fehler oder Sicherheitsrisiken festgestellt werden.
+- **Leistungs-Overhead** – Es gibt einen enormen Leistungs-Overhead und die Skalierung ist sehr schwierig. Um den Grad an Sicherheit, Integrität, Transparenz und Zuverlässigkeit zu erreichen, den Ethereum anstrebt, führt jeder Node jede Transaktion aus und speichert sie. Hinzu kommt, dass der Proof-of-Stake-Konsens ebenfalls Zeit benötigt.
+- **Netzwerküberlastung** – Wenn eine Dapp zu viele Rechenressourcen verbraucht, wird das gesamte Netzwerk überlastet. Derzeit kann das Netzwerk nur etwa 10 bis 15 Transaktionen pro Sekunde verarbeiten; wenn Transaktionen schneller eingehen, kann der Pool an unbestätigten Transaktionen schnell anschwellen.
+- **Benutzererlebnis** – Es kann schwieriger sein, benutzerfreundliche Erlebnisse zu schaffen, da der durchschnittliche Endbenutzer es möglicherweise als zu schwierig empfindet, den für eine wirklich sichere Interaktion mit der Blockchain erforderlichen Tool-Stack einzurichten.
+- **Zentralisierung** – Benutzer- und entwicklerfreundliche Lösungen, die auf der Basisschicht von Ethereum aufbauen, sehen am Ende möglicherweise trotzdem wie zentralisierte Dienste aus. Solche Dienste können zum Beispiel Schlüssel oder andere sensible Informationen serverseitig speichern, ein Frontend über einen zentralen Server bedienen oder wichtige Geschäftslogik auf einem zentralen Server ausführen, bevor sie in die Blockchain geschrieben werden. Durch die Zentralisierung werden viele (wenn nicht alle) Vorteile der Blockchain gegenüber dem traditionellen Modell aufgehoben.
-## Eher ein visueller Lerner? {#visual-learner}
+## Eher der visuelle Lernende? {#visual-learner}
> zu schützen. In ähnlicher Weise wäre bei der [Trennung von Blockvorschlagendem und -ersteller (PBS)](/roadmap/pbs) nur der Blockersteller verpflichtet, einen ganzen Block zu verarbeiten – andere Validatoren würden die Verifizierung mittels Datenverfügbarkeits-Sampling durchführen.
+
+### Datenverfügbarkeitskomitees {#data-availability-committees}
+
+Datenschutzausschüsse (DACs), sind Ausschüsse, die sich aus Interessengruppen zusammensetzen, sie betonen die Notwendigkeit, Informationen über die Verfügbarkeit von Daten bereitzustellen und zu gewährleisten. DACs können anstelle von [oder in Kombination mit](https://hackmd.io/@vbuterin/sharding_proposal#Why-not-use-just-committees-and-not-DAS) DAS verwendet werden. Die von den Ausschüssen gebotenen Sicherheitsgarantien hängen von ihrer Umsetzung ab. Ethereum verwendet zufällig ausgewählte Stichproben von Unterklassen von Prüfern, die die Verfügbarkeit von zum Beispiel <> zusichern.
+
+DACs werden auch von einigen Validiums eingesetzt. Der DAC ist ein vertrauenswürdiger Satz von Knoten, der Datenkopien offline speichert. Die Umsetzung der DAC-Richtlinie wird für die Bereitstellung von Daten im Streitfall verlangt. Mitglieder des DAC veröffentlichen außerdem Offchain Bescheinigungen, um zu beweisen, dass die besagten Daten tatsächlich verfügbar sind. Einige Validiums ersetzen die DACs durch ein Proof-of-Stake (PoS)-Validierungssystem. Hier kann jeder zum Validator werden und Daten außerhalb der Kette speichern. Dennoch basieren die Anforderungen an die Datenübertragung auf einer "Vereinbarung", die in einem digitalen Protokoll hinterlegt ist. Im Falle einer böswilligen Absicht, wie zum Beispiel im Falle eines Datenlecks des Validators, könnte diese Vereinbarung gekündigt werden. Aufgrund ihrer Rolle, die ehrliches Verhalten fördert, verfügen Datenschutzausschüsse, die auf der Proof-of-Stake Methode basieren, über einen erheblich sichereren Speicherplatz als DACs.
+
+## Datenverfügbarkeit und Light Nodes {#data-availability-and-light-nodes}
+
+[Light Nodes](/developers/docs/nodes-and-clients/light-clients) müssen die Korrektheit der Block-Header, die sie empfangen, validieren, ohne die Blockdaten herunterzuladen. Diese Leichtigkeit hat ihren Preis: die Unfähigkeit, die Köpfe des Blocks (block headers) unabhängig zu überprüfen, indem neue Transaktionen lokal durchgeführt werden, wie es die Vollknoten derzeit tun.
+
+Ethereum Light Nodes vertrauen auf zufällige Sätze von 512 Validatoren, die einem _Synchronisierungskomitee_ zugewiesen wurden. Das Sync-Komitee, das als programmierte Investition (DCA) fungiert, weist die <> darauf hin, dass sie durch die Verwendung eines kryptografischen Algorithmus die im Header enthaltenen Daten validieren können. Der Beratungsausschuss führt tägliche Auffrischungen durch. Jeder Block-Header informiert Light Nodes darüber, von welchen Validatoren die Unterzeichnung des _nächsten_ Blocks zu erwarten ist, sodass sie nicht dazu verleitet werden können, einer bösartigen Gruppe zu vertrauen, die vorgibt, das echte Synchronisierungskomitee zu sein.
+
+Was passiert jedoch, wenn es einem Angreifer irgendwie _doch_ gelingt, einen bösartigen Block-Header an Light Clients weiterzugeben und sie davon zu überzeugen, dass er von einem ehrlichen Synchronisierungskomitee unterzeichnet wurde? In diesem Fall könnte der Angreifer Transaktionen hinzufügen, die nicht gültig gemacht wurden, was den <> dazu veranlassen würde, ihnen blind zu vertrauen und sie zu validieren, da sie nicht in der Lage sind, die im Block Header aufgezeichneten Statusänderungen unabhängig zu überprüfen. Der <> kann Beweismittel anlegen, um sich vor Betrug zu schützen.
+
+Wie werden diese Anfragen zur automatischen Reproduktion der Transaktion in der Praxis weitergegeben? Ein vollständiger Knoten stellt fest, dass im Netzwerk über einen ungültigen Zustandsübergang getratscht wird, und beschließt daher, sofort kleine Datendateien zu generieren, in denen der Beweis enthalten ist, dass der fragliche Zustandsübergang nicht Teil einer Reihe von eingereichten Transaktionen sein kann, und diese Daten an seine Peers weiterzuleiten. Die <> können hingehen und die Ergebnisse der letzten Anfrage zur automatischen Reproduktion der Transaktion (fraud proofs) abrufen, um bösartige Header zu erkennen. Dadurch wird sichergestellt, dass es sich bei den Akteuren, die an der Wartung der Kette beteiligt sind, um ehrliche Akteure handelt, wie es bei vollständigen Knoten der Fall ist.
+
+Diese basieren auf vollständigen Knoten, die Zugriff auf die vollständigen Daten der Blöcke haben. Ein Angreifer, der einen bösartigen Block-Header übermittelt und es nicht schafft, die Transaktionsdaten verfügbar zu machen, wäre dann in der Lage, die Erstellung einer Anfrage zur automatischen Reproduktion der Transaktion durch die vollständigen Knoten zu verhindern. Die vollständigen Knoten könnten zwar eine Warnung vor einem fehlerhaften Block signalisieren, sie könnten ihre Warnung jedoch nicht mit Beweisen untermauern, da die Daten zur Generierung des Beweises nicht zur Verfügung gestellt wurden!
+
+DAS: Die Lösung für das Problem der Datenverfügbarkeit. Die <> greifen auf vollständige Daten zurück, die aktualisiert wurden, um sehr kleine Blobs mit zufälligen Daten herunterladen zu können, die als Muster verwendet werden, um die Verfügbarkeit aller vollständigen Daten zu gewährleisten. Die tatsächliche Wahrscheinlichkeit, nach dem Herunterladen von N zufälligen Chunks fälschlicherweise von einer vollständigen Datenverfügbarkeit auszugehen, kann berechnet werden ([bei 100 Chunks liegt die Wahrscheinlichkeit bei 10^-30](https://dankradfeist.de/ethereum/2019/12/20/data-availability-checks.html), d. h. sie ist unglaublich gering).
+
+Doch selbst unter diesem Szenario könnten Angriffe, die nur wenige Bytes zurückhalten, durchaus von den Kunden unbemerkt bleiben, die ihrerseits Abfragen mit zufälligen Daten stellen könnten. Löschen Coding behebt dieses Problem, indem es kleine fehlende Datenteile rekonstruiert, die zur Überprüfung vorgeschlagener Statusänderungen verwendet werden können. Mithilfe der rekonstruierten Daten könnte dann ein Betrugsnachweis erstellt werden, der verhindert, dass Light Nodes fehlerhafte Header akzeptieren.
+
+**Hinweis:** DAS und Betrugsbeweise wurden für Proof-of-Stake-Ethereum-Light-Clients noch nicht implementiert, stehen aber auf der Roadmap und werden höchstwahrscheinlich die Form von ZK-SNARK-basierten Beweisen annehmen. Die heutigen Light-Clients verlassen sich auf eine Form von DAC: Sie überprüfen die Identitäten des Synchronisierungskomitees und vertrauen dann den signierten Blockheadern, die sie erhalten.
+
+## Datenverfügbarkeit und Layer-2-Rollups {#data-availability-and-layer-2-rollups}
+
+[Layer-2-Skalierungslösungen](/layer-2/) wie [Rollups](/glossary/#rollups) reduzieren die Transaktionskosten und erhöhen den Durchsatz von Ethereum durch die Verarbeitung von Transaktionen außerhalb der Chain. Rollup Transaktionen werden komprimiert und stapelweise auf Ethereum gepostet. Batches stellen Tausende einzelner Offchain Transaktionen in einer einzigen Transaktion auf Ethereum dar. Dies reduziert die Überlastung der Basisschicht und senkt die Gebühren für die Benutzer.
+
+Nur wenn eine vorgeschlagene Zustandsänderung unabhängig verifiziert und als korrektes Ergebnis aller einzelnen Off-Chain-Transaktionen bestätigt werden kann, kann man den auf Ethereum geposteten „Sammeltransaktionen“ vertrauen. Falls die Rollup-Betreiber die Transaktionsdaten für diese Überprüfung nicht bereitstellen, besteht das Risiko, dass sie fehlerhafte Daten an Ethereum senden.
+
+[Optimistic Rollups](/developers/docs/scaling/optimistic-rollups/) veröffentlichen komprimierte Transaktionsdaten auf Ethereum und warten eine gewisse Zeit (in der Regel 7 Tage), damit unabhängige Prüfer die Daten kontrollieren können. Sollte jemand ein Problem identifizieren, kann ein Betrugsnachweis (Fraud Proof) erstellt werden, um den Rollup anzufechten. Dies würde dazu führen, dass die Kette zurückgesetzt wird und der ungültige Block ausgelassen wird. Dies ist nur möglich, wenn Daten verfügbar sind. Derzeit gibt es zwei Möglichkeiten, wie optimistische Rollups Transaktionsdaten an L1 senden. Einige Rollups stellen Daten dauerhaft als `CALLDATA` zur Verfügung, die permanent auf der Chain gespeichert sind. Mit der Implementierung von EIP-4844 veröffentlichen einige Rollups ihre Transaktionsdaten stattdessen im günstigeren Klecks Speicher. Dies ist keine dauerhafte Speicherung. Bevor die Daten vom Ethereum-Layer-1 gelöscht werden, müssen unabhängige Verifizierer innerhalb von etwa 18 Tagen die Blobs prüfen und ihre Anfechtungen vorbringen. Die vom Ethereum-Protokoll garantierte Datenverfügbarkeit ist auf dieses kurze, feste Zeitfenster beschränkt. Anschließend sind andere Akteure im Ethereum-Ökosystem dafür verantwortlich. Jeder Node kann die Datenverfügbarkeit mithilfe von DAS überprüfen, d. h. durch Herunterladen kleiner, zufälliger Stichproben der Blob-Daten.
+
+[Zero-Knowledge (ZK)-Rollups](/developers/docs/scaling/zk-rollups) müssen keine Transaktionsdaten veröffentlichen, da [Zero-Knowledge-Gültigkeitsnachweise](/glossary/#zk-proof) die Korrektheit von Zustandsübergängen garantieren. Die Datenverfügbarkeit bleibt jedoch weiterhin ein Problem, denn ohne Zugriff auf die State-Daten eines ZK-Rollups kann man dessen Funktionalität nicht gewährleisten oder damit interagieren. Hält ein Betreiber Details über den State des Rollups zurück, können Nutzer beispielsweise ihre Guthaben nicht einsehen. Zudem können sie keine State-Updates mithilfe von Informationen aus einem neu hinzugefügten Block durchführen.
+
+## Datenverfügbarkeit vs. Datenabrufbarkeit {#data-availability-vs-data-retrievability}
+
+Datenverfügbarkeit ist nicht dasselbe wie Datenabrufbarkeit. Datenverfügbarkeit bedeutet, dass Full Nodes in der Lage waren, auf alle Transaktionen eines bestimmten Blocks zuzugreifen und diese zu überprüfen. Dies ist jedoch nicht mit einer ewigen Verfügbarkeit der Daten gleichzusetzen.
+
+Datenabrufbarkeit ist die Fähigkeit von Nodes, _historische Informationen_ von der Blockchain abzurufen. Für die Verifizierung neuer Blöcke werden diese historischen Daten nicht benötigt. Sie sind jedoch erforderlich, um Full Nodes ab dem Genesis-Block zu synchronisieren oder um spezifische historische Anfragen zu bedienen.
+
+Für das Ethereum-Kernprotokoll steht nicht die Datenabrufbarkeit im Vordergrund, sondern primär die Datenverfügbarkeit. Die Datenabrufbarkeit kann von einer kleinen Population von Archiv-Nodes, die von Dritten betrieben werden, bereitgestellt oder über das Netzwerk mithilfe dezentraler Dateispeicher wie dem [Portal Network](https://www.ethportal.net/) verteilt werden.
+
+## Weiterführende Lektüre {#further-reading}
+
+- [WTF is Data Availability?](https://medium.com/blockchain-capital-blog/wtf-is-data-availability-80c2c95ded0f)
+- [What Is Data Availability?](https://coinmarketcap.com/academy/article/what-is-data-availability)
+- [A primer on data availability checks](https://dankradfeist.de/ethereum/2019/12/20/data-availability-checks.html)
+- [An explanation of the sharding + DAS proposal](https://hackmd.io/@vbuterin/sharding_proposal#ELI5-data-availability-sampling)
+- [A note on data availability and erasure coding](https://github.com/ethereum/research/wiki/A-note-on-data-availability-and-erasure-coding#can-an-attacker-not-circumvent-this-scheme-by-releasing-a-full-unavailable-block-but-then-only-releasing-individual-bits-of-data-as-clients-query-for-them)
+- [Data availability committees.](https://medium.com/starkware/data-availability-e5564c416424)
+- [Proof-of-stake data availability committees.](https://blog.matter-labs.io/zkporter-a-breakthrough-in-l2-scaling-ed5e48842fbf)
+- [Solutions to the data retrievability problem](https://notes.ethereum.org/@vbuterin/data_sharding_roadmap#Who-would-store-historical-data-under-sharding)
+- [Data Availability Or: How Rollups Learned To Stop Worrying And Love Ethereum](https://web.archive.org/web/20250515194659/https://web.archive.org/web/20241108192208/https://research.2077.xyz/data-availability-or-how-rollups-learned-to-stop-worrying-and-love-ethereum)
+- [EIP-7623: Increasing Calldata Cost](https://web.archive.org/web/20250515194659/https://research.2077.xyz/eip-7623-increase-calldata-cost)
diff --git a/public/content/translations/de/developers/docs/data-structures-and-encoding/index.md b/public/content/translations/de/developers/docs/data-structures-and-encoding/index.md
new file mode 100644
index 00000000000..bec0f01ae3f
--- /dev/null
+++ b/public/content/translations/de/developers/docs/data-structures-and-encoding/index.md
@@ -0,0 +1,32 @@
+---
+title: Datenstrukturen und Kodierung
+description: Eine Übersicht über die grundlegenden Ethereum-Datenstrukturen.
+lang: de
+sidebarDepth: 2
+---
+
+Ethereum erstellt, speichert und überträgt große Datenmengen. Diese Daten müssen auf standardisierte und speichereffiziente Weise formatiert werden, damit jeder auf relativ bescheidener handelsüblicher Hardware [einen Node ausführen](/run-a-node/) kann. Um dies zu erreichen, werden auf dem Ethereum Stack mehrere spezifische Datenstrukturen verwendet.
+
+## Voraussetzungen {#prerequisites}
+
+Sie sollten die Grundlagen von Ethereum und [Client-Software](/developers/docs/nodes-and-clients/) verstehen. Es wird empfohlen, mit der Netzwerkschicht und [dem Ethereum-Whitepaper](/whitepaper/) vertraut zu sein.
+
+## Datenstrukturen {#data-structures}
+
+### Patricia Merkle Tries {#patricia-merkle-tries}
+
+Patricia Merkle Versucht sind Strukturen, die Schlüssel-Wert-Paare in einen deterministischen und kryptografisch authentifizierten Trie kodieren. Diese werden in der gesamten Ausführungsschicht von Ethereum umfassend verwendet.
+
+[Mehr über Patricia Merkle Tries](/developers/docs/data-structures-and-encoding/patricia-merkle-trie)
+
+### Recursive Length Prefix {#recursive-length-prefix}
+
+Recursive Length Prefix (RLP) ist eine Serialisierungs methode, die in der gesamten Ausführungsschicht von Ethereum häufig verwendet wird.
+
+[Mehr über RLP](/developers/docs/data-structures-and-encoding/rlp)
+
+### Simple Serialize {#simple-serialize}
+
+Simple Serialise (SSZ) ist aufgrund seiner Kompatibilität mit der Merklelizierung das dominierende Serialisierungsformat auf der Konsensebene von Ethereum.
+
+[Mehr über SSZ](/developers/docs/data-structures-and-encoding/ssz)
diff --git a/public/content/translations/de/developers/docs/data-structures-and-encoding/patricia-merkle-trie/index.md b/public/content/translations/de/developers/docs/data-structures-and-encoding/patricia-merkle-trie/index.md
new file mode 100644
index 00000000000..1525651bd56
--- /dev/null
+++ b/public/content/translations/de/developers/docs/data-structures-and-encoding/patricia-merkle-trie/index.md
@@ -0,0 +1,266 @@
+---
+title: Merkle Patricia Trie
+description: Einführung in Merkle Patricia Trie.
+lang: de
+sidebarDepth: 2
+---
+
+Der Zustand von Ethereum (die Gesamtheit aller Konten, Guthaben und Smart Contracts) wird in eine spezielle Version der Datenstruktur kodiert, die in der Informatik allgemein als Hash-Baum bekannt ist. Diese Datenstruktur ist für viele Anwendungen in der Kryptografie nützlich, da sie eine überprüfbare Beziehung zwischen allen einzelnen Daten im Baum herstellt, was zu einem einzigen **Wurzel**-Wert führt, der verwendet werden kann, um Aussagen über die Daten zu beweisen.
+
+Die Datenstruktur von Ethereum ist ein „modifizierter Merkle-Patricia-Trie“. Der Name rührt daher, dass sie einige Merkmale von PATRICIA (Practical Algorithm To Retrieve Information Coded in Alphanumeric) übernimmt und für einen effizienten Datenabruf (re**trie**val) von Elementen konzipiert ist, die den Ethereum-Zustand ausmachen.
+
+Ein Merkle-Patricia-Trie ist deterministisch und kryptografisch verifizierbar: Die einzige Möglichkeit, eine Zustandswurzel zu erzeugen, besteht darin, sie aus jedem einzelnen Teil des Zustands zu berechnen. Zwei identische Zustände lassen sich leicht nachweisen, indem man den Root-Hash und die Hashes, die zu ihm geführt haben, vergleicht (_ein Merkle-Beweis_). Umgekehrt gibt es keine Möglichkeit, zwei verschiedene Zustände mit demselben Root-Hash zu erstellen, jeder Versuch, einen Zustand mit anderen Werten zu ändern, führt zu einem anderen Stamm-Hash. Theoretisch bietet diese Struktur den „heiligen Gral“ der `O(log(n))`-Effizienz für Einfügungen, Suchvorgänge und Löschungen.
+
+In naher Zukunft plant Ethereum die Migration zu einer [Verkle-Tree](/roadmap/verkle-trees)-Struktur, die viele neue Möglichkeiten für zukünftige Protokollverbesserungen eröffnen wird.
+
+## Voraussetzungen {#prerequisites}
+
+Um diese Seite besser zu verstehen, sind Grundkenntnisse über [Hashes](https://en.wikipedia.org/wiki/Hash_function), [Merkle-Bäume](https://en.wikipedia.org/wiki/Merkle_tree), [Tries](https://en.wikipedia.org/wiki/Trie) und [Serialisierung](https://en.wikipedia.org/wiki/Serialization) hilfreich. Dieser Artikel beginnt mit einer Beschreibung eines einfachen [Radix-Baums](https://en.wikipedia.org/wiki/Radix_tree) und führt dann schrittweise die für die optimierte Datenstruktur von Ethereum notwendigen Änderungen ein.
+
+## Einfache Radix-Tries {#basic-radix-tries}
+
+Bei einem Basic Radix Trie sieht jede Node wie folgt aus:
+
+```
+ [i_0, i_1 ... i_n, value]
+```
+
+Wobei `i_0 ...` i_n`die Symbole des Alphabets (oft binär oder hexadezimal) darstellen,`value`der Endwert am Knoten ist und die Werte in den`i_0, i_1 ...` i_n`-Slots entweder `NULL` oder Zeiger auf (in unserem Fall, Hashes von) andere Knoten sind. Dies bildet einen einfachen `(Key, Value)`-Speicher.
+
+Stell dir vor, du möchtest eine Radix-Trie-Datenstruktur nutzen, um die Reihenfolge eines Sets von Key-Value-Paarten dauerhaft zu speichern. Um den Wert zu finden, der dem Key `dog` im Trie zugeordnet ist, wandeln Sie zuerst `dog` in Buchstaben des Alphabets um (was `64 6f 67` ergibt) und steigen dann diesem Pfad folgend den Trie hinab, bis Sie den Wert finden. Das heißt, Sie beginnen mit der Suche nach dem Stamm-Hash in einer flachen Schlüssel-/Wert-Datenbank, um den Stammknoten des trie zu finden. Es wird als Array von Schlüsseln dargestellt, die auf andere Knoten verweisen. Sie würden den Wert am Index `6` als Key verwenden und ihn in der flachen Key/Value-DB nachschlagen, um den Knoten eine Ebene tiefer zu erhalten. Dann wählen Sie Index `4`, um den nächsten Wert nachzuschlagen, dann Index `6` und so weiter, bis Sie, nachdem Sie dem Pfad gefolgt sind: `root -> 6 -> 4 -> 6 -> 15 -> 6 -> 7`, den Wert des Knotens nachschlagen und das Ergebnis zurückgeben.
+
+Es besteht ein Unterschied zwischen der Suche im „Trie“ und der zugrunde liegenden flachen Schlüssel /Wert-„DB“. Beide definieren Schlüssel /Wertanordnungen, aber die zugrunde liegende Datenbank kann eine herkömmliche einstufige Suche nach einem Schlüssel durchführen. Das Nachschlagen eines Schlüssels im Trie erfordert mehrere zugrunde liegende DB Suchvorgänge, um zum oben beschriebenen Endwert zu gelangen. Bezeichnen wir Letzteres als `path`, um Mehrdeutigkeiten zu vermeiden.
+
+Die Aktualisierungs- und Löschvorgänge für radix tries können wie folgt definiert werden:
+
+```python
+ def update(node_hash, path, value):
+ curnode = db.get(node_hash) if node_hash else [NULL] * 17
+ newnode = curnode.copy()
+ if path == "":
+ newnode[-1] = value
+ else:
+ newindex = update(curnode[path[0]], path[1:], value)
+ newnode[path[0]] = newindex
+ db.put(hash(newnode), newnode)
+ return hash(newnode)
+
+ def delete(node_hash, path):
+ if node_hash is NULL:
+ return NULL
+ else:
+ curnode = db.get(node_hash)
+ newnode = curnode.copy()
+ if path == "":
+ newnode[-1] = NULL
+ else:
+ newindex = delete(curnode[path[0]], path[1:])
+ newnode[path[0]] = newindex
+
+ if all(x is NULL for x in newnode):
+ return NULL
+ else:
+ db.put(hash(newnode), newnode)
+ return hash(newnode)
+```
+
+Ein "Merkle" Radix taum wird durch die Verknüpfung von Knoten mithilfe deterministisch generierter kryptografischer Hash Verdaut erstellt. Diese Inhaltsadressierung (in der Key/Value-DB `key == keccak256(rlp(value))`) bietet eine kryptografische Integritätsgarantie der gespeicherten Daten. Wenn der Stamm Hash eines bestimmten Tries öffentlich bekannt ist, kann jeder mit Zugriff auf die zugrunde liegenden Blattdaten einen Beweis dafür erstellen, dass der Trie einen bestimmten Wert an einem bestimmten Pfad enthält, indem er die Hashes jedes Knotens bereitstellt, der einen bestimmten Wert mit der Baumwurzel verbindet.
+
+Es ist für einen Angreifer unmöglich, einen Beweis für ein `(path, value)`-Paar zu erbringen, das nicht existiert, da der Root-Hash letztendlich auf allen darunter liegenden Hashes basiert. Jede zugrunde liegende Änderung würde den Root Hash ändern. Sie können sich den Hash als komprimierte Darstellung struktureller Informationen über die Daten vorstellen, die durch den pre-Image Schutz der Hashing Funktion gesichert sind.
+
+Wir bezeichnen eine atomare Einheit eines Radix-Baums (z. B. ein einzelnes Hex-Zeichen oder eine 4-Bit-Binärzahl) als "Nibble". Beim Durchlaufen eines Pfads, jeweils ein Nibble nach dem anderen, wie oben beschrieben, können Knoten auf maximal 16 untergeordnete Elemente verweisen, aber ein `value`-Element enthalten. Wir stellen sie daher als Array der Länge 17 dar. Wir nennen diese 17-element Arrays "Zweig Knoten“.
+
+## Merkle-Patricia-Trie {#merkle-patricia-trees}
+
+Radix tries haben eine große Einschränkung: Sie sind ineffizient. Wenn Sie eine `(path, value)`-Bindung speichern möchten, bei der der Pfad wie in Ethereum 64 Zeichen lang ist (die Anzahl der Nibbles in `bytes32`), benötigen wir über ein Kilobyte zusätzlichen Speicherplatz, um eine Ebene pro Zeichen zu speichern, und jede Suche oder Löschung wird die vollen 64 Schritte benötigen. Der im Folgenden vorgestellte Patricia Trie löst dieses Problem.
+
+### Optimierung {#optimization}
+
+Ein Knoten in einem Merkle Patricia Trie ist einer der folgenden:
+
+1. `NULL` (dargestellt als leere Zeichenfolge)
+2. `branch` Ein 17-elementiger Knoten `[ v0 ...` v15, vt ]\`
+3. `leaf` Ein 2-elementiger Knoten `[ encodedPath, value ]`
+4. `extension` Ein 2-elementiger Knoten `[ encodedPath, key ]`
+
+Bei 64 Zeichenpfaden ist es unvermeidlich, dass Sie nach dem Durchlaufen der ersten paar Schichten des trie einen Knoten erreichen, an dem zumindest für einen Teil des Weges kein abweichender Pfad vorhanden ist. Um die Erstellung von bis zu 15 dünn besetzten `NULL`-Knoten entlang des Pfads zu vermeiden, kürzen wir den Abstieg ab, indem wir einen `extension`-Knoten der Form `[ encodedPath, key ]` einrichten, wobei `encodedPath` den "Teilpfad" zum Überspringen enthält (unter Verwendung einer unten beschriebenen kompakten Kodierung) und der `key` für die nächste DB-Suche dient.
+
+Bei einem `leaf`-Knoten, der durch ein Flag im ersten Nibble des `encodedPath` markiert werden kann, kodiert der Pfad alle Pfadfragmente des vorherigen Knotens, und wir können den `value` direkt nachschlagen.
+
+Die obige Optimierung führt jedoch zu Mehrdeutigkeiten.
+
+Wenn Pfade in Nibbles durchlaufen werden, kann es sein, dass eine ungerade Anzahl von Nibbles zu durchlaufen ist, aber da alle Daten im `bytes`-Format gespeichert sind. Es ist nicht möglich, beispielsweise zwischen dem Nibble `1` und den Nibbles `01` zu unterscheiden (beide müssen als `<01>` gespeichert werden). Um eine ungerade Länge anzugeben, wird dem Teilpfad ein Flagge vorangestellt.
+
+### Spezifikation: Kompakte Kodierung einer Hex-Sequenz mit optionalem Terminator {#specification}
+
+Die Kennzeichnung von sowohl _ungerader vs. gerader verbleibender Teilpfadlänge_ als auch _leaf- vs. extension-Knoten_ befindet sich, wie oben beschrieben, im ersten Nibble des Teilpfads eines jeden 2-elementigen Knotens. Sie führen zu Folgendem:
+
+| Hex Zeichen | Bits | Knotentyp teilweise | Pfadlänge |
+| ----------- | ---- | ----------------------------------- | --------- |
+| 0 | 0000 | Verlängerung | sogar |
+| 1 | 0001 | Verlängerung | seltsam |
+| 2 | 0010 | beendend (Blatt) | sogar |
+| 3 | 0011 | beendend (Blatt) | seltsam |
+
+Bei einer geraden verbleibenden Pfadlänge (`0` oder `2`) folgt immer ein weiteres `0`-"Padding"-Nibble.
+
+```python
+ def compact_encode(hexarray):
+ term = 1 if hexarray[-1] == 16 else 0
+ if term:
+ hexarray = hexarray[:-1]
+ oddlen = len(hexarray) % 2
+ flags = 2 * term + oddlen
+ if oddlen:
+ hexarray = [flags] + hexarray
+ else:
+ hexarray = [flags] + [0] + hexarray
+ # hexarray hat jetzt eine gerade Länge, dessen erstes Nibble die Flags sind.
+ o = ""
+ for i in range(0, len(hexarray), 2):
+ o += chr(16 * hexarray[i] + hexarray[i + 1])
+ return o
+```
+
+Beispiele:
+
+```python
+ > [1, 2, 3, 4, 5, ...]
+ '11 23 45'
+ > [0, 1, 2, 3, 4, 5, ...]
+ '00 01 23 45'
+ > [0, f, 1, c, b, 8, 10]
+ '20 0f 1c b8'
+ > [f, 1, c, b, 8, 10]
+ '3f 1c b8'
+```
+
+Hier ist der erweiterte Code zum Abrufen eines Knotens im Merkle Patricia Trie:
+
+```python
+ def get_helper(node_hash, path):
+ if path == []:
+ return node_hash
+ if node_hash == "":
+ return ""
+ curnode = rlp.decode(node_hash if len(node_hash) < 32 else db.get(node_hash))
+ if len(curnode) == 2:
+ (k2, v2) = curnode
+ k2 = compact_decode(k2)
+ if k2 == path[: len(k2)]:
+ return get(v2, path[len(k2) :])
+ else:
+ return ""
+ elif len(curnode) == 17:
+ return get_helper(curnode[path[0]], path[1:])
+
+ def get(node_hash, path):
+ path2 = []
+ for i in range(len(path)):
+ path2.push(int(ord(path[i]) / 16))
+ path2.push(ord(path[i]) % 16)
+ path2.push(16)
+ return get_helper(node_hash, path2)
+```
+
+### Beispiel-Trie {#example-trie}
+
+Nehmen wir an, wir wollen einen Trie, der vier Pfad/Wert-Paare enthält: `('do', 'verb')`, `('dog', 'puppy')`, `('doge', 'coins')`, `('horse', 'stallion')`.
+
+Zuerst konvertieren wir sowohl Pfade als auch Werte in `bytes`. Unten werden die tatsächlichen Byte-Darstellungen für _Pfade_ mit `<>` gekennzeichnet, obwohl die _Werte_ zum leichteren Verständnis immer noch als Strings, gekennzeichnet durch `''`, dargestellt werden (auch sie wären eigentlich `bytes`):
+
+```
+ <64 6f> : 'verb'
+ <64 6f 67> : 'puppy'
+ <64 6f 67 65> : 'coins'
+ <68 6f 72 73 65> : 'stallion'
+```
+
+Nun bauen wir einen solchen Trie mit den folgenden Key-Value-Paaren in der zugrundeliegenden Datenbank auf:
+
+```
+ rootHash: [ <16>, hashA ]
+ hashA: [ <>, <>, <>, <>, hashB, <>, <>, <>, [ <20 6f 72 73 65>, 'stallion' ], <>, <>, <>, <>, <>, <>, <>, <> ]
+ hashB: [ <00 6f>, hashC ]
+ hashC: [ <>, <>, <>, <>, <>, <>, hashD, <>, <>, <>, <>, <>, <>, <>, <>, <>, 'verb' ]
+ hashD: [ <17>, [ <>, <>, <>, <>, <>, <>, [ <35>, 'coins' ], <>, <>, <>, <>, <>, <>, <>, <>, <>, 'puppy' ] ]
+```
+
+Wenn ein Knoten innerhalb eines anderen Knotens referenziert wird, wird `keccak256(rlp.encode(node))` eingefügt, falls `len(rlp.encode(node)) >= 32`, ansonsten `node`, wobei `rlp.encode` die [RLP](/developers/docs/data-structures-and-encoding/rlp)-Kodierungsfunktion ist.
+
+Beachten Sie, dass beim Aktualisieren eines Tries das Key/Value-Paar `(keccak256(x), x)` in einer persistenten Lookup-Tabelle gespeichert werden muss, _wenn_ der neu erstellte Knoten eine Länge >= 32 hat. Allerdings entfällt die Speicherpflicht, falls der Node kürzer ist. Der Grund dafür ist, dass die Funktion f(x) = x umkehrbar ist.
+
+## Tries in Ethereum {#tries-in-ethereum}
+
+Sämtliche Merkle-Tries im Execution Layer von Ethereum sind als Merkle-Patricia-Trie implementiert.
+
+Der Block Header beinhaltet 3 Roots, von denen jede aus einem dieser 3 Tries stammt.
+
+1. State-Root
+2. Transactions-Root
+3. Receipts-Root
+
+### Zustands-Trie {#state-trie}
+
+Es existiert nur ein globaler State-Trie, dessen Aktualisierung jedes Mal erfolgt, wenn ein Client einen Block verarbeitet. Darin ist ein `path` immer: `keccak256(ethereumAddress)` und ein `value` immer: `rlp(ethereumAccount)`. Genauer gesagt ist ein Ethereum-`account` ein 4-elementiges Array: `[nonce,balance,storageRoot,codeHash]`. An dieser Stelle ist es erwähnenswert, dass dieser `storageRoot` die Wurzel eines weiteren Patricia-Tries ist:
+
+### Speicher-Trie {#storage-trie}
+
+Im Speicher-Trie befinden sich _alle_ Vertragsdaten. Für jedes Konto gibt es einen separaten Speicherbereich. Um Werte an bestimmten Speicherpositionen an einer bestimmten Adresse abzurufen, werden die Speicheradresse, die ganzzahlige Position der gespeicherten Daten im Speicher und die Block-ID benötigt. Diese können dann als Argumente an die in der JSON-RPC-API definierte Funktion `eth_getStorageAt` übergeben werden, z. B. um die Daten im Speicherslot 0 für die Adresse `0x295a70b2de5e3953354a6a8344e616ed314d7251` abzurufen:
+
+```bash
+curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": ["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x0", "latest"], "id": 1}' localhost:8545
+
+{"jsonrpc":"2.0","id":1,"result":"0x00000000000000000000000000000000000000000000000000000000000004d2"}
+
+```
+
+Das Abrufen anderer Elemente im Speicher ist etwas komplizierter, da zuerst die Position im Speicher Trie berechnet werden muss. Die Position wird als `keccak256`-Hash der Adresse und der Speicherposition berechnet, wobei beide links mit Nullen auf eine Länge von 32 Bytes aufgefüllt werden. Die Position für die Daten im Speicherslot 1 für die Adresse `0x391694e7e0b0cce554cb130d723a9d27458f9298` lautet zum Beispiel:
+
+```python
+keccak256(decodeHex("000000000000000000000000391694e7e0b0cce554cb130d723a9d27458f9298" + "0000000000000000000000000000000000000000000000000000000000000001"))
+```
+
+In einer Geth Konsole kann dies wie folgt berechnet werden:
+
+```
+> var key = "000000000000000000000000391694e7e0b0cce554cb130d723a9d27458f9298" + "0000000000000000000000000000000000000000000000000000000000000001"
+undefined
+> web3.sha3(key, {"encoding": "hex"})
+"0x6661e9d6d8b923d5bbaab1b96e1dd51ff6ea2a93520fdc9eb75d059238b8c5e9"
+```
+
+Der `path` ist daher `keccak256(<6661e9d6d8b923d5bbaab1b96e1dd51ff6ea2a93520fdc9eb75d059238b8c5e9>)`. Damit können nun wie bisher die Daten aus dem Speicher abgerufen werden:
+
+```bash
+curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": ["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x6661e9d6d8b923d5bbaab1b96e1dd51ff6ea2a93520fdc9eb75d059238b8c5e9", "latest"], "id": 1}' localhost:8545
+
+{"jsonrpc":"2.0","id":1,"result":"0x000000000000000000000000000000000000000000000000000000000000162e"}
+```
+
+Hinweis: Der `storageRoot` für ein Ethereum-Konto ist standardmäßig leer, wenn es sich nicht um ein Vertragskonto handelt.
+
+### Transaktions-Trie {#transaction-trie}
+
+Für jeden Block gibt es einen separaten Transaktions-Trie, der wiederum `(key, value)`-Paare speichert. Ein Pfad ist hier: `rlp(transactionIndex)`. Dies stellt den Key dar, der einem Wert entspricht, der bestimmt wird durch:
+
+```python
+if legacyTx:
+ value = rlp(tx)
+else:
+ value = TxType | encode(tx)
+```
+
+Weitere Informationen dazu finden Sie in der [EIP 2718](https://eips.ethereum.org/EIPS/eip-2718)-Dokumentation.
+
+### Beleg-Trie {#receipts-trie}
+
+Jeder Block hat seinen eigenen Belegversuch. Ein `path` ist hier: `rlp(transactionIndex)`. `transactionIndex` ist sein Index innerhalb des Blocks, in dem es enthalten war. Der Beleg Trie wird nie aktualisiert. Ähnlich wie beim Transaktionsverzeichnis gibt es aktuelle und alte Belege. Um eine bestimmte Quittung im Quittungs Trie abzufragen, werden der Index der Transaktion in ihrem Block, die Quittungsnutzlast und der Transaktionstyp benötigt. Der zurückgegebene Beleg kann vom Typ `Receipt` sein, der als Verkettung von `TransactionType` und `ReceiptPayload` definiert ist, oder er kann vom Typ `LegacyReceipt` sein, der als `rlp([status, cumulativeGasUsed, logsBloom, logs])` definiert ist.
+
+Weitere Informationen dazu finden Sie in der [EIP 2718](https://eips.ethereum.org/EIPS/eip-2718)-Dokumentation.
+
+## Weiterführende Lektüre {#further-reading}
+
+- [Modifizierter Merkle-Patricia-Trie — Wie Ethereum einen Zustand speichert](https://medium.com/codechain/modified-merkle-patricia-trie-how-ethereum-saves-a-state-e6d7555078dd)
+- [Merkling in Ethereum](https://blog.ethereum.org/2015/11/15/merkling-in-ethereum/)
+- [Den Ethereum-Trie verstehen](https://easythereentropy.wordpress.com/2014/06/04/understanding-the-ethereum-trie/)
diff --git a/public/content/translations/de/developers/docs/data-structures-and-encoding/rlp/index.md b/public/content/translations/de/developers/docs/data-structures-and-encoding/rlp/index.md
new file mode 100644
index 00000000000..cc95b6bef56
--- /dev/null
+++ b/public/content/translations/de/developers/docs/data-structures-and-encoding/rlp/index.md
@@ -0,0 +1,163 @@
+---
+title: RLP Serialisierung (Recursive Length Prefix)
+description: Eine Definition der RLP-Kodierung in der Ausführungsschicht von Ethereum.
+lang: de
+sidebarDepth: 2
+---
+
+Die Serialisierung mit rekursivem Längenpräfix (RLP) wird in den Ausführungsclients von Ethereum häufig verwendet. RLP standardisiert die Datenübertragung zwischen Knoten in einem platzsparenden Format. Der Zweck von RLP besteht darin, beliebig verschachtelte Arrays binärer Daten zu kodieren, und RLP ist die primäre Kodierungsmethode, die zum Serialisieren von Objekten in der Ausführungsschicht von Ethereum verwendet wird. Der Hauptzweck von RLP ist die Kodierung von Strukturen; mit Ausnahme von positiven Ganzzahlen delegiert RLP die Kodierung bestimmter Datentypen (z. B. Zeichenfolgen, Gleitkommazahlen) an Protokolle höherer Ordnung. Positive Ganzzahlen müssen im Big Endian Binärformat ohne führende Nullen dargestellt werden (wodurch der Ganzzahlwert Null dem leeren Byte-Array entspricht). Deserialisierte positive Ganzzahlen mit führenden Nullen müssen von jedem höherstufigen Protokoll, das RLP verwendet, als ungültig behandelt werden.
+
+Weitere Informationen im [Ethereum Yellow Paper (Anhang B)](https://ethereum.github.io/yellowpaper/paper.pdf#page=19).
+
+Um RLP zum Kodieren eines Wörterbuchs zu verwenden, werden folgende zwei kanonische Formen vorgeschlagen:
+
+- Verwenden Sie `[[k1,v1],[k2,v2]...]` mit Schlüsseln in lexikografischer Reihenfolge
+- Verwenden Sie die höherstufige Patricia Tree Kodierung wie Ethereum
+
+## Definition {#definition}
+
+Die RLPB Kodierungsfunktion nimmt ein Element auf. Ein Artikel wird wie folgt definiert:
+
+- eine Zeichenfolge (d. h. ein Byte-Array) ist ein Element
+- eine Liste von Elementen ist ein Element
+- eine positive ganze Zahl ist ein Element
+
+Zu den folgenden Elementen zählen beispielsweise alle:
+
+- eine leere Zeichenfolge;
+- die Zeichenfolge, die das Wort „Katze“ enthält;
+- eine Liste mit einer beliebigen Anzahl von Zeichenfolgen;
+- und komplexere Datenstrukturen wie `["Katze", ["Welpe", "Kuh"], "Pferd", [[]], "Schwein", [""], "Schaf"]`.
+- die Zahl `100`
+
+Beachten Sie, dass im Kontext der restlichen Seite „Zeichenfolge“ „eine bestimmte Anzahl von Bytes binärer Daten“ bedeutet. Es werden keine speziellen Kodierungen verwendet und es wird kein Wissen über den Inhalt der Zeichenfolgen vorausgesetzt (außer wie von der Regel gegen nicht-minimale positive Ganzzahlen gefordert).
+
+Die RLP-Kodierung ist wie folgt definiert:
+
+- Bei einer positiven Ganzzahl wird diese in das kürzeste Byte-Array konvertiert, dessen groß endian Interpretation die Ganzzahl ist, und dann gemäß den folgenden Regeln als Zeichenfolge codiert.
+- Für ein einzelnes Byte, dessen Wert im Bereich `[0x00, 0x7f]` (dezimal `[0, 127]`) liegt, ist dieses Byte seine eigene RLP-Kodierung.
+- Andernfalls, wenn eine Zeichenfolge 0-55 Bytes lang ist, besteht die RLP-Kodierung aus einem einzelnen Byte mit dem Wert **0x80** (Dez. 128) plus der Länge der Zeichenfolge, gefolgt von der Zeichenfolge. Der Bereich des ersten Bytes ist somit `[0x80, 0xb7]` (Dez. `[128, 183]`).
+- Wenn eine Zeichenfolge mehr als 55 Bytes lang ist, besteht die RLP-Kodierung aus einem einzelnen Byte mit dem Wert **0xb7** (Dez. 183) plus der Länge der Länge der Zeichenfolge in Bytes in Binärform, gefolgt von der Länge der Zeichenfolge, gefolgt von der Zeichenfolge. Beispielsweise würde eine 1024 Byte lange Zeichenfolge als `\xb9\x04\x00` (Dez. `185, 4, 0`) gefolgt von der Zeichenfolge kodiert. Dabei ist `0xb9` (183 + 2 = 185) das erste Byte, gefolgt von den 2 Bytes `0x0400` (Dez. 1024), die die Länge des eigentlichen Strings angeben. Der Bereich des ersten Bytes ist somit `[0xb8, 0xbf]` (Dez. `[184, 191]`).
+- Wenn eine Zeichenfolge 2^64 Bytes oder länger ist, wird sie möglicherweise nicht codiert.
+- Wenn die Gesamtnutzlast einer Liste (d. h. die kombinierte Länge all ihrer RLP-kodierten Elemente) 0-55 Bytes lang ist, besteht die RLP-Kodierung aus einem einzelnen Byte mit dem Wert **0xc0** plus der Länge der Nutzlast, gefolgt von der Verkettung der RLP-Kodierungen der Elemente. Der Bereich des ersten Bytes ist somit `[0xc0, 0xf7]` (Dez. `[192, 247]`).
+- Wenn die Gesamtnutzlast einer Liste mehr als 55 Bytes lang ist, besteht die RLP-Kodierung aus einem einzelnen Byte mit dem Wert **0xf7** plus der Länge der Länge der Nutzlast in Bytes in Binärform, gefolgt von der Länge der Nutzlast, gefolgt von der Verkettung der RLP-Kodierungen der Elemente. Der Bereich des ersten Bytes ist somit `[0xf8, 0xff]` (Dez. `[248, 255]`).
+
+Im Code lautet dies:
+
+```python
+def rlp_encode(input):
+ if isinstance(input,str):
+ if len(input) == 1 and ord(input) < 0x80:
+ return input
+ return encode_length(len(input), 0x80) + input
+ elif isinstance(input, list):
+ output = ''
+ for item in input:
+ output += rlp_encode(item)
+ return encode_length(len(output), 0xc0) + output
+
+def encode_length(L, offset):
+ if L < 56:
+ return chr(L + offset)
+ elif L < 256**8:
+ BL = to_binary(L)
+ return chr(len(BL) + offset + 55) + BL
+ raise Exception("Eingabe zu lang")
+
+def to_binary(x):
+ if x == 0:
+ return ''
+ return to_binary(int(x / 256)) + chr(x % 256)
+```
+
+## Beispiele {#examples}
+
+- die Zeichenfolge "Hund = [ 0x83, 'd', 'o', 'g' ]
+- die Liste [ "cat", "dog" ] = `[ 0xc8, 0x83, 'c', 'a', 't', 0x83, 'd', 'o', 'g' ]`
+- die leere Zeichenfolge ('null') = `[ 0x80 ]`
+- die leere Liste = `[ 0xc0 ]`
+- die Ganzzahl 0 = `[ 0x80 ]`
+- das Byte `\\x00` = `[ 0x00 ]`
+- das Byte `\\x0f` = `[ 0x0f ]`
+- die Bytes `\\x04\\x00` = `[ 0x82, 0x04, 0x00 ]`
+- die [mengentheoretische Darstellung](http://en.wikipedia.org/wiki/Set-theoretic_definition_of_natural_numbers) von drei, `[ [], [[]], [ [], [[]] ] ] = [ 0xc7, 0xc0, 0xc1, 0xc0, 0xc3, 0xc0, 0xc1, 0xc0 ]`
+- die Zeichenfolge "Lorem ipsum dolor sit amet, consectetur adipisicing elit" = `[ 0xb8, 0x38, 'L', 'o', 'r', 'e', 'm', ' ', ...` `, 'e', 'l', 'i', 't' ]`
+
+## RLP-Dekodierung {#rlp-decoding}
+
+Gemäß den Regeln und dem Verfahren der RLP Kodierung wird der Eingang der RLP Dekodierung als ein Array binärer Daten betrachtet. Der RLP Decodierung Verfahren läuft wie folgt ab:
+
+1. entsprechend dem ersten Byte (d. h. Präfix) der Eingabedaten und Dekodierung des Datentyps, der Länge der tatsächlichen Daten und des Offsets;
+
+2. Dekodieren Sie die Daten entsprechend dem Typ und Offset der Daten und beachten Sie dabei die minimale Codierung Regel für positive Ganzzahlen;
+
+3. Fahren Sie mit der Dekodierung des restlichen Inputs fort;
+
+Fahren Sie mit der Dekodierung des restlichen Inputs fort:
+
+1. die Daten sind eine Zeichenfolge, wenn der Bereich des ersten Bytes (d. h. Präfix) [0x00, 0x7f] ist, und die Zeichenfolge genau das erste Byte selbst ist;
+
+2. die Daten sind eine Zeichenfolge, wenn der Bereich des ersten Bytes [0x80, 0xb7] ist und auf das erste Byte die Zeichenfolge folgt, deren Länge gleich dem ersten Byte minus 0x80 ist;
+
+3. die Daten sind eine Zeichenfolge, wenn der Bereich des ersten Bytes [0xb8, 0xbf] ist und die Länge der Zeichenfolge, deren Länge in Bytes gleich dem ersten Byte minus 0xb7 ist, auf das erste Byte folgt und die Zeichenfolge der Länge der Zeichenfolge folgt;
+
+4. die Daten sind eine Liste, wenn der Bereich des ersten Bytes [0xc0, 0xf7] ist und auf das erste Byte die Verkettung der RLP-Kodierungen aller Elemente der Liste folgt, deren Gesamtnutzlast gleich dem ersten Byte minus 0xc0 ist;
+
+5. die Daten sind eine Liste, wenn der Bereich des ersten Bytes [0xf8, 0xff] ist und die Gesamtnutzlast der Liste, deren Länge gleich dem ersten Byte minus 0xf7 ist, auf das erste Byte folgt und die Verkettung der RLP-Kodierungen aller Elemente der Liste der Gesamtnutzlast der Liste folgt;
+
+Im Code lautet dies:
+
+```python
+def rlp_decode(input):
+ if len(input) == 0:
+ return
+ output = ''
+ (offset, dataLen, type) = decode_length(input)
+ if type is str:
+ output = instantiate_str(substr(input, offset, dataLen))
+ elif type is list:
+ output = instantiate_list(substr(input, offset, dataLen))
+ output += rlp_decode(substr(input, offset + dataLen))
+ return output
+
+def decode_length(input):
+ length = len(input)
+ if length == 0:
+ raise Exception("Eingabe ist null")
+ prefix = ord(input[0])
+ if prefix <= 0x7f:
+ return (0, 1, str)
+ elif prefix <= 0xb7 and length > prefix - 0x80:
+ strLen = prefix - 0x80
+ return (1, strLen, str)
+ elif prefix <= 0xbf and length > prefix - 0xb7 and length > prefix - 0xb7 + to_integer(substr(input, 1, prefix - 0xb7)):
+ lenOfStrLen = prefix - 0xb7
+ strLen = to_integer(substr(input, 1, lenOfStrLen))
+ return (1 + lenOfStrLen, strLen, str)
+ elif prefix <= 0xf7 and length > prefix - 0xc0:
+ listLen = prefix - 0xc0;
+ return (1, listLen, list)
+ elif prefix <= 0xff and length > prefix - 0xf7 and length > prefix - 0xf7 + to_integer(substr(input, 1, prefix - 0xf7)):
+ lenOfListLen = prefix - 0xf7
+ listLen = to_integer(substr(input, 1, lenOfListLen))
+ return (1 + lenOfListLen, listLen, list)
+ raise Exception("Eingabe entspricht nicht dem RLP-Kodierungsformat")
+
+def to_integer(b):
+ length = len(b)
+ if length == 0:
+ raise Exception("Eingabe ist null")
+ elif length == 1:
+ return ord(b[0])
+ return ord(substr(b, -1)) + to_integer(substr(b, 0, -1)) * 256
+```
+
+## Weiterführende Lektüre {#further-reading}
+
+- [RLP in Ethereum](https://medium.com/coinmonks/data-structure-in-ethereum-episode-1-recursive-length-prefix-rlp-encoding-decoding-d1016832f919)
+- [Ethereum unter der Haube: RLP](https://medium.com/coinmonks/ethereum-under-the-hood-part-3-rlp-decoding-df236dc13e58)
+- [Coglio, A. (2020). Ethereums rekursives Längenpräfix in ACL2. arXiv preprint arXiv:2009.13769.](https://arxiv.org/abs/2009.13769)
+
+## Verwandte Themen {#related-topics}
+
+- [Patricia-Merkle-Trie](/developers/docs/data-structures-and-encoding/patricia-merkle-trie)
diff --git a/public/content/translations/de/developers/docs/data-structures-and-encoding/ssz/index.md b/public/content/translations/de/developers/docs/data-structures-and-encoding/ssz/index.md
new file mode 100644
index 00000000000..96ca799aab9
--- /dev/null
+++ b/public/content/translations/de/developers/docs/data-structures-and-encoding/ssz/index.md
@@ -0,0 +1,150 @@
+---
+title: Einfache Serialisierung
+description: Erklärung des SSZ Formats von Ethereum.
+lang: de
+sidebarDepth: 2
+---
+
+**Simple Serialize (SSZ)** ist die Serialisierungsmethode, die auf der Beacon Chain verwendet wird. Es ersetzt die auf der Ausführungsebene verwendete RLP Serialisierung überall auf der Konsensebene mit Ausnahme des Peer-Discovery Protokolls. Weitere Informationen zur RLP-Serialisierung findest du unter [Recursive-Length Prefix (RLP)](/developers/docs/data-structures-and-encoding/rlp/). SSZ ist so konzipiert, dass es deterministisch ist und sich auch effizient Merkleize lässt. Man kann sich SSZ als aus zwei Komponenten bestehend vorstellen: einem Serialisierungs Schema und einem Merkleisierungs Schema, das für die effiziente Arbeit mit der serialisierten Datenstruktur konzipiert ist.
+
+## Wie funktioniert SSZ? {#how-does-ssz-work}
+
+### Serialisierung {#serialization}
+
+SSZ ist ein Serialisierungs Schema, das nicht selbstbeschreibend ist, sondern auf einem Schema basiert, das im Voraus bekannt sein muss. Das Ziel der SSZ Serialisierung besteht darin, Objekte beliebiger Komplexität als Bytefolgen darzustellen. Für „Basistypen“ ist dies ein sehr einfacher Vorgang. Das Element wird einfach in hexadezimale Bytes umgewandelt. Zu den Grundtypen gehören:
+
+- Vorzeichenlose Ganzzahlen
+- Boolesche Werte
+
+Bei komplexen „zusammengesetzten“ Typen ist die Serialisierung komplizierter, da der zusammengesetzte Typ mehrere Elemente enthält, die unterschiedliche Typen oder unterschiedliche Größen oder beides haben können. Wenn diese Objekte alle eine feste Länge haben (d. h. die Größe der Elemente ist unabhängig von ihren tatsächlichen Werten immer konstant), ist die Serialisierung einfach eine Konvertierung jedes Elements im zusammengesetzten Typ in der entsprechenden Reihenfolge in Little-Endian-Bytestrings. Diese Byte Strings werden zusammengefügt. Das serialisierte Objekt verfügt über die Byte Listendarstellung der Elemente mit fester Länge in derselben Reihenfolge, in der sie im deserialisierten Objekt erscheinen.
+
+Bei Typen mit variabler Länge werden die tatsächlichen Daten durch einen „Offset“-Wert an der Position dieses Elements im serialisierten Objekt ersetzt. Die eigentlichen Daten werden am Ende des serialisierten Objekts zu einem Haufen hinzugefügt. Der Offsetwert ist der Index für den Beginn der eigentlichen Daten im Haufen und fungiert als Zeiger auf die relevanten Bytes.
+
+Das folgende Beispiel veranschaulicht, wie der Ausgleich für einen Container mit Elementen fester und variabler Länge funktioniert:
+
+```Rust
+
+ struct Dummy {
+
+ number1: u64,
+ number2: u64,
+ vector: Vec,
+ number3: u64
+ }
+
+ dummy = Dummy{
+
+ number1: 37,
+ number2: 55,
+ vector: vec![1,2,3,4],
+ number3: 22,
+ }
+
+ serialized = ssz.serialize(dummy)
+
+```
+
+`serialized` hätte die folgende Struktur (hier nur auf 4 Bit aufgefüllt, in Wirklichkeit auf 32 Bit, wobei die `int`-Darstellung zur Verdeutlichung beibehalten wird):
+
+```
+[37, 0, 0, 0, 55, 0, 0, 0, 16, 0, 0, 0, 22, 0, 0, 0, 1, 2, 3, 4]
+------------ ----------- ----------- ----------- ----------
+ | | | | |
+ number1 number2 Offset für number3 Wert für
+ vector vector
+
+```
+
+Zur besseren Übersichtlichkeit auf mehrere Zeilen aufgeteilt:
+
+```
+[
+ 37, 0, 0, 0, # Little-Endian-Kodierung von `number1`.
+ 55, 0, 0, 0, # Little-Endian-Kodierung von `number2`.
+ 16, 0, 0, 0, # Der „Offset“, der anzeigt, wo der Wert von `vector` beginnt (Little-Endian 16).
+ 22, 0, 0, 0, # Little-Endian-Kodierung von `number3`.
+ 1, 2, 3, 4, # Die tatsächlichen Werte in `vector`.
+]
+```
+
+Dies ist immer noch eine Vereinfachung – die Ganzzahlen und Nullen in den obigen Schemata würden tatsächlich als Byte listen gespeichert, etwa so:
+
+```
+[
+ 10100101000000000000000000000000 # Little-Endian-Kodierung von `number1`
+ 10110111000000000000000000000000 # Little-Endian-Kodierung von `number2`.
+ 10010000000000000000000000000000 # Der „Offset“, der anzeigt, wo der Wert von `vector` beginnt (Little-Endian 16).
+ 10010110000000000000000000000000 # Little-Endian-Kodierung von `number3`.
+ 10000001100000101000001110000100 # Der tatsächliche Wert des `bytes`-Feldes.
+]
+```
+
+Daher werden die tatsächlichen Werte für Typen mit variabler Länge in einem Haufen am Ende des serialisierten Objekts gespeichert, wobei ihre Offsets an den richtigen Positionen in der geordneten Liste der Felder gespeichert werden.
+
+Es gibt auch einige Sonderfälle, die eine besondere Behandlung erfordern, wie z. B. der Typ `BitList`, bei dem während der Serialisierung eine Längenbegrenzung hinzugefügt und während der Deserialisierung entfernt werden muss. Alle Details findest du in der [SSZ-Spezifikation](https://github.com/ethereum/consensus-specs/blob/dev/ssz/simple-serialize.md).
+
+### Deserialisierung {#deserialization}
+
+Zum Deseria lisieren dieses Objekts ist das Schema erforderlich. Das Schema definiert das genaue Layout der serialisierten Daten, sodass jedes spezifische Element aus einem Byte Klecks in ein aussagekräftiges Objekt deserialisiert werden kann, wobei die Elemente den richtigen Typ, Wert, die richtige Größe und Position haben. Das Schema teilt dem Deserialisierer mit, welche Werte tatsächliche Werte und welche Offsets sind. Alle Feldnamen verschwinden, wenn ein Objekt serialisiert wird, werden aber bei der Deserialisierung gemäß dem Schema neu instanziiert.
+
+Eine interaktive Erklärung dazu findest du auf [ssz.dev](https://www.ssz.dev/overview).
+
+## Merkleisierung {#merkleization}
+
+Dieses SSZ Serialisierte Objekt kann dann merkleisiert werden, d. h. in eine Merkle Baum Darstellung derselben Daten umgewandelt werden. Zunächst wird die Anzahl der 32-Byte-Blöcke im serialisierten Objekt ermittelt. Dies sind die „Blätter“ des Baumes. Die Gesamtzahl der Blätter muss eine Zweierpotenz sein, damit das Zusammenführen der Blätter schließlich eine einzelne Hash-Baum-Wurzel ergibt. Wenn dies nicht von Natur aus der Fall ist, werden zusätzliche Blätter mit 32 Bytes Nullen hinzugefügt. Schematisch.
+
+```
+ Hash-Baumwurzel
+ / \
+ / \
+ / \
+ / \
+ Hash der Blätter Hash der Blätter
+ 1 und 2 3 und 4
+ / \ / \
+ / \ / \
+ / \ / \
+ Blatt1 Blatt2 Blatt3 Blatt4
+```
+
+Es gibt auch Fälle, in denen die Blätter des Baumes nicht von Natur aus gleichmäßig verteilt sind, wie im obigen Beispiel. Beispielsweise könnte Blatt 4 ein Container mit mehreren Elementen sein, die dem Merkle Baum zusätzliche „Tiefe“ hinzufügen müssen, wodurch ein ungleichmäßiger Baum entsteht.
+
+Anstatt diese Baumelemente als Blatt X, Knoten X usw. zu bezeichnen, können wir ihnen verallgemeinerte Indizes zuweisen, beginnend mit Wurzel = 1 und von links nach rechts entlang jeder Ebene zählend. Dies ist der oben Erläuterte verallgemeinerte Index. Jedes Element in der serialisierten Liste hat einen verallgemeinerten Index gleich `2**depth + idx`, wobei idx seine nullindizierte Position im serialisierten Objekt und die Tiefe die Anzahl der Ebenen im Merkle-Baum ist, die als Logarithmus zur Basis zwei der Anzahl der Elemente (Blätter) bestimmt werden kann.
+
+## Verallgemeinerte Indizes {#generalized-indices}
+
+Ein verallgemeinerter Index ist eine Ganzzahl, die einen Node in einem binären Merkle-Baum darstellt, wobei jeder Node einen verallgemeinerten Index von `2 ** depth + index in row` hat.
+
+```
+ 1 --depth = 0 2**0 + 0 = 1
+ 2 3 --depth = 1 2**1 + 0 = 2, 2**1+1 = 3
+ 4 5 6 7 --depth = 2 2**2 + 0 = 4, 2**2 + 1 = 5...
+
+```
+
+Diese Darstellung ergibt einen Knotenindex für jedes Datenelement im Merkle Baum.
+
+## Multiproofs {#multiproofs}
+
+Durch die Bereitstellung der Liste verallgemeinerter Indizes, die ein bestimmtes Element darstellen, können wir es anhand der Hash-Baum-Wurzel überprüfen. Diese Wurzel ist unsere akzeptierte Version der Realität. Alle uns zur Verfügung gestellten Daten können anhand dieser Realität überprüft werden, indem sie an der richtigen Stelle im Merkle Baum eingefügt werden (bestimmt durch seinen verallgemeinerten Index) und beobachtet wird, dass die Wurzel konstant bleibt. In der Spezifikation findest du [hier](https://github.com/ethereum/consensus-specs/blob/dev/ssz/merkle-proofs.md#merkle-multiproofs) Funktionen, die zeigen, wie die minimale Menge an Nodes berechnet wird, die benötigt wird, um den Inhalt einer bestimmten Menge verallgemeinerter Indizes zu verifizieren.
+
+Um beispielsweise Daten im Index 9 im folgenden Baum zu überprüfen, benötigen wir den Hash der Daten an den Indizes 8, 9, 5, 3, 1.
+Der Hash von (8,9) sollte dem Hash (4) entsprechen, der mit 5 gehasht wird, um 2 zu erzeugen, das mit 3 gehasht wird, um die Baumwurzel 1 zu erzeugen. Wenn für 9 falsche Daten angegeben würden, würde sich die Wurzel ändern – wir würden dies erkennen und den Zweig nicht überprüfen.
+
+```
+* = Daten, die zur Erzeugung des Proofs erforderlich sind
+
+ 1*
+ 2 3*
+ 4 5* 6 7
+8* 9* 10 11 12 13 14 15
+
+```
+
+## Weiterführende Lektüre {#further-reading}
+
+- [Ethereum upgraden: SSZ](https://eth2book.info/altair/part2/building_blocks/ssz)
+- [Ethereum upgraden: Merkleisierung](https://eth2book.info/altair/part2/building_blocks/merkleization)
+- [SSZ-Implementierungen](https://github.com/ethereum/consensus-specs/issues/2138)
+- [SSZ-Rechner](https://simpleserialize.com/)
+- [SSZ.dev](https://www.ssz.dev/)
diff --git a/public/content/translations/de/developers/docs/data-structures-and-encoding/web3-secret-storage/index.md b/public/content/translations/de/developers/docs/data-structures-and-encoding/web3-secret-storage/index.md
new file mode 100644
index 00000000000..20665ad9a32
--- /dev/null
+++ b/public/content/translations/de/developers/docs/data-structures-and-encoding/web3-secret-storage/index.md
@@ -0,0 +1,195 @@
+---
+title: Speicherdefinition von Web3-Geheimnis
+description: Formale Definition für die geheime Speicherung von Web3
+lang: de
+sidebarDepth: 2
+---
+
+Damit Ihre App auf Ethereum funktioniert, können Sie das von der Bibliothek web3.js bereitgestellte Web3 Objekt verwenden. Unter der Haube kommuniziert es über RPC Aufrufe mit einem lokalen Knoten. [web3](https://github.com/ethereum/web3.js/) funktioniert mit jedem Ethereum-Node, der eine RPC-Schicht bereitstellt.
+
+`web3` enthält das `eth`-Objekt – web3.eth.
+
+```js
+var fs = require("fs")
+var recognizer = require("ethereum-keyfile-recognizer")
+
+fs.readFile("keyfile.json", (err, data) => {
+ var json = JSON.parse(data)
+ var result = recognizer(json)
+})
+
+/** result
+ * [ 'web3', 3 ] web3 (v3) Schlüsseldatei
+ * [ 'ethersale', undefined ] Ethersale-Schlüsseldatei
+ * null ungültige Schlüsseldatei
+ */
+```
+
+Dieses Dokument beschreibt **Version 3** der Web3 Secret Storage Definition.
+
+## Definition {#definition}
+
+Die eigentliche Kodierung und Dekodierung der Datei bleibt im Vergleich zu Version 1 weitgehend unverändert, außer dass der Kryptoalgorithmus nicht mehr auf AES-128-CBC festgelegt ist (AES-128-CTR ist jetzt die Mindestanforderung). Die meisten Bedeutungen/der Algorithmus sind ähnlich wie in Version 1, mit Ausnahme von `mac`, das als SHA3 (Keccak-256) der Verkettung der zweiten 16 Bytes von links des abgeleiteten Schlüssels zusammen mit dem vollständigen `ciphertext` angegeben wird.
+
+Geheime Schlüsseldateien werden direkt in `~/.web3/keystore` (für Unix-ähnliche Systeme) und `~/AppData/Web3/keystore` (für Windows) gespeichert. Sie können beliebig benannt werden, aber eine gute Konvention ist `.json`, wobei `` die 128-Bit-UUID ist, die dem geheimen Schlüssel zugewiesen wird (ein datenschutzwahrender Proxy für die Adresse des geheimen Schlüssels).
+
+Diese Dateien sind passwortgeschützt. Um den geheimen Schlüssel einer `.json`-Datei abzuleiten, wird zuerst der Verschlüsselungsschlüssel der Datei abgeleitet; dies geschieht, indem das Passwort der Datei durch eine Schlüsselableitungsfunktion geleitet wird, wie sie vom `kdf`-Schlüssel beschrieben wird. KDF-abhängige statische und dynamische Parameter für die KDF-Funktion werden im `kdfparams`-Schlüssel beschrieben.
+
+Für alle minimal konformen Implementierungen ist die Unterstützung von PBKDF2 obligatorisch, mit folgender Kennzeichnung:
+
+- `kdf`: `pbkdf2`
+
+Für PBKDF2 setzen sich die kdfparams wie folgt zusammen:
+
+- `prf`: Muss `hmac-sha256` sein (kann in Zukunft erweitert werden);
+- `c`: Anzahl der Iterationen;
+- `salt`: Salt, das an PBKDF übergeben wird;
+- `dklen`: Länge für den abgeleiteten Schlüssel. Muss >= 32 sein.
+
+Nachdem der Schlüssel der Datei abgeleitet wurde, muss er durch die Ableitung des MAC verifiziert werden. Der MAC sollte als SHA3 (Keccak-256)-Hash des Byte-Arrays berechnet werden, das durch die Verkettung der Bytes 16-31 des abgeleiteten Schlüssels mit dem Inhalt des `ciphertext`-Schlüssels gebildet wird, d. h.:
+
+```js
+KECCAK(DK[16..31] ++ )
+```
+
+(wobei `++` der Verkettungsoperator ist)
+
+Dieser Wert sollte mit dem Inhalt des `mac`-Schlüssels verglichen werden; wenn sie sich unterscheiden, sollte ein alternatives Passwort angefordert (oder der Vorgang abgebrochen) werden.
+
+Nachdem der Schlüssel der Datei verifiziert wurde, kann der Chiffretext (der `ciphertext`-Schlüssel in der Datei) mit dem symmetrischen Verschlüsselungsalgorithmus entschlüsselt werden, der durch den `cipher`-Schlüssel spezifiziert und durch den `cipherparams`-Schlüssel parametrisiert wird. Bei einer Nichtübereinstimmung der Schlüsselgrößen (abgeleiteter Schlüssel vs. Algorithmus-Schlüssel) werden die letzten Bytes des mit Nullen aufgefüllten, abgeleiteten Schlüssels als Schlüssel für den Algorithmus genutzt.
+
+ede Implementierung, die die Mindestanforderungen erfüllt, muss den AES-128-CTR-Algorithmus unterstützen, welcher folgendermaßen gekennzeichnet ist:
+
+- `cipher: aes-128-ctr`
+
+Dieser Verschlüsselungsalgorithmus verwendet die folgenden Parameter, welche als Schlüssel innerhalb des cipherparams-Objekts übergeben werden:
+
+- `iv`: 128-Bit-Initialisierungsvektor für die Chiffre.
+
+Als Schlüssel für die Chiffre werden die 16 Bytes ganz links des abgeleiteten Schlüssels verwendet, d. h. `DK[0..15]`.
+
+Für die Erstellung und Verschlüsselung eines geheimen Schlüssels gelten diese Anweisungen im Grunde in umgekehrter Reihenfolge. Stellen Sie sicher, dass `uuid`, `salt` und `iv` tatsächlich zufällig sind.
+
+Zusätzlich zum `version`-Feld, das als „harter“ Identifikator für die Version dienen sollte, können Implementierungen auch `minorversion` verwenden, um kleinere, abwärtskompatible Änderungen am Format zu verfolgen.
+
+## Testvektoren {#test-vectors}
+
+Details:
+
+- `Adresse`: `008aeeda4d805471df9b2a5b0f38a0c3bcba786b`
+- `ICAP`: `XE542A5PZHH8PYIZUBEJEO0MFWRAPPIL67`
+- `UUID`: `3198bc9c-6672-5ab3-d9954942343ae5b6`
+- `Passwort`: `testpassword`
+- `Geheimnis`: `7a28b5ba57c53603b0b07b56bba752f7784bf506fa95edc395f5cf6c7514fe9d`
+
+### PBKDF2-SHA-256 {#PBKDF2-SHA-256}
+
+Testvektor mit `AES-128-CTR` und `PBKDF2-SHA-256`:
+
+Dateiinhalt von `~/.web3/keystore/3198bc9c-6672-5ab3-d9954942343ae5b6.json`:
+
+```json
+{
+ "crypto": {
+ "cipher": "aes-128-ctr",
+ "cipherparams": {
+ "iv": "6087dab2f9fdbbfaddc31a909735c1e6"
+ },
+ "ciphertext": "5318b4d5bcd28de64ee5559e671353e16f075ecae9f99c7a79a38af5f869aa46",
+ "kdf": "pbkdf2",
+ "kdfparams": {
+ "c": 262144,
+ "dklen": 32,
+ "prf": "hmac-sha256",
+ "salt": "ae3cd4e7013836a3df6bd7241b12db061dbe2c6785853cce422d148a624ce0bd"
+ },
+ "mac": "517ead924a9d0dc3124507e3393d175ce3ff7c1e96529c6c555ce9e51205e9b2"
+ },
+ "id": "3198bc9c-6672-5ab3-d995-4942343ae5b6",
+ "version": 3
+}
+```
+
+**Zwischenergebnisse**:
+
+`Abgeleiteter Schlüssel`: `f06d69cdc7da0faffb1008270bca38f5e31891a3a773950e6d0fea48a7188551`
+`MAC-Body`: `e31891a3a773950e6d0fea48a71885515318b4d5bcd28de64ee5559e671353e16f075ecae9f99c7a79a38af5f869aa46`
+`MAC`: `517ead924a9d0dc3124507e3393d175ce3ff7c1e96529c6c555ce9e51205e9b2`
+`Chiffrierschlüssel`: `f06d69cdc7da0faffb1008270bca38f5`
+
+### Scrypt {#scrypt}
+
+Testvektor für AES-128-CTR und Scrypt:
+
+```json
+{
+ "crypto": {
+ "cipher": "aes-128-ctr",
+ "cipherparams": {
+ "iv": "740770fce12ce862af21264dab25f1da"
+ },
+ "ciphertext": "dd8a1132cf57db67c038c6763afe2cbe6ea1949a86abc5843f8ca656ebbb1ea2",
+ "kdf": "scrypt",
+ "kdfparams": {
+ "dklen": 32,
+ "n": 262144,
+ "p": 1,
+ "r": 8,
+ "salt": "25710c2ccd7c610b24d068af83b959b7a0e5f40641f0c82daeb1345766191034"
+ },
+ "mac": "337aeb86505d2d0bb620effe57f18381377d67d76dac1090626aa5cd20886a7c"
+ },
+ "id": "3198bc9c-6672-5ab3-d995-4942343ae5b6",
+ "version": 3
+}
+```
+
+**Zwischenergebnisse**:
+
+`Abgeleiteter Schlüssel`: `7446f59ecc301d2d79bc3302650d8a5cedc185ccbb4bf3ca1ebd2c163eaa6c2d`
+`MAC-Body`: `edc185ccbb4bf3ca1ebd2c163eaa6c2ddd8a1132cf57db67c038c6763afe2cbe6ea1949a86abc5843f8ca656ebbb1ea2`
+`MAC`: `337aeb86505d2d0bb620effe57f18381377d67d76dac1090626aa5cd20886a7c`
+`Chiffrierschlüssel`: `7446f59ecc301d2d79bc3302650d8a5c`
+
+## Änderungen gegenüber Version 1 {#alterations-from-v2}
+
+Diese Version behebt mehrere Inkonsistenzen mit der [hier](https://github.com/ethereum/homestead-guide/blob/master/old-docs-for-reference/go-ethereum-wiki.rst/Passphrase-protected-key-store-spec.rst) veröffentlichten Version 1. In Kürze:
+
+- Die uneinheitliche und willkürliche Groß- und Kleinschreibung ist problematisch (mal Kleinschreibung wie bei scrypt, mal gemischte Schreibweise wie bei Kdf oder Großbuchstaben wie bei MAC).
+- Das Feld Address ist nicht erforderlich und gefährdet die Privatsphäre.
+- `Salt` ist ein wesentlicher Parameter der Schlüsselableitungsfunktion und sollte ihr zugeordnet werden, nicht der Kryptographie im Allgemeinen.
+- _SaltLen_ ist unnötig (es kann einfach von Salt abgeleitet werden).
+- Die Schlüsselableitungsfunktion ist frei wählbar, der Krypto-Algorithmus aber fest einprogrammiert.
+- `Version` ist eigentlich numerisch, wird aber als String gespeichert (eine strukturierte Versionierung per String wäre zwar denkbar, sprengt aber den Rahmen für ein Konfigurationsdateiformat, das sich selten ändert).
+- `KDF` und `cipher` sind konzeptionell verwandte Konzepte, werden aber unterschiedlich organisiert.
+- Der `MAC` wird aus einem Datenstück berechnet, das von Leerräumen (Whitespace) unabhängig ist(!)
+
+Durch Änderungen am Format ergibt sich die folgende Datei. Ihre Funktionalität entspricht dem Beispiel auf der zuvor verlinkten Seite:
+
+```json
+{
+ "crypto": {
+ "cipher": "aes-128-cbc",
+ "ciphertext": "07533e172414bfa50e99dba4a0ce603f654ebfa1ff46277c3e0c577fdc87f6bb4e4fe16c5a94ce6ce14cfa069821ef9b",
+ "cipherparams": {
+ "iv": "16d67ba0ce5a339ff2f07951253e6ba8"
+ },
+ "kdf": "scrypt",
+ "kdfparams": {
+ "dklen": 32,
+ "n": 262144,
+ "p": 1,
+ "r": 8,
+ "salt": "06870e5e6a24e183a5c807bd1c43afd86d573f7db303ff4853d135cd0fd3fe91"
+ },
+ "mac": "8ccded24da2e99a11d48cda146f9cc8213eb423e2ea0d8427f41c3be414424dd",
+ "version": 1
+ },
+ "id": "0498f19a-59db-4d54-ac95-33901b4f1870",
+ "version": 2
+}
+```
+
+## Änderungen gegenüber Version 2 {#alterations-from-v2}
+
+Version 2 war eine frühe, fehlerbehaftete Implementierung in C++. An den Grundlagen ändert sich nichts.
diff --git a/public/content/translations/de/developers/docs/design-and-ux/dex-design-best-practice/index.md b/public/content/translations/de/developers/docs/design-and-ux/dex-design-best-practice/index.md
new file mode 100644
index 00000000000..d0e14d0bc55
--- /dev/null
+++ b/public/content/translations/de/developers/docs/design-and-ux/dex-design-best-practice/index.md
@@ -0,0 +1,220 @@
+---
+title: Bewährte Praktiken für das Design von dezentralen Börsen (DEX)
+description: Ein Leitfaden, der UX/UI-Entscheidungen für das Tauschen von Tokens erklärt.
+lang: de
+---
+
+Seit dem Start von Uniswap im Jahr 2018 wurden Hunderte von dezentralen Börsen auf Dutzenden von verschiedenen Chains gestartet.
+Viele von ihnen führten neue Elemente ein oder fügten ihre eigene Note hinzu, aber die Benutzeroberfläche ist im Allgemeinen gleich geblieben.
+
+Ein Grund dafür ist [Jakobs Gesetz](https://lawsofux.com/jakobs-law/):
+
+> Benutzer verbringen die meiste Zeit auf anderen Websites. Das bedeutet, dass Benutzer es vorziehen, dass Ihre Website auf die gleiche Weise funktioniert wie alle anderen Websites, die sie bereits kennen.
+
+Dank früher Innovatoren wie Uniswap, Pancakeswap und Sushiswap haben DeFi-Benutzer eine kollektive Vorstellung davon, wie eine DEX aussieht.
+Aus diesem Grund bildet sich jetzt so etwas wie eine „Best Practice“ heraus. Wir sehen, dass immer mehr Design-Entscheidungen über Websites hinweg standardisiert werden. Man kann die Entwicklung von DEXs als ein riesiges Beispiel für Live-Tests sehen. Dinge, die funktionierten, blieben, Dinge, die nicht funktionierten, wurden verworfen. Es gibt immer noch Raum für Persönlichkeit, aber es gibt bestimmte Standards, denen eine DEX entsprechen sollte.
+
+Dieser Artikel ist eine Zusammenfassung von:
+
+- was man einbeziehen sollte
+- wie man es so benutzerfreundlich wie möglich gestaltet
+- die wichtigsten Möglichkeiten, das Design anzupassen
+
+Alle Beispiel-Wireframes wurden speziell für diesen Artikel erstellt, obwohl sie alle auf realen Projekten basieren.
+
+Das Figma-Kit ist ebenfalls am Ende enthalten – Sie können es gerne verwenden und Ihre eigenen Wireframes beschleunigen!
+
+## Grundlegende Anatomie einer DEX {#basic-anatomy-of-a-dex}
+
+Die Benutzeroberfläche enthält im Allgemeinen drei Elemente:
+
+1. Hauptformular
+2. Schaltfläche
+3. Detailbereich
+
+
+
+## Variationen {#variations}
+
+Dies wird ein wiederkehrendes Thema in diesem Artikel sein, aber es gibt verschiedene Möglichkeiten, diese Elemente zu organisieren. Der „Detailbereich“ kann sein:
+
+- Über der Schaltfläche
+- Unter der Schaltfläche
+- In einem Akkordeon-Panel versteckt
+- Und/oder in einem „Vorschau“-Modal
+
+N.B. Ein „Vorschau“-Modal ist optional, aber wenn Sie nur sehr wenige Details auf der Hauptbenutzeroberfläche anzeigen, wird es unerlässlich.
+
+## Struktur des Hauptformulars {#structure-of-the-main-form}
+
+Dies ist das Feld, in dem Sie tatsächlich auswählen, welchen Token Sie tauschen möchten. Die Komponente besteht aus einem Eingabefeld und einer kleinen Schaltfläche in einer Reihe.
+
+DEXs zeigen normalerweise zusätzliche Details in einer Reihe darüber und einer Reihe darunter an, obwohl dies auch anders konfiguriert werden kann.
+
+
+
+## Variationen {#variations2}
+
+Hier werden zwei UI-Variationen gezeigt; eine ohne Ränder, die ein sehr offenes Design erzeugt, und eine, bei der die Eingabezeile einen Rand hat, was den Fokus auf dieses Element legt.
+
+
+
+Diese Grundstruktur ermöglicht es, **vier wichtige Informationen** im Design anzuzeigen: eine in jeder Ecke. Wenn es nur eine obere/untere Reihe gibt, dann gibt es nur zwei Plätze.
+
+Im Laufe der Entwicklung von DeFi wurden hier viele verschiedene Dinge integriert.
+
+## Wichtige Informationen, die enthalten sein sollten {#key-info-to-include}
+
+- Guthaben in der Wallet
+- Max-Schaltfläche
+- Fiat-Äquivalent
+- Preisauswirkung auf den „erhaltenen“ Betrag
+
+In den Anfängen von DeFi fehlte oft das Fiat-Äquivalent. Wenn Sie irgendeine Art von Web3-Projekt entwickeln, ist es unerlässlich, dass ein Fiat-Äquivalent angezeigt wird. Benutzer denken immer noch in lokalen Währungen, daher sollte dies einbezogen werden, um den realen mentalen Modellen zu entsprechen.
+
+Im zweiten Feld (dem, in dem Sie den Token auswählen, zu dem Sie tauschen) können Sie auch die Preisauswirkung neben dem Fiat-Währungsbetrag angeben, indem Sie die Differenz zwischen dem eingegebenen Betrag und den geschätzten Ausgabebeträgen berechnen. Dies ist ein recht nützliches Detail, das man einbeziehen sollte.
+
+Prozent-Schaltflächen (z. B. 25 %, 50 %, 75 %) können eine nützliche Funktion sein, aber sie nehmen mehr Platz ein, fügen mehr Handlungsaufforderungen hinzu und erhöhen die mentale Belastung. Dasselbe gilt für Prozentregler. Einige dieser UI-Entscheidungen hängen von Ihrer Marke und Ihrem Benutzertyp ab.
+
+Zusätzliche Details können unter dem Hauptformular angezeigt werden. Da diese Art von Informationen hauptsächlich für Profi-Benutzer gedacht ist, ist es sinnvoll, sie entweder:
+
+- so minimal wie möglich zu halten, oder;
+- in einem Akkordeon-Panel zu verstecken
+
+
+
+## Zusätzliche Informationen, die enthalten sein sollten {#extra-info-to-include}
+
+- Token-Preis
+- Slippage
+- Mindestens erhaltener Betrag
+- Erwartete Ausgabe
+- Preisauswirkung
+- Gas-Kostenschätzung
+- Andere Gebühren
+- Order-Routing
+
+Man könnte argumentieren, dass einige dieser Details optional sein könnten.
+
+Order-Routing ist interessant, macht aber für die meisten Benutzer keinen großen Unterschied.
+
+Einige andere Details geben einfach dasselbe auf unterschiedliche Weise wieder. Zum Beispiel sind „mindestens erhaltener Betrag“ und „Slippage“ zwei Seiten derselben Medaille. Wenn Sie die Slippage auf 1 % eingestellt haben, dann ist der Mindestbetrag, den Sie erwarten können = erwartete Ausgabe - 1 %. Einige Benutzeroberflächen zeigen den erwarteten Betrag, den Mindestbetrag und die Slippage an … Was nützlich, aber möglicherweise übertrieben ist.
+
+Die meisten Benutzer werden die Standard-Slippage ohnehin beibehalten.
+
+Die „Preisauswirkung“ wird oft in Klammern neben dem Fiat-Äquivalent im „An“-Feld angezeigt. Dies ist ein großartiges UX-Detail, aber wenn es hier angezeigt wird, muss es dann wirklich noch einmal unten angezeigt werden? Und dann noch einmal auf einem Vorschaubildschirm?
+
+Viele Benutzer (insbesondere diejenigen, die kleine Beträge tauschen) werden sich nicht um diese Details kümmern; sie werden einfach eine Zahl eingeben und auf Tauschen klicken.
+
+
+
+Welche Details genau angezeigt werden, hängt von Ihrer Zielgruppe und dem Gefühl ab, das Ihre App vermitteln soll.
+
+Wenn Sie die Slippage-Toleranz im Detailbereich anzeigen, sollten Sie sie auch direkt von hier aus bearbeitbar machen. Dies ist ein gutes Beispiel für einen „Beschleuniger“; ein netter UX-Trick, der die Abläufe erfahrener Benutzer beschleunigen kann, ohne die allgemeine Benutzerfreundlichkeit der App zu beeinträchtigen.
+
+
+
+Es ist eine gute Idee, nicht nur über eine bestimmte Information auf einem Bildschirm nachzudenken, sondern über den gesamten Ablauf:
+Zahlen im Hauptformular eingeben → Details scannen → Zum Vorschaubildschirm klicken (falls Sie einen haben).
+Sollte der Detailbereich jederzeit sichtbar sein, oder muss der Benutzer darauf klicken, um ihn zu erweitern?
+Sollten Sie durch das Hinzufügen eines Vorschaubildschirms Reibung erzeugen? Dies zwingt den Benutzer, langsamer zu machen und seinen Handel zu überdenken, was nützlich sein kann. Aber wollen sie all die gleichen Informationen noch einmal sehen? Was ist für sie an diesem Punkt am nützlichsten?
+
+## Design-Optionen {#design-options}
+
+Wie bereits erwähnt, hängt vieles von Ihrem persönlichen Stil ab
+Wer ist Ihr Benutzer?
+Was ist Ihre Marke?
+Wollen Sie eine „Profi“-Oberfläche, die jedes Detail anzeigt, oder wollen Sie minimalistisch sein?
+Selbst wenn Sie auf Profi-Benutzer abzielen, die alle möglichen Informationen wollen, sollten Sie sich dennoch an Alan Coopers weise Worte erinnern:
+
+> Egal wie schön, egal wie cool Ihre Benutzeroberfläche ist, es wäre besser, wenn es weniger davon gäbe.
+
+### Struktur {#structure}
+
+- Tokens links oder Tokens rechts
+- 2 oder 3 Reihen
+- Details über oder unter der Schaltfläche
+- Details erweitert, minimiert oder nicht angezeigt
+
+### Komponentenstil {#component-style}
+
+- leer
+- umrandet
+- gefüllt
+
+Aus reiner UX-Sicht ist der UI-Stil weniger wichtig, als Sie denken. Visuelle Trends kommen und gehen in Zyklen, und viele Vorlieben sind subjektiv.
+
+Der einfachste Weg, ein Gefühl dafür zu bekommen – und über die verschiedenen Konfigurationen nachzudenken – ist, sich einige Beispiele anzusehen und dann selbst ein wenig zu experimentieren.
+
+Das enthaltene Figma-Kit enthält leere, umrandete und gefüllte Komponenten.
+
+Schauen Sie sich die folgenden Beispiele an, um verschiedene Möglichkeiten zu sehen, wie Sie alles zusammensetzen können:
+
+
+
+
+
+
+
+
+
+
+
+
+
+## Aber auf welche Seite sollte der Token? {#but-which-side-should-the-token-go-on}
+
+Das Fazit ist, dass es wahrscheinlich keinen großen Unterschied für die Benutzerfreundlichkeit macht. Es gibt jedoch ein paar Dinge zu beachten, die Sie in die eine oder andere Richtung beeinflussen könnten.
+
+Es war mäßig interessant zu sehen, wie sich die Mode im Laufe der Zeit verändert hat. Uniswap hatte den Token anfangs auf der linken Seite, hat ihn aber inzwischen auf die rechte Seite verschoben. Sushiswap hat diese Änderung ebenfalls während eines Design-Upgrades vorgenommen. Die meisten, aber nicht alle Protokolle sind diesem Beispiel gefolgt.
+
+Finanzielle Konventionen setzen traditionell das Währungssymbol vor die Zahl, z. B. $50, €50, £50, aber wir _sagen_ 50 Dollar, 50 Euro, 50 Pfund.
+
+Für den allgemeinen Benutzer – insbesondere für jemanden, der von links nach rechts und von oben nach unten liest – fühlt sich der Token auf der rechten Seite wahrscheinlich natürlicher an.
+
+
+
+Den Token auf die linke Seite und alle Zahlen auf die rechte Seite zu setzen, sieht angenehm symmetrisch aus, was ein Pluspunkt ist, aber es gibt einen weiteren Nachteil bei diesem Layout.
+
+Das Gesetz der Nähe besagt, dass Elemente, die nahe beieinander liegen, als zusammengehörig wahrgenommen werden. Dementsprechend wollen wir zusammengehörige Elemente nebeneinander platzieren. Das Token-Guthaben ist direkt mit dem Token selbst verbunden und ändert sich, wann immer ein neuer Token ausgewählt wird. Es ist daher etwas sinnvoller, das Token-Guthaben neben der Token-Auswahlschaltfläche zu platzieren. Es könnte unter den Token verschoben werden, aber das bricht die Symmetrie des Layouts.
+
+Letztendlich gibt es für beide Optionen Vor- und Nachteile, aber es ist interessant, wie der Trend zum Token auf der rechten Seite zu gehen scheint.
+
+## Verhalten der Schaltfläche {#button-behavior}
+
+Haben Sie keine separate Schaltfläche für „Genehmigen“. Haben Sie auch keinen separaten Klick für „Genehmigen“. Der Benutzer möchte tauschen, also sagen Sie einfach „Tauschen“ auf der Schaltfläche und initiieren Sie die Genehmigung als ersten Schritt. Ein Modal kann den Fortschritt mit einem Stepper oder einer einfachen „Tx 1 von 2 – genehmigt“-Benachrichtigung anzeigen.
+
+
+
+
+
+### Schaltfläche als kontextbezogene Hilfe {#button-as-contextual-help}
+
+Die Schaltfläche kann auch als Warnung dienen!
+
+Dies ist eigentlich ein ziemlich ungewöhnliches Designmuster außerhalb von Web3, hat sich aber darin zum Standard entwickelt. Dies ist eine gute Innovation, da sie Platz spart und die Aufmerksamkeit fokussiert hält.
+
+Wenn die Hauptaktion – TAUSCHEN – aufgrund eines Fehlers nicht verfügbar ist, kann der Grund mit der Schaltfläche erklärt werden, z. B.:
+
+- Netzwerk wechseln
+- Wallet verbinden
+- verschiedene Fehler
+
+Die Schaltfläche kann auch **der auszuführenden Aktion zugeordnet werden**. Wenn der Benutzer zum Beispiel nicht tauschen kann, weil er sich im falschen Netzwerk befindet, sollte auf der Schaltfläche „Zu Ethereum wechseln“ stehen, und wenn der Benutzer auf die Schaltfläche klickt, sollte das Netzwerk auf Ethereum umgeschaltet werden. Dies beschleunigt den Benutzerfluss erheblich.
+
+
+
+
+
+## Erstellen Sie Ihre eigene mit dieser Figma-Datei {#build-your-own-with-this-figma-file}
+
+Dank der harten Arbeit mehrerer Protokolle hat sich das DEX-Design stark verbessert. Wir wissen, welche Informationen der Benutzer benötigt, wie wir sie anzeigen sollten und wie wir den Ablauf so reibungslos wie möglich gestalten können.
+Hoffentlich bietet dieser Artikel einen soliden Überblick über die UX-Prinzipien.
+
+Wenn Sie experimentieren möchten, können Sie gerne das Figma-Wireframe-Kit verwenden. Es ist so einfach wie möglich gehalten, bietet aber genügend Flexibilität, um die Grundstruktur auf verschiedene Weisen aufzubauen.
+
+[Figma Wireframe-Kit](https://www.figma.com/community/file/1393606680816807382/dex-wireframes-kit)
+
+DeFi wird sich weiterentwickeln, und es gibt immer Raum für Verbesserungen.
+
+Viel Erfolg!
diff --git a/public/content/translations/de/developers/docs/design-and-ux/heuristics-for-web3/index.md b/public/content/translations/de/developers/docs/design-and-ux/heuristics-for-web3/index.md
new file mode 100644
index 00000000000..3b8a508b5d5
--- /dev/null
+++ b/public/content/translations/de/developers/docs/design-and-ux/heuristics-for-web3/index.md
@@ -0,0 +1,138 @@
+---
+title: 7 Heuristiken für das Design von Web3-Schnittstellen
+description: Grundsätze zur Verbesserung der Benutzerfreundlichkeit von Web3
+lang: de
+---
+
+Benutzerfreundlichkeits-Heuristiken sind allgemeine „Faustregeln“, mit denen Sie die Benutzerfreundlichkeit Ihrer Website messen können.
+Die 7 Heuristiken hier sind speziell auf Web3 zugeschnitten und sollten zusammen mit Jakob Nielsens [10 allgemeinen Prinzipien für Interaktionsdesign](https://www.nngroup.com/articles/ten-usability-heuristics/) verwendet werden.
+
+## Sieben Benutzerfreundlichkeits-Heuristiken für Web3 {#seven-usability-heuristics-for-web3}
+
+1. Feedback folgt der Aktion
+2. Sicherheit und Vertrauen
+3. Die wichtigsten Informationen sind offensichtlich
+4. Verständliche Terminologie
+5. Aktionen sind so kurz wie möglich
+6. Netzwerkverbindungen sind sichtbar und flexibel
+7. Steuerung über die App, nicht über die Wallet
+
+## Definitionen und Beispiele {#definitions-and-examples}
+
+### 1. Feedback folgt der Aktion {#feedback-follows-action}
+
+**Es sollte offensichtlich sein, wenn etwas passiert ist oder gerade passiert.**
+
+Benutzer entscheiden über ihre nächsten Schritte auf der Grundlage des Ergebnisses ihrer vorherigen Schritte. Daher ist es wichtig, dass sie über den Systemstatus informiert bleiben. Dies ist in Web3 besonders wichtig, da Transaktionen manchmal eine kurze Zeit benötigen, um in die Blockchain aufgenommen zu werden. Wenn es kein Feedback gibt, das sie zum Warten auffordert, sind sich die Benutzer unsicher, ob etwas passiert ist.
+
+**Tipps:**
+
+- Informieren Sie den Benutzer über Nachrichten, Benachrichtigungen und andere Warnungen.
+- Kommunizieren Sie Wartezeiten klar und deutlich.
+- Wenn eine Aktion länger als ein paar Sekunden dauert, beruhigen Sie den Benutzer mit einem Timer oder einer Animation, damit er das Gefühl hat, dass etwas passiert.
+- Wenn ein Prozess aus mehreren Schritten besteht, zeigen Sie jeden Schritt an.
+
+**Beispiel:**
+Wenn Sie jeden Schritt einer Transaktion anzeigen, wissen die Benutzer, wo sie sich im Prozess befinden. Geeignete Symbole informieren den Benutzer über den Status seiner Aktionen.
+
+
+
+### 2. Sicherheit und Vertrauen sind fest verankert {#security-and-trust-are-backed-in}
+
+Sicherheit sollte Priorität haben, und dies sollte für den Benutzer hervorgehoben werden.
+Die Menschen legen großen Wert auf ihre Daten. Sicherheit ist für Benutzer oft ein Hauptanliegen und sollte daher auf allen Ebenen des Designs berücksichtigt werden. Sie sollten immer versuchen, das Vertrauen Ihrer Benutzer zu gewinnen, aber die Art und Weise, wie Sie dies tun, kann in verschiedenen Apps unterschiedliche Dinge bedeuten. Es sollte kein nachträglicher Gedanke sein, sondern durchgehend bewusst gestaltet werden. Bauen Sie Vertrauen in der gesamten Benutzererfahrung auf, einschließlich der sozialen Kanäle und der Dokumentation sowie der endgültigen Benutzeroberfläche. Faktoren wie der Grad der Dezentralisierung, der Multi-Sig-Status des Treasury und ob das Team gedoxxt ist, beeinflussen das Vertrauen der Benutzer.
+
+**Tipps:**
+
+- Listen Sie Ihre Audits mit Stolz auf
+- Holen Sie sich mehrere Audits
+- Bewerben Sie alle von Ihnen entworfenen Sicherheitsfunktionen
+- Heben Sie mögliche Risiken hervor, einschließlich der zugrunde liegenden Integrationen
+- Kommunizieren Sie die Komplexität von Strategien
+- Berücksichtigen Sie Probleme, die nicht die Benutzeroberfläche betreffen und die Sicherheitswahrnehmung Ihrer Benutzer beeinträchtigen könnten
+
+**Beispiel:**
+Fügen Sie Ihre Audits in der Fußzeile in einer gut sichtbaren Größe ein.
+
+
+
+### 3. Die wichtigsten Informationen sind offensichtlich {#the-most-important-info-is-obvious}
+
+Zeigen Sie bei komplexen Systemen nur die relevantesten Daten an. Bestimmen Sie, was am wichtigsten ist, und priorisieren Sie dessen Anzeige.
+Zu viele Informationen sind überwältigend, und Benutzer orientieren sich bei Entscheidungen in der Regel an einer einzigen Information. In DeFi sind dies wahrscheinlich der APR bei Rendite-Apps und der LTV bei Kredit-Apps.
+
+**Tipps:**
+
+- Benutzerforschung wird die wichtigste Metrik aufdecken
+- Machen Sie die wichtigsten Informationen groß und die anderen Details klein und unauffällig
+- Menschen lesen nicht, sie scannen; stellen Sie sicher, dass Ihr Design scanbar ist
+
+**Beispiel:** Große, vollfarbige Tokens sind beim Scannen leicht zu finden. Der APR ist groß und in einer Akzentfarbe hervorgehoben.
+
+
+
+### 4. Klare Terminologie {#clear-terminology}
+
+Die Terminologie sollte verständlich und angemessen sein.
+Technischer Jargon kann eine große Hürde sein, da er die Konstruktion eines völlig neuen mentalen Modells erfordert. Benutzer können das Design nicht mit Wörtern, Phrasen und Konzepten in Beziehung setzen, die sie bereits kennen. Alles wirkt verwirrend und ungewohnt, und es gibt eine steile Lernkurve, bevor sie überhaupt versuchen können, es zu benutzen. Ein Benutzer könnte sich DeFi nähern, um etwas Geld zu sparen, und was er findet, ist: Mining, Farming, Staking, Emissionen, Bribes, Vaults, Lockers, veTokens, Vesting, Epochen, dezentrale Algorithmen, protokolleigene Liquidität…
+Versuchen Sie, einfache Begriffe zu verwenden, die von der breitmöglichsten Gruppe von Menschen verstanden werden. Erfinden Sie keine brandneuen Begriffe nur für Ihr Projekt.
+
+**Tipps:**
+
+- Verwenden Sie eine einfache und konsistente Terminologie
+- Verwenden Sie so weit wie möglich die bestehende Sprache
+- Erfinden Sie keine eigenen Begriffe
+- Folgen Sie den Konventionen, sobald sie erscheinen
+- Klären Sie die Benutzer so gut wie möglich auf
+
+**Beispiel:**
+„Ihre Belohnungen“ ist ein weithin verstandener, neutraler Begriff; kein neues Wort, das für dieses Projekt erfunden wurde. Die Belohnungen werden in USD angegeben, um den mentalen Modellen der realen Welt zu entsprechen, auch wenn die Belohnungen selbst in einem anderen Token sind.
+
+
+
+### 5. Aktionen sind so kurz wie möglich {#actions-are-as-short-as-possible}
+
+Beschleunigen Sie die Interaktionen des Benutzers durch die Gruppierung von Teilaktionen.
+Dies kann sowohl auf der Smart-Contract-Ebene als auch auf der Benutzeroberfläche erfolgen. Der Benutzer sollte nicht von einem Teil des Systems zu einem anderen wechseln – oder das System ganz verlassen – müssen, um eine übliche Aktion abzuschließen.
+
+**Tipps:**
+
+- Kombinieren Sie „Approve“ nach Möglichkeit mit anderen Aktionen
+- Bündeln Sie die Signierschritte so nah wie möglich
+
+**Beispiel:** Die Kombination von „Liquidität hinzufügen“ und „Staken“ ist ein einfaches Beispiel für einen Beschleuniger, der einem Benutzer sowohl Zeit als auch Gas spart.
+
+
+
+### 6. Netzwerkverbindungen sind sichtbar und flexibel {#network-connections-are-visible-and-flexible}
+
+Informieren Sie den Benutzer darüber, mit welchem Netzwerk er verbunden ist, und stellen Sie klare Verknüpfungen zum Wechseln des Netzwerks bereit.
+Dies ist bei Multichain-Apps besonders wichtig. Die Hauptfunktionen der App sollten auch dann sichtbar sein, wenn die Verbindung getrennt ist oder eine Verbindung zu einem nicht unterstützten Netzwerk besteht.
+
+**Tipps:**
+
+- Zeigen Sie so viel wie möglich von der App an, während die Verbindung getrennt ist
+- Zeigen Sie an, mit welchem Netzwerk der Benutzer aktuell verbunden ist
+- Zwingen Sie den Benutzer nicht, zur Wallet zu gehen, um das Netzwerk zu wechseln
+- Wenn die App vom Benutzer einen Netzwerkwechsel verlangt, fordern Sie die Aktion vom Haupt-Call-to-Action aus an
+- Wenn die App Märkte oder Vaults für mehrere Netzwerke enthält, geben Sie deutlich an, welches Set sich der Benutzer gerade ansieht
+
+**Beispiel:** Zeigen Sie dem Benutzer in der App-Leiste an, mit welchem Netzwerk er verbunden ist, und ermöglichen Sie ihm, es zu ändern.
+
+
+
+### 7. Steuerung über die App, nicht über die Wallet {#control-from-the-app-not-the-wallet}
+
+Die Benutzeroberfläche sollte dem Benutzer alles mitteilen, was er wissen muss, und ihm die Kontrolle über alles geben, was er tun muss.
+In Web3 gibt es Aktionen, die Sie in der Benutzeroberfläche durchführen, und Aktionen, die Sie in der Wallet durchführen. Im Allgemeinen leiten Sie eine Aktion in der Benutzeroberfläche ein und bestätigen sie dann in der Wallet. Benutzer können sich unwohl fühlen, wenn diese beiden Stränge nicht sorgfältig integriert sind.
+
+**Tipps:**
+
+- Kommunizieren Sie den Systemstatus über Feedback in der Benutzeroberfläche
+- Führen Sie eine Aufzeichnung ihres Verlaufs
+- Stellen Sie Links zu Block-Explorern für alte Transaktionen bereit
+- Stellen Sie Verknüpfungen zum Wechseln von Netzwerken bereit.
+
+**Beispiel:** Ein dezenter Container zeigt dem Benutzer, welche relevanten Tokens er in seiner Wallet hat, und der Haupt-CTA bietet eine Verknüpfung zum Wechseln des Netzwerks.
+
+
diff --git a/public/content/translations/de/developers/docs/design-and-ux/index.md b/public/content/translations/de/developers/docs/design-and-ux/index.md
new file mode 100644
index 00000000000..ff950149d1a
--- /dev/null
+++ b/public/content/translations/de/developers/docs/design-and-ux/index.md
@@ -0,0 +1,86 @@
+---
+title: Design und UX in Web3
+description: Einführung in UX-Design und -Forschung im Web3-Bereich und Ethereum
+lang: de
+---
+
+Sind Sie neu in der Entwicklung mit Ethereum? Dann sind Sie hier an der richtigen Stelle. Die Ethereum-Community hat Ressourcen verfasst, um Sie in die Grundlagen des Web3-Designs und research einzuführen. Sie lernen Kernkonzepte kennen, die sich von anderen App-Designs, die Sie kennen, unterscheiden können.
+
+Benötigen Sie zunächst ein grundlegendes Verständnis von web3? Schauen Sie sich den [**Lern-Hub**](/learn/) an.
+
+## Beginnen Sie mit der Nutzerforschung {#start-with-user-research}
+
+Effektives Design geht über die Gestaltung visuell ansprechender Benutzeroberflächen hinaus. Es geht darum, ein tiefes Verständnis für die Bedürfnisse, Ziele und treibenden Faktoren des Benutzers zu erlangen. Daher empfehlen wir allen Designern dringend, einen Designprozess wie den [**Double-Diamond-Prozess**](https://en.wikipedia.org/wiki/Double_Diamond_\(design_process_model\)) zu übernehmen, um sicherzustellen, dass ihre Arbeit überlegt und zielgerichtet ist.
+
+- [Web3 braucht mehr UX-Forscher und -Designer](https://blog.akasha.org/akasha-conversations-9-web3-needs-more-ux-researchers-and-designers) – Ein Überblick über die aktuelle Designreife
+- [Eine einfache Anleitung zur UX-Forschung in Web3](https://uxplanet.org/a-complete-guide-to-ux-research-for-web-3-0-products-d6bead20ebb1) – Einfache Anleitung zur Durchführung von Forschung
+- [Wie man UX-Entscheidungen in Web3 angeht](https://archive.devcon.org/archive/watch/6/data-empathy-how-to-approach-ux-decisions-in-web3/) – Ein kurzer Überblick über quantitative und qualitative Forschung und die Unterschiede zwischen beiden (Video, 6 Min.)
+- [UX-Forscher in Web3 sein](https://medium.com/@georgia.rakusen/what-its-like-being-a-user-researcher-in-web3-6a4bcc096849) – Eine persönliche Sichtweise darauf, wie es ist, ein UX-Forscher in Web3 zu sein
+
+## Forschungsstudien in Web3 {#research-in-web3}
+
+Dies ist eine umfassende Liste von Studien zu user research, die in Web3 durchgeführt wurden. Sie helfen bei Design- und Produktentscheidungen oder können als Inspiration für die Durchführung eigener Studien dienen.
+
+| Schwerpunktbereich | Name |
+| :------------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Krypto-Onboarding | [The Reown Pulse 2024: Crypto Consumer Sentiment & Usage](https://reown.com/blog/unveiling-walletconnects-consumer-crypto-report) |
+| Krypto-Onboarding | [CRADL: UX in Kryptowährung](https://docs.google.com/presentation/d/1s2OPSH5sMJzxRYaJSSRTe8W2iIoZx0PseIV-WeZWD1s/edit?usp=sharing) |
+| Krypto-Onboarding | [CRADL: Onboarding zur Kryptowährung](https://docs.google.com/presentation/d/1R9nFuzA-R6SxaGCKhoMbE4Vxe0JxQSTiHXind3LVq_w/edit?usp=sharing) |
+| Krypto-Onboarding | [Bitcoin-UX-Bericht](https://github.com/patestevao/BitcoinUX-report/blob/master/report.md) |
+| Krypto-Onboarding | [ConSensys: The State of Web3 perception around the world 2023](https://consensys.io/insight-report/web3-and-crypto-global-survey-2023) |
+| Krypto-Onboarding | [NEAR: Accelerating the journey towards adoption](https://drive.google.com/file/d/1VuaQP4QSaQxR5ddQKTMGI0b0rWdP7uGn/view) |
+| Staking | [OpenUX: Rocket Pool Node Operator UX](https://storage.googleapis.com/rocketpool/RocketPool-NodeOperator-UX-Report-Jan-2024.pdf) |
+| Staking | [Staking: Key trends, takeaways, and predictions - Eth Staker](https://lookerstudio.google.com/u/0/reporting/cafcee00-e1af-4148-bae8-442a88ac75fa/page/p_ja2srdhh2c?s=hmbTWDh9hJo) |
+| Staking | [Multi-App-Staking](https://github.com/threshold-network/UX-User-Research/blob/main/Multi-App%20Staking%20\(MAS\)/iterative-user-study/MAS%20Iterative%20User%20Study.pdf) |
+| DAO | [2022 DAO Research Update: What do DAO Builders Need?](https://blog.aragon.org/2022-dao-research-update/) |
+| DeFi | [Absicherungs-Pools](https://github.com/threshold-network/UX-User-Research/tree/main/Keep%20Coverage%20Pool) |
+| DeFi | [ConSensys: DeFi User Research Report 2022](https://cdn2.hubspot.net/hubfs/4795067/ConsenSys%20Codefi-Defi%20User%20ResearchReport.pdf) |
+| Metaverse | [Metaverse: Nutzerforschungsbericht](https://www.politico.com/f/?id=00000187-7685-d820-a7e7-7e85d1420000) |
+| Metaverse | [Going on Safari: Researching Users in the Metaverse](https://archive.devcon.org/archive/watch/6/going-on-safari-researching-users-in-the-metaverse/?tab=YouTube) (Video, 27 Min.) |
+
+## Design für Web3 {#design-for-web3}
+
+- [Web3 UX-Design-Handbuch](https://web3ux.design/) – Praktische Anleitung zum Entwerfen von Web3-Apps
+- [Web3-Designprinzipien](https://medium.com/@lyricalpolymath/web3-design-principles-f21db2f240c1) – Ein Framework mit UX-Regeln für Blockchain-basierte Dapps
+- [Blockchain-Designprinzipien](https://medium.com/design-ibm/blockchain-design-principles-599c5c067b6e) – Erkenntnisse des Blockchain-Designteams bei IBM
+- [Neueux.com](https://neueux.com/apps) – UI-Bibliothek mit Nutzerflüssen mit vielfältigen Filteroptionen
+- [Web3's Usability Crisis: What You NEED to Know!](https://www.youtube.com/watch?v=oBSXT_6YDzg) – Eine Podiumsdiskussion über die Fallstricke bei der entwicklerfokussierten Projekterstellung (Video, 34 Min.)
+
+## Erste Schritte {#getting-started}
+
+- [Heuristiken für Web3](/developers/docs/design-and-ux/heuristics-for-web3/) – 7 Heuristiken für das Web3-Interface-Design
+- [DEX-Design Best Practices](/developers/docs/design-and-ux/dex-design-best-practice/) – Eine Anleitung zum Entwerfen dezentraler Börsen
+
+## Web3-Design-Fallstudien {#design-case-studies}
+
+- [Deep Work Studio](https://www.deepwork.studio/case-studies)
+- [Ein NFT auf OpenSea verkaufen](https://builtformars.com/case-studies/opensea)
+- [Wallet-UX-Analyse: Wie sich Wallets ändern müssen](https://www.youtube.com/watch?v=oTpuxYj8JWI&ab_channel=ETHDenver) (Video, 20 Min.)
+
+## Design-Bounties {#bounties}
+
+- [Dework](https://app.dework.xyz/bounties)
+- [Buildbox-Hackathons](https://app.buidlbox.io/)
+- [ETHGlobal-Hackathons](https://ethglobal.com/)
+
+## Design-DAOs und -Communitys {#design-daos-and-communities}
+
+Engagieren Sie sich in beruflich orientierten Community-Organisationen oder treten Sie Designgruppen bei, um mit anderen Mitgliedern über Design- und Forschungsthemen und -trends zu diskutieren.
+
+- [Vectordao.com](https://vectordao.com/)
+- [Deepwork.studio](https://www.deepwork.studio/)
+- [We3.co](https://we3.co/)
+- [Openux.xyz](https://openux.xyz/)
+
+## Designsysteme und andere Design-Ressourcen {#design-systems-and-resources}
+
+- [Optimism Design](https://www.figma.com/@optimism) (Figma)
+- [Ethereum.org Designsystem](https://www.figma.com/@ethdotorg) (Figma)
+- [Finity, ein Designsystem von Polygon](https://www.figma.com/community/file/1073921725197233598/finity-design-system) (Figma)
+- [Kleros Designsystem](https://www.figma.com/community/file/999852250110186964/kleros-design-system) (Figma)
+- [Safe Designsystem](https://www.figma.com/community/file/1337417127407098506/safe-design-system) (Figma)
+- [ENS Designsystem](https://thorin.ens.domains/)
+- [Mirror Designsystem](https://degen-xyz.vercel.app/)
+
+**Auf dieser Seite aufgeführte Artikel und Projekte sind keine offiziellen Empfehlungen** und dienen nur zu Informationszwecken.
+Wir fügen Links zu dieser Seite auf der Grundlage von Kriterien in unserer [Auflistungsrichtlinie](/contributing/design/adding-design-resources) hinzu. Wenn Sie möchten, dass wir ein Projekt/einen Artikel hinzufügen, bearbeiten Sie diese Seite auf [GitHub](https://github.com/ethereum/ethereum-org-website/blob/dev/public/content/developers/docs/design-and-ux/index.md).
diff --git a/public/content/translations/de/developers/docs/development-networks/index.md b/public/content/translations/de/developers/docs/development-networks/index.md
index a651178cd46..ef9ea6ac8cc 100644
--- a/public/content/translations/de/developers/docs/development-networks/index.md
+++ b/public/content/translations/de/developers/docs/development-networks/index.md
@@ -18,39 +18,37 @@ Entwicklungsnetzwerke sind im Wesentlichen Ethereum-Kunden (Implementierungen vo
**Warum nicht einfach einen Ethereum-Knoten lokal betreiben?**
-Sie _könnten_ [einen Knoten betreiben](/developers/docs/nodes-and-clients/#running-your-own-node), da jedoch Entwicklungsnetzwerke speziell für die Entwicklung erstellt werden, sind sie oft mit praktischen Funktionen ausgestattet wie:
+Sie _könnten_ einen [Node](/developers/docs/nodes-and-clients/#running-your-own-node) betreiben, aber da Entwicklungsnetzwerke speziell für die Entwicklung konzipiert sind, sind sie oft mit praktischen Funktionen ausgestattet, wie z. B.:
-- Seeding deterministisch mit Daten für die lokale Blockchain durchführen (z. B. Konten mit ETH-Guthaben)
+- Deterministisches Seeding Ihrer lokalen Blockchain mit Daten (z. B. Konten mit ETH-Guthaben)
- Sofortige Erzeugung von Blöcken mit jeder empfangenen Transaktion, in der richtigen Reihenfolge und ohne Verzögerung
- Verbesserte Debugging- und Protokollierungsfunktionen
## Verfügbare Tools {#available-projects}
-**Hinweis**: Die meisten [Entwicklerframeworks](/developers/docs/frameworks/) enthalten ein integriertes Entwicklungsnetzwerk. Wir empfehlen Ihnen, mit einem Framework für die Einrichtung [Ihrer lokalen Entwicklungsumgebung](/developers/local-environment/) zu beginnen.
+**Hinweis**: Die meisten [Entwicklungsframeworks](/developers/docs/frameworks/) enthalten ein integriertes Entwicklungsnetzwerk. Wir empfehlen Ihnen, mit einem Framework zu beginnen, um Ihre [lokale Entwicklungsumgebung einzurichten](/developers/local-environment/).
-### Hardhat Network {#hardhat-network}
+### Hardhat-Netzwerk {#hardhat-network}
Ein lokales Ethereum-Netzwerk, das für die Entwicklung konzipiert ist. Die können darin Ihre Contracts bereitstellen, Tests durchführen und Ihren Code debuggen.
Hardhat Network beinhaltet Hardhat, eine Ethereum-Entwicklungsumgebung für Profis.
- [Website](https://hardhat.org/)
-- [GitHub](https://github.com/nomiclabs/hardhat)
+- [GitHub](https://github.com/NomicFoundation/hardhat)
### Lokale Beacon Chains {#local-beacon-chains}
Einige Konsensclients verfügen über integrierte Tools, um lokale Beacon Chains zu Testzwecken zu erstellen. Anleitungen für Lighthouse, Nimbus und Lodestar sind verfügbar:
-- [Lokales Testnetz unter Verwendung von Lodestar](https://chainsafe.github.io/lodestar/contribution/advanced-topics/setting-up-a-testnet#post-merge-local-testnet/)
-- [Lokales Testnetz unter Verwendung von Lighthouse](https://lighthouse-book.sigmaprime.io/setup.html#local-testnets)
+- [Lokales Testnet mit Lodestar](https://chainsafe.github.io/lodestar/contribution/advanced-topics/setting-up-a-testnet#post-merge-local-testnet/)
+- [Lokales Testnet mit Lighthouse](https://lighthouse-book.sigmaprime.io/setup.html#local-testnets)
-### Öffentliche Ethereum Test-Chains {#public-beacon-testchains}
+### Öffentliche Ethereum-Testchains {#public-beacon-testchains}
-Es gibt auch zwei öffentliche Testimplementierungen von Ethereum: Sepolia und Hoodi. Sepolia ist das empfohlene Standard-Testnetz für die Anwendungsentwicklung, mit einem geschlossenen Validatorsatz für schnelle Synchronisation. Hoodi ist ein Testnetz für Validierung und Staking, das einen offenen Validatorsatz verwendet und es potenziell jedem ermöglicht, zu validieren.
+Es gibt auch zwei gewartete öffentliche Testimplementierungen von Ethereum: Sepolia und Hoodi. Die empfohlene Testnet-Version mit Langzeitunterstützung ist **Hoodi**, auf der jeder frei validieren kann. Sepolia nutzt einen Validatoren-Satz mit Genehmigung, was bedeutet, dass es auf diesem Testnet keinen allgemeinen Zugang für neue Validatoren gibt.
-- [Hoodi Staking Launchpad](https://hoodi.launchpad.ethereum.org/en/)
-- [Sepolia Website](https://sepolia.dev/)
-- [Hoodi Website](https://hoodi.ethpandaops.io/)
+- [Hoodi Staking Launchpad](https://hoodi.launchpad.ethereum.org/)
### Kurtosis Ethereum-Paket {#kurtosis}
@@ -58,12 +56,12 @@ Kurtosis ist ein Build-System für Multi-Container-Testumgebungen, das es Entwic
Das Ethereum-Kurtosis-Paket kann verwendet werden, um schnell ein parameterisierbares, hochskalierbares und privates Ethereum-Testnetz über Docker oder Kubernetes einzurichten. Das Paket unterstützt alle wichtigen Clients der Ausführungs- und Konsensebene. Kurtosis verwaltet gekonnt alle lokalen Portzuweisungen und Dienstverbindungen für ein repräsentatives Netzwerk, das in Validierungs- und Test-Workflows im Zusammenhang mit der Ethereum-Kerninfrastruktur verwendet wird.
-- [Ethereum Netzwerk-Paket](https://github.com/kurtosis-tech/ethereum-package)
+- [Ethereum-Netzwerkpaket](https://github.com/kurtosis-tech/ethereum-package)
- [Website](https://www.kurtosis.com/)
- [GitHub](https://github.com/kurtosis-tech/kurtosis)
- [Dokumentation](https://docs.kurtosis.com/)
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
_Sie kennen Community-Resourcen die Ihnen geholfen haben? Bearbeiten Sie diese Seite und fügen Sie sie hinzu!_
diff --git a/public/content/translations/de/developers/docs/ethereum-stack/index.md b/public/content/translations/de/developers/docs/ethereum-stack/index.md
index 2d5c5a715a1..b40a1e9533f 100644
--- a/public/content/translations/de/developers/docs/ethereum-stack/index.md
+++ b/public/content/translations/de/developers/docs/ethereum-stack/index.md
@@ -8,13 +8,13 @@ Wie bei jedem Software-Stack variiert der komplette "Ethereum-Stack" zielabhäng
Es gibt jedoch zentrale Komponenten von Ethereum, die dabei helfen, ein gedankliches Modell für die Interaktion von Softwareanwendungen mit der Ethereum-Blockchain bereitzustellen. Wenn Sie die Ebenen des Stacks verstehen, ist es einfacher, die unterschiedlichen Möglichkeiten für die Integration von Ethereum in Softwareprojekte zu verstehen.
-## Ebene 1: Ethereum-Virtual Machine {#ethereum-virtual-machine}
+## Ebene 1: Ethereum Virtual Machine {#ethereum-virtual-machine}
-Die [Ethereum Virtual Machine (EVM)](/developers/docs/evm/) ist die Laufzeitumgebung für Smart Contracts in Ethereum. Alle Smart Contracts und Statusänderungen auf der Ethereum-Blockchain erfolgen über [Transaktionen](/developers/docs/transactions/). Die EVM übernimmt die gesamte Transaktionsabwicklung im Ethereum-Netzwerk.
+Die [Ethereum Virtual Machine (EVM)](/developers/docs/evm/) ist die Laufzeitumgebung für Smart Contracts auf Ethereum. Alle Smart Contracts und Zustandsänderungen auf der Ethereum-Blockchain werden durch [Transaktionen](/developers/docs/transactions/) ausgeführt. Die EVM übernimmt die gesamte Transaktionsabwicklung im Ethereum-Netzwerk.
-Wie bei jeder virtuellen Maschine erzeugt die EVM einen Abstraktionsgrad zwischen dem ausführenden Code und der ausführenden Maschine (einem Ethereum-Node). Derzeit läuft die EVM auf Tausenden von Knoten auf der ganzen Welt.
+Wie bei jeder virtuellen Maschine erzeugt die EVM einen Abstraktionsgrad zwischen dem ausführenden Code und der ausführenden Maschine (einem Ethereum-Node). Derzeit läuft die EVM auf Tausenden von Knoten, die weltweit verteilt sind.
-Unter der Haube verwendet die EVM eine Reihe von Opcode-Anweisungen, um bestimmte Aufgaben auszuführen. Diese (140 einmaligen) Opcodes erlauben es der EVM [Turing-komplett](https://en.wikipedia.org/wiki/Turing_completeness) zu sein, was bedeutet, dass die EVM in der Lage ist, fast alles zu berechnen, wenn man genügend Ressourcen hat.
+Unter der Haube verwendet die EVM eine Reihe von Opcode-Anweisungen, um bestimmte Aufgaben auszuführen. Diese (140 einzigartigen) Opcodes ermöglichen es der EVM, [Turing-vollständig](https://en.wikipedia.org/wiki/Turing_completeness) zu sein, was bedeutet, dass die EVM bei ausreichenden Ressourcen in der Lage ist, so gut wie alles zu berechnen.
Als dApp-Entwickler müssen Sie über die EVM nicht mehr wissen, als dass sie existiert und sie alle Anwendungen auf Ethereum zuverlässig ohne Ausfallzeiten betreibt.
@@ -22,9 +22,9 @@ Als dApp-Entwickler müssen Sie über die EVM nicht mehr wissen, als dass sie ex
[Smart Contracts](/developers/docs/smart-contracts/) sind die ausführbaren Programme, die auf der Ethereum-Blockchain laufen.
-Smart Contracts werden unter Verwendung bestimmter [Programmiersprachen](/developers/docs/smart-contracts/languages/) geschrieben, die in EVM Bytecode kompiliert werden (Low-Level-Maschinenbefehle, Opcodes genannt).
+Smart Contracts werden in spezifischen [Programmiersprachen](/developers/docs/smart-contracts/languages/) geschrieben, die zu EVM-Bytecode (Maschinenbefehle auf niedriger Ebene, sogenannte Opcodes) kompiliert werden.
-Smart Contracts dienen nicht nur als Open-Source-Bibliotheken, sondern sind im Wesentlichen offene API-Dienste, die rund um die Uhr laufen und nicht aufgehoben werden können. Smart Contracts stellen öffentliche Funktionen zur Verfügung, mit denen Nutzer und Anwendungen ([dApps](/developers/docs/dapps/)) interagieren können, ohne dass eine Berechtigung dafür erforderlich ist. Jede Anwendung kann sich in die bereitgestellten Smart Contracts integrieren, um Funktionen zusammenzustellen, wie z. B. das Hinzufügen von [Daten-Feeds](/developers/docs/oracles/) oder die Unterstützung von Token-Swaps. Zudem kann jeder neue Smart Contracts für Ethereum bereitstellen, um maßgeschneiderte Funktionen für die Anforderungen der eigenen Anwendung zu schaffen.
+Smart Contracts dienen nicht nur als Open-Source-Bibliotheken, sondern sind im Wesentlichen offene API-Dienste, die rund um die Uhr laufen und nicht aufgehoben werden können. Smart Contracts stellen öffentliche Funktionen zur Verfügung, mit denen Benutzer und Anwendungen ([Dapps](/developers/docs/dapps/)) ohne Genehmigung interagieren können. Jede Anwendung kann in bereitgestellte Smart Contracts integriert werden, um Funktionalitäten zusammenzustellen, wie z. B. das Hinzufügen von [Daten-Feeds](/developers/docs/oracles/) oder die Unterstützung von Token-Swaps. Zudem kann jeder neue Smart Contracts für Ethereum bereitstellen, um maßgeschneiderte Funktionen für die Anforderungen der eigenen Anwendung zu schaffen.
Als dApp-Entwickler müssen Sie Smart Contracts nur dann schreiben, wenn Sie benutzerdefinierte Funktionen zur Ethereum-Blockchain hinzufügen möchten. Sie werden feststellen, dass sich die meisten oder alle Bedürfnisse Ihres Projekts durch die Integration von bestehenden Smart Contracts erfüllen lassen, zum Beispiel wenn Sie Zahlungen in Stablecoins unterstützen oder den dezentralen Austausch von Tokens ermöglichen möchten.
@@ -40,9 +40,9 @@ Indem Sie Ihre Anwendung mit einem Ethereum-Node verbinden (über die [JSON-RPC-
Viele komfortable Bibliotheken (die von der Open-Source-Community von Ethereum erstellt und verwaltet werden) ermöglichen es Ihren Anwendern, sich mit der Ethereum-Blockchain zu verbinden und mit ihr zu kommunizieren.
-Wenn Ihre benutzerseitige Anwendung eine Web-App ist, können Sie auch eine entsprechende [JavaScript-API](/developers/docs/apis/javascript/) direkt in Ihr Frontend `installieren`. Oder Sie verwenden eine [Python](/developers/docs/programming-languages/python/)- oder [Java](/developers/docs/programming-languages/java/)-API, um diese Funktionalität serverseitig zu implementieren.
+Wenn Ihre Endbenutzer-Anwendung eine Web-App ist, können Sie eine [JavaScript-API](/developers/docs/apis/javascript/) mit `npm install` direkt in Ihr Frontend installieren. Oder Sie entscheiden sich vielleicht dafür, diese Funktionalität serverseitig zu implementieren und eine API für [Python](/developers/docs/programming-languages/python/) oder [Java](/developers/docs/programming-languages/java/) zu verwenden.
-Obwohl diese APIs kein notwendiger Bestandteil des Stacks sind, gestalten sie die direkte Interaktion mit einem Ethereum-Node wesentlich einfacher. Zudem bieten sie Dienstprogrammfunktionen (z. B. Umwandlung von ETH zu GWei), so dass Sie als Entwickler weniger Zeit damit verbringen, Probleme mit Ethereum-Clients zu lösen, und sich auf die konkreten Funktionen Ihrer Anwendung konzentrieren können.
+Obwohl diese APIs kein notwendiger Bestandteil des Stacks sind, gestalten sie die direkte Interaktion mit einem Ethereum-Node wesentlich einfacher. Sie bieten auch Hilfsfunktionen (z. B. die Umrechnung von ETH in Gwei), sodass Sie als Entwickler weniger Zeit mit den Feinheiten von Ethereum-Clients verbringen und sich mehr auf die anwendungsspezifische Funktionalität konzentrieren können.
## Ebene 5: Endbenutzeranwendungen {#end-user-applications}
@@ -52,10 +52,10 @@ Die Art und Weise, wie Sie diese Benutzeroberflächen entwickeln, bleibt im Wese
## Bereit, Ihren Stack zu wählen? {#ready-to-choose-your-stack}
-Machen Sie sich mit unserem Leitfaden vertraut, um [eine lokale Entwicklungsumgebung für Ihre Ethereum-Anwendung aufzusetzen](/developers/local-environment/).
+Lesen Sie unseren Leitfaden zum [Einrichten einer lokalen Entwicklungsumgebung](/developers/local-environment/) für Ihre Ethereum-Anwendung.
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
-- [Die Architektur einer Web 3.0-Anwendung](https://www.preethikasireddy.com/post/the-architecture-of-a-web-3-0-application) – _Preethi Kasireddy_
+- [Die Architektur einer Web 3.0-Anwendung](https://www.preethikasireddy.com/post/the-architecture-of-a-web-3-0-application) - _Preethi Kasireddy_
-_Kennen Sie eine Community Ressource, die Ihnen geholfen hat? Bearbeiten Sie diese Seite und fügen Sie sie hinzu._
+_Sie kennen Community-Resourcen die Ihnen geholfen haben? Bearbeiten Sie diese Seite und fügen Sie sie hinzu!_
diff --git a/public/content/translations/de/developers/docs/evm/index.md b/public/content/translations/de/developers/docs/evm/index.md
index bb357fd24ff..e9dec99b553 100644
--- a/public/content/translations/de/developers/docs/evm/index.md
+++ b/public/content/translations/de/developers/docs/evm/index.md
@@ -1,77 +1,87 @@
---
-title: Ethereum Virtual Machine (EVM)
+title: Ethereum Virtuelle Maschine (EVM)
description: Eine Einführung in die virtuelle Maschine von Ethereum und wie sie sich auf Zustand, Transaktionen und Smart Contracts bezieht.
lang: de
---
-Die Ethereum Virtual Machine (EVM) ist eine dezentrale virtuelle Umgebung, die Code konsistent und sicher auf allen Ethereum-Knoten ausführt. Knoten führen die EVM aus, um Smart Contracts auszuführen, wobei sie "[Gas](/gas/)" verwenden, um den für [Operationen](/developers/docs/evm/opcodes/) erforderlichen Rechenaufwand zu messen, wodurch eine effiziente Ressourcenzuweisung und Netzwerksicherheit gewährleistet werden.
+Die Ethereum Virtual Machine (EVM) ist eine dezentrale virtuelle Umgebung, die Code konsistent und sicher auf allen Ethereum-Knoten ausführt. Knoten führen die EVM aus, um Smart Contracts auszuführen, wobei sie "[Gas](/developers/docs/gas/)" verwenden, um den für [Operationen](/developers/docs/evm/opcodes/) erforderlichen Rechenaufwand zu messen, wodurch eine effiziente Ressourcenzuweisung und Netzwerksicherheit gewährleistet werden.
## Voraussetzungen {#prerequisites}
-Um den EVM zu verstehen, sind ein paar grundlegende Kenntnisse der gängigen Informatikterminologie wie [Bytes](https://wikipedia.org/wiki/Byte), [Speicher](https://wikipedia.org/wiki/Computer_memory) und [Stack](https://wikipedia.org/wiki/Stack_(abstract_data_type)) notwendig. Es wäre auch hilfreich, wenn Sie sich mit Kryptografie-/Blockchain-Konzepten wie [Hash-Funktionen](https://wikipedia.org/wiki/Cryptographic_hash_function) und dem [Merkle-Baum](https://wikipedia.org/wiki/Merkle_tree) auskennen.
+Einige grundlegende Kenntnisse der gängigen Terminologie der Informatik wie [Bytes](https://wikipedia.org/wiki/Byte), [Speicher](https://wikipedia.org/wiki/Computer_memory) und ein [Stack](https://wikipedia.org/wiki/Stack_\(abstract_data_type\)) sind notwendig, um die EVM zu verstehen. Es wäre auch hilfreich, mit Kryptographie-/Blockchain-Konzepten wie [Hash-Funktionen](https://wikipedia.org/wiki/Cryptographic_hash_function) und dem [Merkle-Baum](https://wikipedia.org/wiki/Merkle_tree) vertraut zu sein.
-## Vom Ledger zur Zustandsmaschine {#from-ledger-to-state-machine}
+## Vom Hauptbuch zur Zustandsmaschine {#from-ledger-to-state-machine}
Die Analogie eines 'verteilten Schalters' wird oft verwendet, um Blockchains wie Bitcoin zu beschreiben, die eine dezentrale Währung mit grundlegenden Tools der Kryptographie ermöglichen. Der Ledger führt eine Aufzeichnung von Aktivitäten, die sich an eine Reihe von Regeln halten müssen, die wiederum bestimmen, welche Aktionen erfolgen bzw. nicht erfolgen können, um den Ledger zu verändern. Zum Beispiel kann eine Bitcoin-Adresse nicht mehr Bitcoin ausgeben, als sie zuvor erhalten hat. Diese Regeln untermauern alle Transaktionen auf Bitcoin und vielen anderen Blockchains.
-Während Ethereum seine eigene native Kryptowährung (Ether) hat, die fast genau den gleichen intuitiven Regeln folgt, ermöglicht es auch eine wesentlich leistungsfähigere Funktion: [Smart Contracts](/developers/docs/smart-contracts/). Für diese komplexere Funktion ist eine ausgeklügeltere Analogie erforderlich. Anstelle eines verteilten Ledgers ist Ethereum eine verteilte [Zustandsmaschine](https://wikipedia.org/wiki/Finite-state_machine). Ethereums Zustand ist eine große Datenstruktur, die nicht nur alle Konten und Kontostände enthält, sondern einen _Maschinenzustand_, der nach einer vordefinierten Reihe von Regeln von Block zu Block wechselt und beliebigen Maschinencode ausführen kann. Die spezifischen Regeln für das Ändern des Zustands von Block zu Block werden vom EVM definiert.
+Während Ethereum seine eigene native Kryptowährung (Ether) hat, die fast genau den gleichen intuitiven Regeln folgt, ermöglicht es auch eine viel mächtigere Funktion: [Smart Contracts](/developers/docs/smart-contracts/). Für diese komplexere Funktion ist eine ausgeklügeltere Analogie erforderlich. Anstelle eines verteilten Hauptbuchs ist Ethereum eine verteilte [Zustandsmaschine](https://wikipedia.org/wiki/Finite-state_machine). Der Zustand von Ethereum ist eine große Datenstruktur, die nicht nur alle Konten und Guthaben enthält, sondern auch einen _Maschinenzustand_, der sich von Block zu Block nach einem vordefinierten Satz von Regeln ändern kann und der beliebigen Maschinencode ausführen kann. Die spezifischen Regeln für das Ändern des Zustands von Block zu Block werden vom EVM definiert.
- _Diagramm angepasst von [Ethereum EVM illustriert](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+
+_Diagramm adaptiert von [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
-## Ethereum-Zustandsübergangsfunktion {#the-ethereum-state-transition-function}
+## Die Ethereum-Zustandsübergangsfunktion {#the-ethereum-state-transition-function}
-Die EVM verhält sich wie eine mathematische Funktion: Mit einer Eingabe, erzeugt sie eine deterministische Ausgabe. Folglich ist es sehr hilfreich, Ethereum formaler als eine **Zustandsübergangsfunktion** enthaltend zu beschreiben:
+Die EVM verhält sich wie eine mathematische Funktion: Mit einer Eingabe, erzeugt sie eine deterministische Ausgabe. Daher ist es sehr hilfreich, Ethereum formeller als etwas zu beschreiben, das über eine **Zustandsübergangsfunktion** verfügt:
```
Y(S, T)= S'
```
-Bei einem alten gültigen Zustand `(S)` und einem neuen Satz gültiger Transaktionen `(T)` erzeugt die Ethereum-Statusübergangsfunktion `Y(S, T)` einen neuen gültigen Ausgabezustand `S'`.
+Bei einem alten gültigen Zustand `(S)` und einem neuen Satz gültiger Transaktionen `(T)` erzeugt die Ethereum-Zustandsübergangsfunktion `Y(S, T)` einen neuen gültigen Ausgabezustand `S'`
### Zustand {#state}
-Im Rahmen von Ethereum ist der Zustand eine enorme Datenstruktur, die [ modifizierte Merkle-Patricia-Trie](/developers/docs/data-structures-and-encoding/patricia-merkle-trie/) genannt wird, die alle [Konten](/developers/docs/accounts/) durch Hashes verbunden hält und mit einem einzigen Stamm-Hash in der Blockchain abrufbar ist.
+Im Kontext von Ethereum ist der Zustand eine riesige Datenstruktur, die als [modifizierter Merkle-Patricia-Trie](/developers/docs/data-structures-and-encoding/patricia-merkle-trie/) bezeichnet wird. Sie hält alle [Konten](/developers/docs/accounts/), die durch Hashes verknüpft sind, und ist auf einen einzigen Root-Hash reduzierbar, der auf der Blockchain gespeichert ist.
### Transaktionen {#transactions}
Transaktionen sind kryptographisch signierte Anweisungen von Konten. Es gibt zwei Arten von Transaktionen: solche, die zu Nachrichtenanrufen führen, und solche, die zur Erstellung von Verträgen führen.
-Die Erstellung von Verträgen führt zur Erstellung eines neuen Vertragskontos mit zusammengestelltem [Smart-Contract](/developers/docs/smart-contracts/anatomy/)-Bytecode. Immer wenn ein anderes Konto einen Nachrichtenaufruf an diesen Vertrag stellt, führt es seinen Bytecode aus.
+Die Vertragserstellung führt zur Erstellung eines neuen Vertragskontos, das kompilierten [Smart-Contract](/developers/docs/smart-contracts/anatomy/)-Bytecode enthält. Immer wenn ein anderes Konto einen Nachrichtenaufruf an diesen Vertrag stellt, führt es seinen Bytecode aus.
## EVM-Anweisungen {#evm-instructions}
-Die EVM wird als [Stackmaschine](https://wikipedia.org/wiki/Stack_machine) mit einer Tiefe von 1024 Artikeln ausgeführt. Jedes Element ist ein 256-Bit-Wort, das für die einfache Verwendung mit 256-Bit-Kryptographie (wie Keccak-256-Hashes oder secp256k1-Signaturen) gewählt wurde.
+Die EVM wird als [Stack-Maschine](https://wikipedia.org/wiki/Stack_machine) mit einer Tiefe von 1024 Elementen ausgeführt. Jedes Element ist ein 256-Bit-Wort, das für die einfache Verwendung mit 256-Bit-Kryptographie (wie Keccak-256-Hashes oder secp256k1-Signaturen) gewählt wurde.
-Während der Ausführung behält die EVM einen transienten _-Speicher_ (als wortadressiertes Byte-Array), der zwischen Transaktionen nicht vorhanden ist.
+Während der Ausführung unterhält die EVM einen transienten _Speicher_ (als wortadressiertes Byte-Array), der zwischen den Transaktionen nicht persistent ist.
-Verträge enthalten jedoch eine Merkle-Patricia_-Speicher_-Trie (als wortadressierbares Wort-Array), mit der das betreffende Konto und ein Teil des globalen Zustands verbunden sind.
+### Transienter Speicher
-Kompilierter Smart-Contract-Bytecode wird als eine Anzahl von EVM-[Opcodes ausgeführt](/developers/docs/evm/opcodes), die standardmäßige Stackoperationen wie `XOR`, `UND`, `ADD`, `SUB` etc. ausführen. Die EVM implementiert auch eine Reihe von Blockchain-spezifischen Stack-Operationen, wie `ADDRESS`, `BALANCE`, `BLOCKHASH` usw.
+Der transiente Speicher ist ein Schlüssel-Wert-Speicher pro Transaktion, auf den über die Opcodes `TSTORE` und `TLOAD` zugegriffen wird. Er bleibt über alle internen Aufrufe innerhalb derselben Transaktion bestehen, wird aber am Ende der Transaktion gelöscht. Im Gegensatz zum Speicher wird der transiente Speicher als Teil des EVM-Zustands und nicht als Teil des Ausführungsrahmens modelliert, aber er wird nicht in den globalen Zustand übernommen. Der transiente Speicher ermöglicht eine gas-effiziente, temporäre Zustandsfreigabe über interne Aufrufe während einer Transaktion hinweg.
- _Diagramm angepasst von [Ethereum EVM illustriert](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+### Speicherort
+
+Verträge enthalten einen Merkle-Patricia-_Speicher_-Trie (als wortadressierbares Wort-Array), der mit dem betreffenden Konto verknüpft und Teil des globalen Zustands ist. Dieser persistente Speicher unterscheidet sich vom transienten Speicher, der nur für die Dauer einer einzigen Transaktion verfügbar ist und nicht Teil des persistenten Speicher-Tries des Kontos ist.
+
+### Operationscodes
+
+Kompilierter Smart-Contract-Bytecode wird als eine Reihe von EVM-[Opcodes](/developers/docs/evm/opcodes) ausgeführt, die Standard-Stack-Operationen wie `XOR`, `AND`, `ADD`, `SUB` usw. durchführen. Die EVM implementiert auch eine Reihe von Blockchain-spezifischen Stack-Operationen, wie z. B. `ADDRESS`, `BALANCE`, `BLOCKHASH`, usw. Das Opcode-Set enthält auch `TSTORE` und `TLOAD`, die den Zugriff auf den transienten Speicher ermöglichen.
+
+
+_Diagramme adaptiert von [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
## EVM-Implementierungen {#evm-implementations}
Alle Implementierungen der EVM müssen sich nach der im Yellowpaper von Ethereum beschriebenen Spezifikation richten.
-Während der siebenjährigen Geschichte von Ethereum hat die EVM mehrere Revisionen durchlaufen. Zudem gibt es mehrere Implementierungen der EVM in verschiedenen Programmiersprachen.
+In der zehnjährigen Geschichte von Ethereum wurde die EVM mehrfach überarbeitet, und es gibt mehrere Implementierungen der EVM in verschiedenen Programmiersprachen.
-[Ethereum-Ausführungs-Clients](/developers/docs/nodes-and-clients/#execution-clients) enthalten eine EVM-Implementierung. Zusätzlich gibt es mehrere eigenständige Implementierungen, einschließlich:
+[Ethereum-Ausführungs-Clients](/developers/docs/nodes-and-clients/#execution-clients) beinhalten eine EVM-Implementierung. Zusätzlich gibt es mehrere eigenständige Implementierungen, einschließlich:
- [Py-EVM](https://github.com/ethereum/py-evm) - _Python_
- [evmone](https://github.com/ethereum/evmone) - _C++_
- [ethereumjs-vm](https://github.com/ethereumjs/ethereumjs-vm) - _JavaScript_
-- [revm](https://github.com/bluealloy/revm) – _Rust_
+- [revm](https://github.com/bluealloy/revm) - _Rust_
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
- [Ethereum Yellowpaper](https://ethereum.github.io/yellowpaper/paper.pdf)
- [Jellopaper aka KEVM: Semantics of EVM in K](https://jellopaper.org/)
- [The Beigepaper](https://github.com/chronaeon/beigepaper)
-- [Opcodes der virtuellen Maschine von Ethereum](https://www.ethervm.io/)
-- [Betriebscodes für die Referenzdokumente für die virtuelle Ethereum-Maschine](https://www.evm.codes/)
-- [Eine kurze Einführung in die Dokumentation von Solidity](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html#index-6)
-- [Ethereum meistern – Die Ethereum Virtual Machine](https://github.com/ethereumbook/ethereumbook/blob/openedition/13evm.asciidoc)
+- [Opcodes der Ethereum Virtual Machine](https://www.ethervm.io/)
+- [Interaktive Referenz der Opcodes der Ethereum Virtual Machine](https://www.evm.codes/)
+- [Eine kurze Einführung in der Solidity-Dokumentation](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html#index-6)
+- [Mastering Ethereum – Die Ethereum Virtual Machine](https://github.com/ethereumbook/ethereumbook/blob/openedition/13evm.asciidoc)
## Verwandte Themen {#related-topics}
diff --git a/public/content/translations/de/developers/docs/evm/opcodes/index.md b/public/content/translations/de/developers/docs/evm/opcodes/index.md
index 467c273bd2c..a59b15c4543 100644
--- a/public/content/translations/de/developers/docs/evm/opcodes/index.md
+++ b/public/content/translations/de/developers/docs/evm/opcodes/index.md
@@ -4,171 +4,174 @@ description: Eine Liste aller verfügbaren Opcodes für die virtuelle Ethereum-M
lang: de
---
-## Übersicht {#overview}
+## Überblick {#overview}
-Das ist eine aktualisierte Version der EVM-Referenzseite unter [wolflo/evm-opcodes](https://github.com/wolflo/evm-opcodes). Auch aus dem [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf), dem [Jello Paper](https://jellopaper.org/evm/), und der [Geth](https://github.com/ethereum/go-ethereum)-Implementierung. Das soll eine zugängliche Referenz sein, aber sie ist nicht besonders streng. Wenn Sie sich sicher sein wollen, und Kenntnis von jedem Sonderfall haben benötigen, ist es ratsam, das Jello Paper oder eine Client-Implementierung zu verwenden.
+Dies ist eine aktualisierte Version der EVM-Referenzseite auf [wolflo/evm-opcodes](https://github.com/wolflo/evm-opcodes).
+Auch aus dem [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf), dem [Jello Paper](https://jellopaper.org/evm/) und der [geth](https://github.com/ethereum/go-ethereum)-Implementierung entnommen.
+Das soll eine zugängliche Referenz sein, aber sie ist nicht besonders streng.
+Wenn Sie sich sicher sein wollen, und Kenntnis von jedem Sonderfall haben benötigen, ist es ratsam, das Jello Paper oder eine Client-Implementierung zu verwenden.
-Suchen Sie nach einer interaktiven Referenz? Sehen Sie sich [evm.codes](https://www.evm.codes/) an.
+Suchen Sie nach einer interaktiven Referenz? Besuchen Sie [evm.codes](https://www.evm.codes/).
Für Operationen mit dynamischen Gaskosten, siehe [gas.md](https://github.com/wolflo/evm-opcodes/blob/main/gas.md).
-💡 Kurztipp: Um ganze Zeilen einzusehen, verwenden Sie `[shift] + scroll`, um horizontal auf dem Desktop zu scrollen.
+💡 Schneller Tipp: Um ganze Zeilen anzuzeigen, verwenden Sie `[shift] + scroll`, um auf dem Desktop horizontal zu scrollen.
-| Stack | Name | Gas | Anfangs-Stack | Ergebnis-Stack | Speicher | Anmerkungen |
-|:-----:|:-------------- |:-----------------------------------------------------------------------------------------------:|:------------------------------------------------ |:-------------------------------------------- |:----------------------------------------------------------------------------- |:--------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| 00 | STOP | 0 | | | | halt execution |
-| 01 | ADD | 3 | `a, b` | `a + b` | | (u)int256 addition modulo 2\*\*256 |
-| 02 | MUL | 5 | `a, b` | `a * b` | | (u)int256 multiplication modulo 2\*\*256 |
-| 03 | SUB | 3 | `a, b` | `a - b` | | (u)int256 addition modulo 2\*\*256 |
-| 04 | DIV | 5 | `a, b` | `a // b` | | uint256 division |
-| 05 | SDIV | 5 | `a, b` | `a // b` | | int256 division |
-| 06 | MOD | 5 | `a, b` | `a % b` | | uint256 modulus |
-| 07 | SMOD | 5 | `a, b` | `a % b` | | int256 modulus |
-| 08 | ADDMOD | 8 | `a, b, N` | `(a + b) % N` | | (u)int256 addition modulo N |
-| 09 | MULMOD | 8 | `a, b, N` | `(a * b) % N` | | (u)int256 multiplication modulo N |
-| 0A | EXP | [A1](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a1-exp) | `a, b` | `a ** b` | | uint256 exponentiation modulo 2\*\*256 |
-| 0B | SIGNEXTEND | 5 | `b, x` | `SIGNEXTEND(x, b)` | | [sign extend](https://wikipedia.org/wiki/Sign_extension) `x` from `(b+1)` bytes to 32 bytes |
-| 0C-0F | _invalid_ | | | | | |
-| 10 | LT | 3 | `a, b` | `a < b` | | uint256 less-than |
-| 11 | GT | 3 | `a, b` | `a > b` | | uint256 greater-than |
-| 12 | SLT | 3 | `a, b` | `a < b` | | int256 less-than |
-| 13 | SGT | 3 | `a, b` | `a > b` | | int256 greater-than |
-| 14 | EQ | 3 | `a, b` | `a == b` | | (u)int256 equality |
-| 15 | ISZERO | 3 | `a` | `a == 0` | | (u)int256 iszero |
-| 16 | AND | 3 | `a, b` | `a && b` | | bitwise AND |
-| 17 | OR | 3 | `a, b` | `a \|\| b` | | bitwise OR |
-| 18 | XOR | 3 | `a, b` | `a ^ b` | | bitwise XOR |
-| 19 | NOT | 3 | `a` | `~a` | | bitwise NOT |
-| 1A | BYTE | 3 | `i, x` | `(x >> (248 - i * 8)) && 0xFF` | | `i`th byte of (u)int256 `x`, from the left |
-| 1B | SHL | 3 | `shift, val` | `val << shift` | | shift left |
-| 1C | SHR | 3 | `shift, val` | `val >> shift` | | logical shift right |
-| 1D | SAR | 3 | `shift, val` | `val >> shift` | | arithmetic shift right |
-| 1E-1F | _invalid_ | | | | | |
-| 20 | KECCAK256 | [A2](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a2-sha3) | `ost, len` | `keccak256(mem[ost:ost+len-1])` | | keccak256 |
-| 21-2F | _invalid_ | | | | | |
-| 30 | ADDRESS | 2 | `.` | `address(this)` | | address of executing contract |
-| 31 | BALANCE | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr` | `addr.balance` | | balance, in wei |
-| 32 | ORIGIN | 2 | `.` | `tx.origin` | | address that originated the tx |
-| 33 | CALLER | 2 | `.` | `msg.sender` | | address of msg sender |
-| 34 | CALLVALUE | 2 | `.` | `msg.value` | | msg value, in wei |
-| 35 | CALLDATALOAD | 3 | `idx` | `msg.data[idx:idx+32]` | | read word from msg data at index `idx` |
-| 36 | CALLDATASIZE | 2 | `.` | `len(msg.data)` | | length of msg data, in bytes |
-| 37 | CALLDATACOPY | [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations) | `dstOst, ost, len` | `.` | mem[dstOst:dstOst+len-1] := msg.data[ost:ost+len-1] | copy msg data |
-| 38 | CODESIZE | 2 | `.` | `len(this.code)` | | length of executing contract's code, in bytes |
-| 39 | CODECOPY | [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations) | `dstOst, ost, len` | `.` | | mem[dstOst:dstOst+len-1] := this.code[ost:ost+len-1] | copy executing contract's bytecode |
-| 3A | GASPRICE | 2 | `.` | `tx.gasprice` | | gas price of tx, in wei per unit gas [\*\*](https://eips.ethereum.org/EIPS/eip-1559#gasprice) |
-| 3B | EXTCODESIZE | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr` | `len(addr.code)` | | size of code at addr, in bytes |
-| 3C | EXTCODECOPY | [A4](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a4-extcodecopy) | `addr, dstOst, ost, len` | `.` | mem[dstOst:dstOst+len-1] := addr.code[ost:ost+len-1] | copy code from `addr` |
-| 3D | RETURNDATASIZE | 2 | `.` | `size` | | size of returned data from last external call, in bytes |
-| 3E | RETURNDATACOPY | [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations) | `dstOst, ost, len` | `.` | mem[dstOst:dstOst+len-1] := returndata[ost:ost+len-1] | copy returned data from last external call |
-| 3F | EXTCODEHASH | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr` | `Hash` | | hash = addr.exists ? keccak256(addr.code) : 0 |
-| 40 | BLOCKHASH | 20 | `blockNum` | `blockHash(blockNum)` | | |
-| 41 | COINBASE | 2 | `.` | `block.coinbase` | | Adresse des Proposers für den aktuellen Block |
-| 42 | TIMESTAMP | 2 | `.` | `block.timestamp` | | timestamp of current block |
-| 43 | NUMBER | 2 | `.` | `block.number` | | number of current block |
-| 44 | PREVRANDAO | 2 | `.` | `randomness beacon` | | randomness beacon |
-| 45 | GASLIMIT | 2 | `.` | `block.gaslimit` | | gas limit of current block |
-| 46 | CHAINID | 2 | `.` | `chain_id` | | push current [chain id](https://eips.ethereum.org/EIPS/eip-155) onto stack |
-| 47 | SELFBALANCE | 5 | `.` | `address(this).balance` | | balance of executing contract, in wei |
-| 48 | BASEFEE | 2 | `.` | `block.basefee` | | base fee of current block |
-| 49 | BLOBHASH | 3 | `idx` | `tx.blob_versioned_hashes[idx]` | | [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844) |
-| 4A | BLOBBASEFEE | 2 | `.` | `block.blobbasefee` | | Blob-Basisgebühr des aktuellen Blocks ([EIP-7516](https://eips.ethereum.org/EIPS/eip-7516)) |
-| 4B-4F | _invalid_ | | | | | |
-| 50 | POP | 2 | `_anon` | `.` | | remove item from top of stack and discard it |
-| 51 | MLOAD | 3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost` | `mem[ost:ost+32]` | | read word from memory at offset `ost` |
-| 52 | MSTORE | 3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, val` | `.` | mem[ost:ost+32] := val | write a word to memory |
-| 53 | MSTORE8 | 3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, val` | `.` | mem[ost] := val && 0xFF | write a single byte to memory |
-| 54 | SLOAD | [A6](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a6-sload) | `key` | `storage[key]` | | read word from storage |
-| 55 | SSTORE | [A7](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a7-sstore) | `key, val` | `.` | storage[key] := val | write word to storage |
-| 56 | JUMP | 8 | `dst` | `.` | | `$pc := dst` mark that `pc` is only assigned if `dst` is a valid jumpdest |
-| 57 | JUMPI | 10 | `dst, condition` | `.` | | `$pc := condition ? dst : $pc + 1` |
-| 58 | PC | 2 | `.` | `$pc` | | program counter |
-| 59 | MSIZE | 2 | `.` | `len(mem)` | | size of memory in current execution context, in bytes |
-| 5A | GAS | 2 | `.` | `gasRemaining` | | |
-| 5B | JUMPDEST | 1 | | | mark valid jump destination | a valid jump destination for example a jump destination not inside the push data |
-| 5C | TLOAD | 100 | `key` | `tstorage[key]` | | read word from transient storage ([EIP-1153](https://eips.ethereum.org/EIPS/eip-1153)) |
-| 5D | TSTORE | 100 | `key, val` | `.` | tstorage[key] := val | write word to transient storage ([EIP-1153](https://eips.ethereum.org/EIPS/eip-1153)) |
-| 5E | MCOPY | 3+3\*words+[A0](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `dstOst, ost, len` | `.` | mem[dstOst] := mem[ost:ost+len] | copy memory from one area to another ([EIP-5656](https://eips.ethereum.org/EIPS/eip-5656)) |
-| 5F | PUSH0 | 2 | `.` | `uint8` | | Bringen Sie den konstanten Wert 0 in den Stack ein |
-| 60 | PUSH1 | 3 | `.` | `uint8` | | push 1-byte value onto stack |
-| 61 | PUSH2 | 3 | `.` | `uint16` | | push 2-byte value onto stack |
-| 62 | PUSH3 | 3 | `.` | `uint24` | | push 3-byte value onto stack |
-| 63 | PUSH4 | 3 | `.` | `uint32` | | push 4-byte value onto stack |
-| 64 | PUSH5 | 3 | `.` | `uint40` | | push 5-byte value onto stack |
-| 65 | PUSH6 | 3 | `.` | `uint48` | | push 6-byte value onto stack |
-| 66 | PUSH7 | 3 | `.` | `uint56` | | push 7-byte value onto stack |
-| 67 | PUSH8 | 3 | `.` | `uint64` | | push 8-byte value onto stack |
-| 68 | PUSH9 | 3 | `.` | `uint72` | | push 9-byte value onto stack |
-| 69 | PUSH10 | 3 | `.` | `uint80` | | push 10-byte value onto stack |
-| 6A | PUSH11 | 3 | `.` | `uint88` | | push 11-byte value onto stack |
-| 6B | PUSH12 | 3 | `.` | `uint96` | | push 12-byte value onto stack |
-| 6C | PUSH13 | 3 | `.` | `uint104` | | push 13-byte value onto stack |
-| 6D | PUSH14 | 3 | `.` | `uint112` | | push 14-byte value onto stack |
-| 6E | PUSH15 | 3 | `.` | `uint120` | | push 15-byte value onto stack |
-| 6F | PUSH16 | 3 | `.` | `uint128` | | push 16-byte value onto stack |
-| 70 | PUSH17 | 3 | `.` | `uint136` | | push 17-byte value onto stack |
-| 71 | PUSH18 | 3 | `.` | `uint144` | | push 18-byte value onto stack |
-| 72 | PUSH19 | 3 | `.` | `uint152` | | push 19-byte value onto stack |
-| 73 | PUSH20 | 3 | `.` | `uint160` | | push 20-byte value onto stack |
-| 74 | PUSH21 | 3 | `.` | `uint168` | | push 21-byte value onto stack |
-| 75 | PUSH22 | 3 | `.` | `uint176` | | push 22-byte value onto stack |
-| 76 | PUSH23 | 3 | `.` | `uint184` | | push 23-byte value onto stack |
-| 77 | PUSH24 | 3 | `.` | `uint192` | | push 24-byte value onto stack |
-| 78 | PUSH25 | 3 | `.` | `uint200` | | push 25-byte value onto stack |
-| 79 | PUSH26 | 3 | `.` | `uint208` | | push 26-byte value onto stack |
-| 7A | PUSH27 | 3 | `.` | `uint216` | | push 27-byte value onto stack |
-| 7B | PUSH28 | 3 | `.` | `uint224` | | push 28-byte value onto stack |
-| 7C | PUSH29 | 3 | `.` | `uint232` | | push 29-byte value onto stack |
-| 7D | PUSH30 | 3 | `.` | `uint240` | | push 30-byte value onto stack |
-| 7E | PUSH31 | 3 | `.` | `uint248` | | push 31-byte value onto stack |
-| 7F | PUSH32 | 3 | `.` | `uint256` | | push 32-byte value onto stack |
-| 80 | DUP1 | 3 | `a` | `a, a` | | clone 1st value on stack |
-| 81 | DUP2 | 3 | `_, a` | `a, _, a` | | clone 2nd value on stack |
-| 82 | DUP3 | 3 | `_, _, a` | `a, _, _, a` | | clone 3rd value on stack |
-| 83 | DUP4 | 3 | `_, _, _, a` | `a, _, _, _, a` | | clone 4th value on stack |
-| 84 | DUP5 | 3 | `..., a` | `a, ..., a` | | clone 5th value on stack |
-| 85 | DUP6 | 3 | `..., a` | `a, ..., a` | | clone 6th value on stack |
-| 86 | DUP7 | 3 | `..., a` | `a, ..., a` | | clone 7th value on stack |
-| 87 | DUP8 | 3 | `..., a` | `a, ..., a` | | clone 8th value on stack |
-| 88 | DUP9 | 3 | `..., a` | `a, ..., a` | | clone 9th value on stack |
-| 89 | DUP10 | 3 | `..., a` | `a, ..., a` | | clone 10th value on stack |
-| 8A | DUP11 | 3 | `..., a` | `a, ..., a` | | clone 11th value on stack |
-| 8B | DUP12 | 3 | `..., a` | `a, ..., a` | | clone 12th value on stack |
-| 8C | DUP13 | 3 | `..., a` | `a, ..., a` | | clone 13th value on stack |
-| 8D | DUP14 | 3 | `..., a` | `a, ..., a` | | clone 14th value on stack |
-| 8E | DUP15 | 3 | `..., a` | `a, ..., a` | | clone 15th value on stack |
-| 8F | DUP16 | 3 | `..., a` | `a, ..., a` | | clone 16th value on stack |
-| 90 | SWAP1 | 3 | `a, b` | `b, a` | | |
-| 91 | SWAP2 | 3 | `a, _, b` | `b, _, a` | | |
-| 92 | SWAP3 | 3 | `a, _, _, b` | `b, _, _, a` | | |
-| 93 | SWAP4 | 3 | `a, _, _, _, b` | `b, _, _, _, a` | | |
-| 94 | SWAP5 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 95 | SWAP6 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 96 | SWAP7 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 97 | SWAP8 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 98 | SWAP9 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 99 | SWAP10 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 9A | SWAP11 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 9B | SWAP12 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 9C | SWAP13 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 9D | SWAP14 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 9E | SWAP15 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 9F | SWAP16 | 3 | `a, ..., b` | `b, ..., a` | | |
-| A0 | LOG0 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len` | `.` | | LOG0(memory[ost:ost+len-1]) |
-| A1 | LOG1 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0` | `.` | | LOG1(memory[ost:ost+len-1], topic0) |
-| A2 | LOG2 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0, topic1` | `.` | | LOG2(memory[ost:ost+len-1], topic0, topic1) |
-| A3 | LOG3 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0, topic1, topic2` | `.` | | LOG3(memory[ost:ost+len-1], topic0, topic1, topic2) |
-| A4 | LOG4 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0, topic1, topic2, topic3` | `.` | | LOG4(memory[ost:ost+len-1], topic0, topic1, topic2, topic3) |
-| A5-EF | _invalid_ | | | | | |
-| F0 | CREATE | [A9](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a9-create-operations) | `val, ost, len` | `addr` | | addr = keccak256(rlp([address(this), this.nonce])) |
-| F1 | CALL | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | gas, addr, val, argOst, argLen, retOst, retLen | `success` | mem[retOst:retOst+retLen-1] := returndata | |
-| F2 | CALLCODE | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | `gas, addr, val, argOst, argLen, retOst, retLen` | `success` | mem[retOst:retOst+retLen-1] = returndata | same as DELEGATECALL, but does not propagate original msg.sender and msg.value |
-| F3 | RETURN | 0[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, len` | `.` | | return mem[ost:ost+len-1] |
-| F4 | DELEGATECALL | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | `gas, addr, argOst, argLen, retOst, retLen` | `success` | mem[retOst:retOst+retLen-1] := returndata | |
-| F5 | CREATE2 | [A9](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a9-create-operations) | `val, ost, len, salt` | `addr` | | addr = keccak256(0xff ++ address(this) ++ salt ++ keccak256(mem[ost:ost+len-1]))[12:] |
-| F6-F9 | _invalid_ | | | | | |
-| FA | STATICCALL | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | `gas, addr, argOst, argLen, retOst, retLen` | `success` | mem[retOst:retOst+retLen-1] := returndata | |
-| FB-FC | _invalid_ | | | | | |
-| FD | REVERT | 0[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, len` | `.` | | revert(mem[ost:ost+len-1]) |
-| FE | INVALID | [AF](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#af-invalid) | | | designated invalid opcode - [EIP-141](https://eips.ethereum.org/EIPS/eip-141) | |
-| FF | SELFDESTRUCT | [AB](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#ab-selfdestruct) | `addr` | `.` | | sendet alle ETH an `addr`; wenn es in derselben Transaktion ausgeführt wird, in der ein Vertrag erstellt wurde, zerstört es den Vertrag |
+| Stack | Name | Gas | Anfangs-Stack | Ergebnis-Stack | Speicher | Anmerkungen | |
+| :---: | :------------- | :---------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------ | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------- |
+| 00 | STOP | 0 | | | | Ausführung anhalten | |
+| 01 | ADD | 3 | `a, b` | `a + b` | | (u)int256 Addition Modulo 2\*\*256 | |
+| 02 | MUL | 5 | `a, b` | `a * b` | | (u)int256 Multiplikation Modulo 2\*\*256 | |
+| 03 | SUB | 3 | `a, b` | `a - b` | | (u)int256 Subtraktion Modulo 2\*\*256 | |
+| 04 | DIV | 5 | `a, b` | `a // b` | | uint256 Division | |
+| 05 | SDIV | 5 | `a, b` | `a // b` | | int256 Division | |
+| 06 | MOD | 5 | `a, b` | `a % b` | | uint256 Modulus | |
+| 07 | SMOD | 5 | `a, b` | `a % b` | | int256 Modulus | |
+| 08 | ADDMOD | 8 | `a, b, N` | `(a + b) % N` | | (u)int256 Addition Modulo N | |
+| 09 | MULMOD | 8 | `a, b, N` | `(a * b) % N` | | (u)int256 Multiplikation Modulo N | |
+| 0A | EXP | [A1](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a1-exp) | `a, b` | `a ** b` | | uint256 Potenzierung Modulo 2\*\*256 | |
+| 0B | SIGNEXTEND | 5 | `b, x` | `SIGNEXTEND(x, b)` | | [Vorzeichenerweiterung](https://de.wikipedia.org/wiki/Vorzeichenerweiterung) von `x` von `(b+1)` Bytes auf 32 Bytes | |
+| 0C-0F | _ungültig_ | | | | | | |
+| 10 | LT | 3 | `a, b` | `a < b` | | uint256 kleiner-als | |
+| 11 | GT | 3 | `a, b` | `a > b` | | uint256 größer-als | |
+| 12 | SLT | 3 | `a, b` | `a < b` | | int256 kleiner-als | |
+| 13 | SGT | 3 | `a, b` | `a > b` | | int256 größer-als | |
+| 14 | EQ | 3 | `a, b` | `a == b` | | (u)int256 Gleichheit | |
+| 15 | ISZERO | 3 | `a` | `a == 0` | | (u)int256 ist-Null | |
+| 16 | AND | 3 | `a, b` | `a && b` | | Bitweises UND | |
+| 17 | OR | 3 | `a, b` | `a \\|\\| b` | | Bitweises ODER | |
+| 18 | XOR | 3 | `a, b` | `a ^ b` | | Bitweises XOR | |
+| 19 | NOT | 3 | `a` | `~a` | | Bitweises NICHT | |
+| 1A | BYTE | 3 | `i, x` | `(x >> (248 - i * 8)) && 0xFF` | | `i`-tes Byte von (u)int256 `x`, von links | |
+| 1B | SHL | 3 | `shift, val` | `val << shift` | | Linksverschiebung | |
+| 1C | SHR | 3 | `shift, val` | `val >> shift` | | Logische Rechtsverschiebung | |
+| 1D | SAR | 3 | `shift, val` | `val >> shift` | | Arithmetische Rechtsverschiebung | |
+| 1E-1F | _ungültig_ | | | | | | |
+| 20 | KECCAK256 | [A2](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a2-sha3) | `ost, len` | `keccak256(mem[ost:ost+len-1])` | | keccak256 | |
+| 21-2F | _ungültig_ | | | | | | |
+| 30 | ADDRESS | 2 | `.` | `address(this)` | | Adresse des ausführenden Vertrags | |
+| 31 | BALANCE | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr` | `addr.balance` | | Guthaben, in Wei | |
+| 32 | ORIGIN | 2 | `.` | `tx.origin` | | Adresse, von der die Transaktion (tx) ausging | |
+| 33 | CALLER | 2 | `.` | `msg.sender` | | Adresse des Nachrichtenabsenders (msg) | |
+| 34 | CALLVALUE | 2 | `.` | `msg.value` | | Wert der Nachricht (msg) in Wei | |
+| 35 | CALLDATALOAD | 3 | `idx` | `msg.data[idx:idx+32]` | | Wort aus den Nachrichtendaten (msg) am Index `idx` lesen | |
+| 36 | CALLDATASIZE | 2 | `.` | `len(msg.data)` | | Länge der Nachrichtendaten (msg), in Bytes | |
+| 37 | CALLDATACOPY | [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations) | `dstOst, ost, len` | `.` | mem[dstOst:dstOst+len-1] := msg.data[ost:ost+len-1] | Nachrichtendaten (msg) kopieren | |
+| 38 | CODESIZE | 2 | `.` | `len(this.code)` | | Länge des Codes des ausführenden Vertrags, in Bytes | |
+| 39 | CODECOPY | [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations) | `dstOst, ost, len` | `.` | | mem[dstOst:dstOst+len-1] := this.code[ost:ost+len-1] | Bytecode des ausführenden Vertrags kopieren |
+| 3A | GASPRICE | 2 | `.` | `tx.gasprice` | | Gaspreis der Transaktion (tx), in Wei pro Gaseinheit [\*\*](https://eips.ethereum.org/EIPS/eip-1559#gasprice) | |
+| 3B | EXTCODESIZE | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr` | `len(addr.code)` | | Größe des Codes bei Adresse (addr), in Bytes | |
+| 3C | EXTCODECOPY | [A4](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a4-extcodecopy) | `addr, dstOst, ost, len` | `.` | mem[dstOst:dstOst+len-1] := addr.code[ost:ost+len-1] | Code von `addr` kopieren | |
+| 3D | RETURNDATASIZE | 2 | `.` | `size` | | Größe der zurückgegebenen Daten vom letzten externen Aufruf, in Bytes | |
+| 3E | RETURNDATACOPY | [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations) | `dstOst, ost, len` | `.` | mem[dstOst:dstOst+len-1] := returndata[ost:ost+len-1] | Zurückgegebene Daten vom letzten externen Aufruf kopieren | |
+| 3F | EXTCODEHASH | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr` | `hash` | | hash = addr.exists ? keccak256(addr.code) : 0 | |
+| 40 | BLOCKHASH | 20 | `blockNum` | `blockHash(blockNum)` | | | |
+| 41 | COINBASE | 2 | `.` | `block.coinbase` | | Adresse des Proposers für den aktuellen Block | |
+| 42 | TIMESTAMP | 2 | `.` | `block.timestamp` | | Zeitstempel des aktuellen Blocks | |
+| 43 | NUMBER | 2 | `.` | `block.number` | | Nummer des aktuellen Blocks | |
+| 44 | PREVRANDAO | 2 | `.` | `randomness beacon` | | Zufalls-Beacon | |
+| 45 | GASLIMIT | 2 | `.` | `block.gaslimit` | | Gaslimit des aktuellen Blocks | |
+| 46 | CHAINID | 2 | `.` | `chain_id` | | Aktuelle [Chain-ID](https://eips.ethereum.org/EIPS/eip-155) auf den Stack legen | |
+| 47 | SELFBALANCE | 5 | `.` | `address(this).balance` | | Guthaben des ausführenden Vertrags, in Wei | |
+| 48 | BASEFEE | 2 | `.` | `block.basefee` | | Grundgebühr des aktuellen Blocks | |
+| 49 | BLOBHASH | 3 | `idx` | `tx.blob_versioned_hashes[idx]` | | [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844) | |
+| 4A | BLOBBASEFEE | 2 | `.` | `block.blobbasefee` | | Blob-Grundgebühr des aktuellen Blocks ([EIP-7516](https://eips.ethereum.org/EIPS/eip-7516)) | |
+| 4B-4F | _ungültig_ | | | | | | |
+| 50 | POP | 2 | `_anon` | `.` | | Element von der Spitze des Stacks entfernen und verwerfen | |
+| 51 | MLOAD | 3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost` | `mem[ost:ost+32]` | | Wort aus dem Speicher am Offset `ost` lesen | |
+| 52 | MSTORE | 3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, val` | `.` | mem[ost:ost+32] := val | Ein Wort in den Speicher schreiben | |
+| 53 | MSTORE8 | 3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, val` | `.` | mem[ost] := val && 0xFF | Ein einzelnes Byte in den Speicher schreiben | |
+| 54 | SLOAD | [A6](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a6-sload) | `key` | `storage[key]` | | Wort aus dem Speicher lesen | |
+| 55 | SSTORE | [A7](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a7-sstore) | `key, val` | `.` | storage[key] := val | Wort in den Speicher schreiben | |
+| 56 | JUMP | 8 | `dst` | `.` | | `$pc := dst` markiert, dass `pc` nur zugewiesen wird, wenn `dst` ein gültiges Sprungziel ist | |
+| 57 | JUMPI | 10 | `dst, condition` | `.` | | `$pc := condition ?` dst : $pc + 1\` | |
+| 58 | PC | 2 | `.` | `$pc` | | Programm-Zähler | |
+| 59 | MSIZE | 2 | `.` | `len(mem)` | | Größe des Speichers im aktuellen Ausführungskontext, in Bytes | |
+| 5A | GAS | 2 | `.` | `gasRemaining` | | | |
+| 5B | JUMPDEST | 1 | | | Gültiges Sprungziel markieren | ein gültiges Sprungziel, z. B. ein Sprungziel, das nicht innerhalb der Push-Daten liegt | |
+| 5C | TLOAD | 100 | `key` | `tstorage[key]` | | Wort aus dem transienten Speicher lesen ([EIP-1153](https://eips.ethereum.org/EIPS/eip-1153)) | |
+| 5D | TSTORE | 100 | `key, val` | `.` | tstorage[key] := val | Wort in den transienten Speicher schreiben ([EIP-1153](https://eips.ethereum.org/EIPS/eip-1153)) | |
+| 5E | MCOPY | 3+3\*words+[A0](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `dstOst, ost, len` | `.` | mem[dstOst] := mem[ost:ost+len] | Speicher von einem Bereich in einen anderen kopieren ([EIP-5656](https://eips.ethereum.org/EIPS/eip-5656)) | |
+| 5F | PUSH0 | 2 | `.` | `uint8` | | Bringen Sie den konstanten Wert 0 in den Stack ein | |
+| 60 | PUSH1 | 3 | `.` | `uint8` | | 1-Byte-Wert auf den Stack legen | |
+| 61 | PUSH2 | 3 | `.` | `uint16` | | 2-Byte-Wert auf den Stack legen | |
+| 62 | PUSH3 | 3 | `.` | `uint24` | | 3-Byte-Wert auf den Stack legen | |
+| 63 | PUSH4 | 3 | `.` | `uint32` | | 4-Byte-Wert auf den Stack legen | |
+| 64 | PUSH5 | 3 | `.` | `uint40` | | 5-Byte-Wert auf den Stack legen | |
+| 65 | PUSH6 | 3 | `.` | `uint48` | | 6-Byte-Wert auf den Stack legen | |
+| 66 | PUSH7 | 3 | `.` | `uint56` | | 7-Byte-Wert auf den Stack legen | |
+| 67 | PUSH8 | 3 | `.` | `uint64` | | 8-Byte-Wert auf den Stack legen | |
+| 68 | PUSH9 | 3 | `.` | `uint72` | | 9-Byte-Wert auf den Stack legen | |
+| 69 | PUSH10 | 3 | `.` | `uint80` | | 10-Byte-Wert auf den Stack legen | |
+| 6A | PUSH11 | 3 | `.` | `uint88` | | 11-Byte-Wert auf den Stack legen | |
+| 6B | PUSH12 | 3 | `.` | `uint96` | | 12-Byte-Wert auf den Stack legen | |
+| 6C | PUSH13 | 3 | `.` | `uint104` | | 13-Byte-Wert auf den Stack legen | |
+| 6D | PUSH14 | 3 | `.` | `uint112` | | 14-Byte-Wert auf den Stack legen | |
+| 6E | PUSH15 | 3 | `.` | `uint120` | | 15-Byte-Wert auf den Stack legen | |
+| 6F | PUSH16 | 3 | `.` | `uint128` | | 16-Byte-Wert auf den Stack legen | |
+| 70 | PUSH17 | 3 | `.` | `uint136` | | 17-Byte-Wert auf den Stack legen | |
+| 71 | PUSH18 | 3 | `.` | `uint144` | | 18-Byte-Wert auf den Stack legen | |
+| 72 | PUSH19 | 3 | `.` | `uint152` | | 19-Byte-Wert auf den Stack legen | |
+| 73 | PUSH20 | 3 | `.` | `uint160` | | 20-Byte-Wert auf den Stack legen | |
+| 74 | PUSH21 | 3 | `.` | `uint168` | | 21-Byte-Wert auf den Stack legen | |
+| 75 | PUSH22 | 3 | `.` | `uint176` | | 22-Byte-Wert auf den Stack legen | |
+| 76 | PUSH23 | 3 | `.` | `uint184` | | 23-Byte-Wert auf den Stack legen | |
+| 77 | PUSH24 | 3 | `.` | `uint192` | | 24-Byte-Wert auf den Stack legen | |
+| 78 | PUSH25 | 3 | `.` | `uint200` | | 25-Byte-Wert auf den Stack legen | |
+| 79 | PUSH26 | 3 | `.` | `uint208` | | 26-Byte-Wert auf den Stack legen | |
+| 7A | PUSH27 | 3 | `.` | `uint216` | | 27-Byte-Wert auf den Stack legen | |
+| 7B | PUSH28 | 3 | `.` | `uint224` | | 28-Byte-Wert auf den Stack legen | |
+| 7C | PUSH29 | 3 | `.` | `uint232` | | 29-Byte-Wert auf den Stack legen | |
+| 7D | PUSH30 | 3 | `.` | `uint240` | | 30-Byte-Wert auf den Stack legen | |
+| 7E | PUSH31 | 3 | `.` | `uint248` | | 31-Byte-Wert auf den Stack legen | |
+| 7F | PUSH32 | 3 | `.` | `uint256` | | 32-Byte-Wert auf den Stack legen | |
+| 80 | DUP1 | 3 | `a` | `a, a` | | 1. Wert auf dem Stack klonen | |
+| 81 | DUP2 | 3 | `_, a` | `a, _, a` | | 2. Wert auf dem Stack klonen | |
+| 82 | DUP3 | 3 | `_, _, a` | `a, _, _, a` | | 3. Wert auf dem Stack klonen | |
+| 83 | DUP4 | 3 | `_, _, _, a` | `a, _, _, _, a` | | 4. Wert auf dem Stack klonen | |
+| 84 | DUP5 | 3 | `..., a` | `a, ..., a` | | 5. Wert auf dem Stack klonen | |
+| 85 | DUP6 | 3 | `..., a` | `a, ..., a` | | 6. Wert auf dem Stack klonen | |
+| 86 | DUP7 | 3 | `..., a` | `a, ..., a` | | 7. Wert auf dem Stack klonen | |
+| 87 | DUP8 | 3 | `..., a` | `a, ..., a` | | 8. Wert auf dem Stack klonen | |
+| 88 | DUP9 | 3 | `..., a` | `a, ..., a` | | 9. Wert auf dem Stack klonen | |
+| 89 | DUP10 | 3 | `..., a` | `a, ..., a` | | 10. Wert auf dem Stack klonen | |
+| 8A | DUP11 | 3 | `..., a` | `a, ..., a` | | 11. Wert auf dem Stack klonen | |
+| 8B | DUP12 | 3 | `..., a` | `a, ..., a` | | 12. Wert auf dem Stack klonen | |
+| 8C | DUP13 | 3 | `..., a` | `a, ..., a` | | 13. Wert auf dem Stack klonen | |
+| 8D | DUP14 | 3 | `..., a` | `a, ..., a` | | 14. Wert auf dem Stack klonen | |
+| 8E | DUP15 | 3 | `..., a` | `a, ..., a` | | 15. Wert auf dem Stack klonen | |
+| 8F | DUP16 | 3 | `..., a` | `a, ..., a` | | 16. Wert auf dem Stack klonen | |
+| 90 | SWAP1 | 3 | `a, b` | `b, a` | | | |
+| 91 | SWAP2 | 3 | `a, _, b` | `b, _, a` | | | |
+| 92 | SWAP3 | 3 | `a, _, _, b` | `b, _, _, a` | | | |
+| 93 | SWAP4 | 3 | `a, _, _, _, b` | `b, _, _, _, a` | | | |
+| 94 | SWAP5 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 95 | SWAP6 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 96 | SWAP7 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 97 | SWAP8 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 98 | SWAP9 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 99 | SWAP10 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 9A | SWAP11 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 9B | SWAP12 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 9C | SWAP13 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 9D | SWAP14 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 9E | SWAP15 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 9F | SWAP16 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| A0 | LOG0 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len` | `.` | | LOG0(memory[ost:ost+len-1]) | |
+| A1 | LOG1 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0` | `.` | | LOG1(memory[ost:ost+len-1], topic0) | |
+| A2 | LOG2 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0, topic1` | `.` | | LOG2(memory[ost:ost+len-1], topic0, topic1) | |
+| A3 | LOG3 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0, topic1, topic2` | `.` | | LOG3(memory[ost:ost+len-1], topic0, topic1, topic2) | |
+| A4 | LOG4 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0, topic1, topic2, topic3` | `.` | | LOG4(memory[ost:ost+len-1], topic0, topic1, topic2, topic3) | |
+| A5-EF | _ungültig_ | | | | | | |
+| F0 | CREATE | [A9](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a9-create-operations) | `val, ost, len` | `addr` | | addr = keccak256(rlp([address(this), this.nonce])) | |
+| F1 | CALL | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | gas, addr, val, argOst, argLen, retOst, retLen | `erfolg` | mem[retOst:retOst+retLen-1] := returndata | | |
+| F2 | CALLCODE | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | `gas, addr, val, argOst, argLen, retOst, retLen` | `erfolg` | mem[retOst:retOst+retLen-1] = returndata | dasselbe wie DELEGATECALL, aber leitet den ursprünglichen msg.sender und msg.value nicht weiter | |
+| F3 | RETURN | 0[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, len` | `.` | | return mem[ost:ost+len-1] | |
+| F4 | DELEGATECALL | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | `gas, addr, argOst, argLen, retOst, retLen` | `erfolg` | mem[retOst:retOst+retLen-1] := returndata | | |
+| F5 | CREATE2 | [A9](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a9-create-operations) | `val, ost, len, salt` | `addr` | | addr = keccak256(0xff ++ address(this) ++ salt ++ keccak256(mem[ost:ost+len-1]))[12:] | |
+| F6-F9 | _ungültig_ | | | | | | |
+| FA | STATICCALL | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | `gas, addr, argOst, argLen, retOst, retLen` | `erfolg` | mem[retOst:retOst+retLen-1] := returndata | | |
+| FB-FC | _ungültig_ | | | | | | |
+| FD | REVERT | 0[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, len` | `.` | | revert(mem[ost:ost+len-1]) | |
+| FE | INVALID | [AF](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#af-invalid) | | | designierter ungültiger Opcode - [EIP-141](https://eips.ethereum.org/EIPS/eip-141) | | |
+| FF | SELFDESTRUCT | [AB](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#ab-selfdestruct) | `addr` | `.` | | sendet alle ETH an `addr`; wenn es in derselben Transaktion ausgeführt wird, in der ein Vertrag erstellt wurde, zerstört es den Vertrag | |
diff --git a/public/content/translations/de/developers/docs/frameworks/index.md b/public/content/translations/de/developers/docs/frameworks/index.md
index 25b2032dc40..170f4b6fe13 100644
--- a/public/content/translations/de/developers/docs/frameworks/index.md
+++ b/public/content/translations/de/developers/docs/frameworks/index.md
@@ -6,19 +6,27 @@ lang: de
## Einführung in Frameworks {#introduction-to-frameworks}
-Für den Aufbau einer vollwertigen dApp sind unterschiedliche Technologieteile erforderlich. Software-Frameworks enthalten viele der erforderlichen Funktionen oder bieten einfache Plugin-Systeme, über die Sie die Tools auswählen können, die Sie als hilfreich erachten.
+Für den Aufbau einer vollwertigen dApp sind
+unterschiedliche Technologieteile erforderlich. Software-Frameworks enthalten viele der erforderlichen
+Funktionen oder bieten einfache Plugin-Systeme, über die Sie die Tools auswählen können,
+die Sie als hilfreich erachten.
-Frameworks bieten zahlreiche direkt einsetzbare Funktionen wie:
+Frameworks bieten zahlreiche direkt einsetzbare Funktionen
+wie:
- Funktionen, um eine lokale Blockchain-Instanz aufzusetzen
- Dienstprogramme zum Kompilieren und Testen von Smart Contracts
-- Client-Entwicklungs-Add-ons zur Erstellung Ihrer anwenderorientierten Anwendung im selben Projekt/Repository
-- Konfiguration für die Verbindung zu Ethereum-Netzwerken und zur Bereitstellung von Verträgen, sei es zu einer lokal laufenden Instanz oder für ein öffentliches Netzwerk von Ethereum
-- Dezentralisierte App-Verteilung – Integration mit Speicheroptionen wie IPFS
+- Client-Entwicklungs-Add-ons zur Erstellung Ihrer anwenderorientierten Anwendung
+ im selben Projekt/Repository.
+- Konfiguration zur Verbindung mit Ethereum-Netzwerken und zur Bereitstellung
+ von Verträgen, sei es für eine lokal laufende Instanz oder eines
+ der öffentlichen Netzwerke von Ethereum.
+- Verteilung dezentraler Apps – Integrationen mit Speicheroptionen
+ wie IPFS.
## Voraussetzungen {#prerequisites}
-Bevor Sie sich mit Frameworks beschäftigen, empfehlen wir, dass Sie sich mit der Einführung in [dApps](/developers/docs/dapps/) und den [Ethereum-Stack](/developers/docs/ethereum-stack/) vertraut machen.
+Bevor Sie sich mit Frameworks beschäftigen, empfehlen wir Ihnen, zuerst unsere Einführung in [Dapps](/developers/docs/dapps/) und den [Ethereum-Stack](/developers/docs/ethereum-stack/) zu lesen.
## Verfügbare Frameworks {#available-frameworks}
@@ -27,40 +35,40 @@ Bevor Sie sich mit Frameworks beschäftigen, empfehlen wir, dass Sie sich mit de
- [Foundry installieren](https://book.getfoundry.sh/)
- [Foundry-Buch](https://book.getfoundry.sh/)
- [Foundry-Community-Chat auf Telegram](https://t.me/foundry_support)
-- [Fantastisches Foundry](https://github.com/crisgarner/awesome-foundry)
+- [Awesome Foundry](https://github.com/crisgarner/awesome-foundry)
-**Hardhat –** **_Ethereum-Entwicklungsumgebung für Experten_**
+**Hardhat –** **_Ethereum-Entwicklungsumgebung für Profis._**
- [hardhat.org](https://hardhat.org)
- [GitHub](https://github.com/nomiclabs/hardhat)
-**Ape –** **_Das Smart-Contract-Entwicklungstool für Python-Experten, Data Scientists und Sicherheitsexperten_**
+**Ape –** **_Das Smart-Contract-Entwicklungstool für Pythonistas, Datenwissenschaftler und Sicherheitsexperten._**
- [Dokumentation](https://docs.apeworx.io/ape/stable/)
- [GitHub](https://github.com/ApeWorX/ape)
-**Web3j –** **_eine Plattform für die Entwicklung von Blockchain-Anwendungen auf JVM._**
+**Web3j –** **_Eine Plattform für die Entwicklung von Blockchain-Anwendungen auf der JVM._**
-- [Website](https://www.web3labs.com/web3j-sdk)
+- [Homepage](https://www.web3labs.com/web3j-sdk)
- [Dokumentation](https://docs.web3j.io)
- [GitHub](https://github.com/web3j/web3j)
-**ethers-kt – ** **_asynchrone, hochleistungsfähige Kotlin-/Java-/Android-Bibliothek für EVM-basierte Blockchains._**
+**ethers-kt –** **_Asynchrone, hochleistungsfähige Kotlin-/Java-/Android-Bibliothek für EVM-basierte Blockchains._**
- [GitHub](https://github.com/Kr1ptal/ethers-kt)
- [Beispiele](https://github.com/Kr1ptal/ethers-kt/tree/master/examples)
- [Discord](https://discord.gg/rx35NzQGSb)
-**Create Eth App –** **_Ethereum-basierte Apps mit einem Befehl erstellen. Zur Auswahl steht ein breitest Angebot an UI-Frameworks und DeFi-Vorlagen._**
+**Create Eth App –** **_Erstellen Sie Ethereum-basierte Apps mit einem Befehl._** Zur Auswahl steht ein breitest Angebot an UI-Frameworks und DeFi-Vorlagen._\*\*
- [GitHub](https://github.com/paulrberg/create-eth-app)
- [Vorlagen](https://github.com/PaulRBerg/create-eth-app/tree/develop/templates)
-**Scaffold-Eth –** **_Ethers.js + Hardhat + React-Komponenten und Hooks für web3: alles, was Sie brauchen, um mit der Entwicklung dezentraler Anwendungen auf Basis von Smart Contracts zu beginnen._**
+**Scaffold-Eth –** **_Ethers.js + Hardhat + React-Komponenten und Hooks für Web3: alles, was Sie für den Einstieg in die Erstellung dezentralisierter Anwendungen auf der Grundlage von Smart Contracts benötigen._**
- [GitHub](https://github.com/scaffold-eth/scaffold-eth-2)
-**Tenderly –** **_Web3-Entwicklungsplattform, die es Blockchain-Entwicklern ermöglicht, Smart Contracts zu erstellen, zu testen, zu debuggen, zu überwachen und zu betreiben sowie die dApp-Nutzererfahrung zu verbessern._**
+**Tenderly –** **_Web3-Entwicklungsplattform, die es Blockchain-Entwicklern ermöglicht, Smart Contracts zu erstellen, zu testen, zu debuggen, zu überwachen und zu betreiben sowie die Dapp-UX zu verbessern._**
- [Website](https://tenderly.co/)
- [Dokumentation](https://docs.tenderly.co/)
@@ -70,7 +78,7 @@ Bevor Sie sich mit Frameworks beschäftigen, empfehlen wir, dass Sie sich mit de
- [Website](https://thegraph.com/)
- [Tutorial](/developers/tutorials/the-graph-fixing-web3-data-querying/)
-**Alchemy-****_Ehereum-Entwicklungsplattform_**
+**Alchemy –** **_Ethereum-Entwicklungsplattform._**
- [alchemy.com](https://www.alchemy.com/)
- [GitHub](https://github.com/alchemyplatform)
@@ -82,18 +90,18 @@ Bevor Sie sich mit Frameworks beschäftigen, empfehlen wir, dass Sie sich mit de
- [GitHub](https://github.com/node-real)
- [Discord](https://discord.gg/V5k5gsuE)
-**thirdweb SDK –** **_erstellen Sie Web3-Anwendungen, die mit Ihren Smart Contracts interagieren können, indem Sie unsere leistungsstarken SDKs und CLI verwenden._**
+**thirdweb SDK –** **_Erstellen Sie Web3-Anwendungen, die mit Ihren Smart Contracts interagieren können, indem Sie unsere leistungsstarken SDKs und unsere CLI verwenden._**
- [Dokumentation](https://portal.thirdweb.com/sdk/)
- [GitHub](https://github.com/thirdweb-dev/)
-**Chainstack –** **_Web3-Entwicklungsplattform (Ethereum und andere)._**
+**Chainstack –** **_Web3 (Ethereum und andere) Entwicklungsplattform._**
- [chainstack.com](https://www.chainstack.com/)
- [GitHub](https://github.com/chainstack)
- [Discord](https://discord.gg/BSb5zfp9AT)
-**Crossmint –** **_eine Plattform für Web3-Entwicklung auf Unternehmensniveau, die es Ihnen ermöglicht, NFT-Anwendungen auf allen wichtigen EVM-Blockchains (und anderen) zu erstellen._**
+**Crossmint –** **_Web3-Entwicklungsplattform auf Unternehmensniveau, mit der Sie NFT-Anwendungen auf allen wichtigen EVM-Ketten(und anderen) erstellen können._**
- [Website](https://www.crossmint.com)
- [Dokumentation](https://docs.crossmint.com)
@@ -105,34 +113,42 @@ Bevor Sie sich mit Frameworks beschäftigen, empfehlen wir, dass Sie sich mit de
- [GitHub](https://github.com/eth-brownie/brownie)
- **Brownie wird derzeit nicht gewartet**
-**OpenZeppelin SDK –** **_das ultimative Smart-Contract-Toolkit: eine Suite an Tools, die Ihnen helfen, zu entwickeln, zu kompilieren, zu aktualisieren, bereitzustellen und mit Smart Contracts zu interagieren._**
+**OpenZeppelin SDK –** **_Das ultimative Smart-Contract-Toolkit: Eine Suite von Tools, die Ihnen bei der Entwicklung, Kompilierung, Aktualisierung, Bereitstellung und Interaktion mit Smart Contracts helfen._**
-- [OpenZeppelin SDK](https://openzeppelin.com/sdk/)
+- [OpenZeppelin Defender SDK](https://docs.openzeppelin.com/defender/sdk)
- [GitHub](https://github.com/OpenZeppelin/openzeppelin-sdk)
- [Community-Forum](https://forum.openzeppelin.com/c/support/17)
- **Die Entwicklung von OpenZeppelin SDK ist beendet**
-**Catapulta –** **_ein Tool für die Bereitstellung von Multi-Chain-Smart-Contracts, das die Verifizierung in Block-Explorern automatisiert, bereitgestellte Smart Contracts verfolgt und Bereitstellungsberichte teilt; Plug-and-Play für Foundry- und Hardhat-Projekte._**
+**Catapulta –** **_Multi-Chain-Bereitstellungstool für Smart Contracts, das Verifizierungen in Block-Explorern automatisiert, bereitgestellte Smart Contracts nachverfolgt und Bereitstellungsberichte teilt; Plug-and-Play für Foundry- und Hardhat-Projekte._**
- [Website](https://catapulta.sh/)
- [Dokumentation](https://catapulta.sh/docs)
-- [Github](https://github.com/catapulta-sh)
+- [GitHub](https://github.com/catapulta-sh)
-**Covalent –** **_erweiterte Blockchain-APIs für über 200 Ketten._**
+**GoldRush (powered by Covalent) –** **_GoldRush bietet die umfassendste Blockchain-Daten-API-Suite für Entwickler, Analysten und Unternehmen. Ganz gleich, ob Sie ein DeFi-Dashboard, eine Wallet, einen Trading-Bot, einen KI-Agenten oder eine Compliance-Plattform erstellen, die Daten-APIs bieten einen schnellen, genauen und entwicklerfreundlichen Zugriff auf die wesentlichen On-Chain-Daten, die Sie benötigen._**
-- [covalenthq.com](https://www.covalenthq.com/)
-- [Dokumentation](https://www.covalenthq.com/docs/api/)
+- [Website](https://goldrush.dev/)
+- [Dokumentation](https://goldrush.dev/docs/chains/ethereum)
- [GitHub](https://github.com/covalenthq)
- [Discord](https://www.covalenthq.com/discord/)
-**Wake –** **_ein All-in-One-Python-Framework für das Testen von Contracts, Fuzzing, Bereitstellung, Schwachstellenscanning und Code-Navigation._**
+**Wake –** **_All-in-One-Python-Framework für das Testen von Verträgen, Fuzzing, Bereitstellung, Schwachstellenscans und Code-Navigation._**
-- [Website](https://getwake.io/)
+- [Homepage](https://getwake.io/)
- [Dokumentation](https://ackeeblockchain.com/wake/docs/latest/)
- [GitHub](https://github.com/Ackee-Blockchain/wake)
- [VS-Code-Erweiterung](https://marketplace.visualstudio.com/items?itemName=AckeeBlockchain.tools-for-solidity)
-## Weiterführende Informationen {#further-reading}
+**Veramo –** **_Ein quelloffenes, modulares und agnostisches Framework, das es Entwicklern dezentralisierter Anwendungen erleichtert, dezentrale Identitäten und verifizierbare Nachweise in ihre Anwendungen zu integrieren._**
+
+- [Homepage](https://veramo.io/)
+- [Dokumentation](https://veramo.io/docs/basics/introduction)
+- [GitHub](https://github.com/uport-project/veramo)
+- [Discord](https://discord.com/invite/FRRBdjemHV)
+- [NPM-Paket](https://www.npmjs.com/package/@veramo/core)
+
+## Weiterführende Lektüre {#further-reading}
_Sie kennen Community-Resourcen die Ihnen geholfen haben? Bearbeiten Sie diese Seite und fügen Sie sie hinzu!_
diff --git a/public/content/translations/de/developers/docs/gas/index.md b/public/content/translations/de/developers/docs/gas/index.md
index 09ac46fea76..e308182b49e 100644
--- a/public/content/translations/de/developers/docs/gas/index.md
+++ b/public/content/translations/de/developers/docs/gas/index.md
@@ -1,6 +1,7 @@
---
title: Gas und Gebühren
-description:
+metaTitle: "Ethereum Gas und Gebühren: Technische Übersicht"
+description: Informieren Sie sich über die Ethereum Gasgebühren, wie sie berechnet werden und welche Rolle sie für die Netzwerksicherheit und Transaktionsverarbeitung spielen.
lang: de
---
@@ -8,33 +9,34 @@ Gas ist für das Ethereum-Netzwerk unerlässlich. Es ist der Treibstoff, der Eth
## Voraussetzungen {#prerequisites}
-Um diese Seite besser zu verstehen, empfehlen wir dir, zuerst [Transaktionen](/developers/docs/transactions/) und [Blöcke](/developers/docs/evm/) zu lesen.
+Um diese Seite besser zu verstehen, empfehlen wir Ihnen, sich zunächst über [Transaktionen](/developers/docs/transactions/) und die [EVM](/developers/docs/evm/) zu informieren.
-## Was ist Gas? {#what-is-gas}
+## Was ist Sprit? {#what-is-gas}
Gas bezieht sich auf die Einheit, die den Umfang des Rechenaufwands misst, der für die Durchführung spezifischer Operationen im Ethereum-Netzwerk erforderlich ist.
Da jede Transaktion im Ethereum-Netzwerk den Einsatz von Rechenressourcen erfordert, um zur Ausführung zu gelangen, ist für diese Ressourcen eine Vergütung erforderlich. Das dient der Sicherstellung, dass das Ethereum-Netzwerk weder für Spam-Attacken anfällig ist, noch in Zustände unendlicher Rechenzyklen verfallen kann. Die Bezahlung für Berechnungen erfolgt in Form einer Gasgebühr.
-Die Gasgebühr entspricht **dem Volumen des verbrauchten Gases für eine spezifische Transaktion multipliziert mit dem Preis je Gaseinheit**. Die Gebühr wird unabhängig davon gezahlt, ob eine Transaktion erfolgreich ist oder nicht.
+Die Gasgebühr ist **die Menge des für einen Vorgang verbrauchten Gases multipliziert mit den Kosten pro Gaseinheit**. Die Gebühr wird unabhängig davon gezahlt, ob eine Transaktion erfolgreich ist oder nicht.
- _Diagramm angepasst von [Ethereum EVM illustriert](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+
+_Diagramm adaptiert von [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
Gasgebühren sind in der originären Währung von Ethereum, Ether (ETH), zu entrichten. Die Gaspreise werden in der Regel in Gwei angegeben, einer Untereinheit von ETH. Jede Gwei entspricht einem Milliardstel einer ETH (0,000000001 ETH oder 10-9 ETH).
Anstatt z. B. zu sagen, dass dein Gas 0,000000001 Ether kostet, kannst du sagen, dass dein Gas 1 Gwei kostet.
-Das Wort "gwei" ist eine Kurzform von "giga-wei", was "Milliarde wei" bedeutet. Ein gwei entspricht einer Milliarde wei. Wei selbst (benannt nach [Wei Dai](https://wikipedia.org/wiki/Wei_Dai), dem Erfinder von [B-Geld](https://www.investopedia.com/terms/b/bmoney.asp)) ist die kleinste Einheit von ETH.
+Das Wort "gwei" ist eine Kurzform von "giga-wei", was "Milliarde wei" bedeutet. Ein gwei entspricht einer Milliarde wei. Wei selbst (benannt nach [Wei Dai](https://wikipedia.org/wiki/Wei_Dai), dem Schöpfer von [b-money](https://www.investopedia.com/terms/b/bmoney.asp)) ist die kleinste Einheit von ETH.
## Wie werden die Gasgebühren berechnet? {#how-are-gas-fees-calculated}
Sie können die Menge an Gas, die Sie zu zahlen bereit sind, festlegen, wenn Sie eine Transaktion einreichen. Durch das Angebot einer festgelegten Gasmenge beteiligen Sie sich an einer Auktion zur Einbeziehung Ihrer Transaktion in den nächsten Block. Bei einem zu niedrigen Gasangebot verringert sich die Wahrscheinlichkeit, dass Validierer Ihre Transaktion für die Einbindung in den nächsten Block auswählen, was zu einer verzögerten oder sogar nicht erfolgenden Ausführung Ihrer Transaktion führen kann. Wenn Sie zu viel bieten, könnten Sie ETH verschwenden. Wie können Sie also feststellen, wie viel Sie zahlen müssen?
-Der Gesamtbetrag, den Sie zahlen, wird in zwei Komponenten aufgeteilt: die `Grundgebühr `und die `Prioritätsgebühr` (Trinkgeld).
+Der Gesamtbetrag, den Sie zahlen, wird in zwei Komponenten aufgeteilt: die `Grundgebühr` und die `Prioritätsgebühr` (Trinkgeld).
-Die `Grundgebühr` wird durch das Protokoll festgelegt - Sie müssen mindestens diesen Betrag zahlen, damit Ihre Transaktion als gültig betrachtet wird. Die `Prioritätsgebühr` ist ein Trinkgeld, das Sie auf die Grundgebühr aufschlagen, um Ihre Transaktion für die Validierer attraktiv zu machen, so dass diese sie für die Aufnahme in den nächsten Block auswählen.
+Die `Grundgebühr` wird vom Protokoll festgelegt – Sie müssen mindestens diesen Betrag bezahlen, damit Ihre Transaktion als gültig angesehen wird. Die `Prioritätsgebühr` ist ein Trinkgeld, das Sie zur Grundgebühr hinzufügen, um Ihre Transaktion für Validatoren attraktiv zu machen, sodass sie diese für die Aufnahme in den nächsten Block auswählen.
-Eine Transaktion, für die nur die `Grundgebühr` gezahlt wird, ist zwar technisch gesehen gültig, wird aber wahrscheinlich nicht berücksichtigt, da sie den Validierern keinen Anreiz bietet, sie einer anderen Transaktion vorzuziehen. Die "richtige" `Prioritätsgebühr` wird durch die Netzwerkauslastung zu dem Zeitpunkt bestimmt, an dem Sie Ihre Transaktion senden. Wenn es viel Nachfrage gibt, müssen Sie Ihre `Prioritätsgebühr` möglicherweise höher ansetzen, aber wenn es weniger Nachfrage gibt, können Sie weniger bezahlen.
+Eine Transaktion, für die nur die `Grundgebühr` gezahlt wird, ist zwar technisch gesehen gültig, wird aber wahrscheinlich nicht berücksichtigt, da sie den Validatoren keinen Anreiz bietet, sie einer anderen Transaktion vorzuziehen. Die 'richtige' `Prioritätsgebühr` wird durch die Netzwerkauslastung zum Zeitpunkt des Sendens Ihrer Transaktion bestimmt – bei hoher Nachfrage müssen Sie Ihre `Prioritätsgebühr` möglicherweise höher ansetzen, aber bei geringerer Nachfrage können Sie weniger bezahlen.
Nehmen wir zum Beispiel an, Jordan muss Taylor 1 ETH bezahlen. Ein ETH-Transfer erfordert 21.000 Gaseinheiten, und die Grundgebühr beträgt 10 gwei. Jordan enthält ein Trinkgeld von 2 gwei.
@@ -42,52 +44,56 @@ Die Gesamtgebühr würde sich nun wie folgt zusammensetzen:
`Verbrauchte Gaseinheiten * (Grundgebühr + Prioritätsgebühr)`
-wobei die `Grundgebühr` ein durch das Protokoll bestimmter Wert und die `Prioritätsgebühr` ein vom Benutzer gesetzter Wert als Anreiz für den Validierer ist.
+wobei die `Grundgebühr` ein vom Protokoll festgelegter Wert ist und die `Prioritätsgebühr` ein vom Benutzer als Trinkgeld an den Validator festgelegter Wert ist.
-z.B. `21,000 * (10 + 2) = 252,000 gwei` (0.000252 ETH).
+z. B. `21.000 * (10 + 2) = 252.000 Gwei` (0,000252 ETH).
Wenn Jordan das Geld versendet, werden 1,000252 ETH von Jordans Konto abgezogen. Taylor werden 1,0000 ETH gutgeschrieben. Der Validator erhält das Trinkgeld von 0,000042 ETH. Die `Grundgebühr` von 0,00021 ETH wird verbrannt.
### Grundgebühr {#base-fee}
-Jeder Block hat seine eigene Basisgebühr, welche als reservierter Preis erscheint. Um in einen Block aufgenommen zu werden, muss der angebotene Preis pro Gas mindestens der Grundgebühr entsprechen. Die Grundgebühr wird unabhängig vom aktuellen Block berechnet und richtet sich stattdessen nach den vorherigen Blöcken. Das macht die Transaktionsgebühren für die Nutzer/Nutzerinnen berechenbarer. Bei der Erstellung des Blocks wird diese **Grundgebühr "verbrannt"** und damit aus dem Verkehr gezogen.
+Jeder Block hat seine eigene Basisgebühr, welche als reservierter Preis erscheint. Um in einen Block aufgenommen zu werden, muss der angebotene Preis pro Gas mindestens der Grundgebühr entsprechen. Die Grundgebühr wird unabhängig vom aktuellen Block berechnet und stattdessen durch die vorherigen Blöcke bestimmt, was die Transaktionsgebühren für Benutzer berechenbarer macht. Wenn der Block erstellt wird, wird diese **Grundgebühr „verbrannt“** und damit aus dem Umlauf genommen.
-Die Grundgebühr wird anhand einer Formel berechnet, die die Größe des vorherigen Blocks (die für alle Transaktionen verwendete Gasmenge) mit der Zielgröße vergleicht. Die Grundgebühr erhöht sich um maximal 12,5 % pro Block, wenn die Zielblockgröße überschritten wird. Dieses exponentielle Wachstum macht es wirtschaftlich unrentabel, die Blockgröße unbegrenzt hoch zu halten.
+Die Grundgebühr wird durch eine Formel berechnet, die die Größe des vorherigen Blocks (die für alle Transaktionen verwendete Gasmenge) mit der Zielgröße (die Hälfte des Gaslimits) vergleicht. Die Grundgebühr wird um maximal 12,5 % pro Block steigen oder fallen, wenn die Zielblockgröße über bzw. unter dem Zielwert liegt. Dieses exponentielle Wachstum macht es wirtschaftlich unrentabel, die Blockgröße unbegrenzt hoch zu halten.
-| Blocknummer | Enthaltenes Gas | Gebührenerhöhung | Aktuelle Grundgebühr |
-| ----------- | ---------------:| ----------------:| --------------------:|
-| 1 | 15 m | 0 % | 100 gwei |
-| 2 | 30 m | 0 % | 100 gwei |
-| 3 | 30 m | 12,5 % | 112,5 gwei |
-| 4 | 30 m | 12,5 % | 126,6 gwei |
-| 5 | 30 m | 12,5 % | 142,4 gwei |
-| 6 | 30 m | 12,5 % | 160,2 gwei |
-| 7 | 30 m | 12,5 % | 180,2 gwei |
-| 8 | 30 m | 12,5 % | 202,7 gwei |
+| Blocknummer | Enthaltenes Gas | Gebührenerhöhung | Aktuelle Grundgebühr |
+| ----------- | ----------------------: | ---------------: | -------------------: |
+| 1 | 18 Mio. | 0 % | 100 gwei |
+| 2 | 36 Mio. | 0 % | 100 gwei |
+| 3 | 36 Mio. | 12,5 % | 112,5 gwei |
+| 4 | 36 Mio. | 12,5 % | 126,6 gwei |
+| 5 | 36 Mio. | 12,5 % | 142,4 gwei |
+| 6 | 36 Mio. | 12,5 % | 160,2 gwei |
+| 7 | 36 Mio. | 12,5 % | 180,2 gwei |
+| 8 | 36 Mio. | 12,5 % | 202,7 gwei |
-Der obigen Tabelle folgend: Um eine Transaktion auf Block Nummer 9 zu erstellen, wird eine Wallet den Nutzer mit Sicherheit wissen lassen, dass die **maximale Grundgebühr**, die dem nächsten Block hinzugefügt wird, `aktuelle Grundgebühr * 112,5%` oder `202,7 gwei * 112,5% = 228,1 gwei` ist.
+In der obigen Tabelle wird ein Beispiel mit 36 Millionen als Gaslimit demonstriert. Folgt man diesem Beispiel, wird eine Wallet dem Benutzer beim Erstellen einer Transaktion in Block Nummer 9 mit Sicherheit mitteilen, dass die **maximale Grundgebühr**, die dem nächsten Block hinzugefügt wird, `aktuelle Grundgebühr * 112,5 %` oder `202,7 Gwei * 112,5 % = 228,1 Gwei` beträgt.
Außerdem ist es unwahrscheinlich, dass es zu längeren Zeiträumen mit vollen Blöcken kommt, da die Grundgebühr vor einem vollen Block schnell ansteigt.
-| Blocknummer | Enthaltenes Gas | Gebührenerhöhung | Aktuelle Grundgebühr |
-| ----------- | ---------------:| ----------------:| --------------------:|
-| 30 | 30 m | 12,5 % | 2705,6 gwei |
-| ... | ... | 12,5 % | ... |
-| 50 | 30 m | 12,5 % | 28531,3 gwei |
-| ... | ... | 12,5 % | ... |
-| 100 | 30 m | 12,5 % | 10302608,6 gwei |
+| Blocknummer | Enthaltenes Gas | Gebührenerhöhung | Aktuelle Grundgebühr |
+| --------------------------------------------------- | --------------------------------------------------: | ---------------: | --------------------------------------------------: |
+| 30 | 36 Mio. | 12,5 % | 2705,6 gwei |
+| ... | ... | 12,5 % | ... |
+| 50 | 36 Mio. | 12,5 % | 28531,3 gwei |
+| ... | ... | 12,5 % | ... |
+| 100 | 36 Mio. | 12,5 % | 10302608,6 gwei |
-### Prioritätsgebühr (Trinkgeld) {#priority-fee}
+### Prioritätsgebühr (Trinkgelder) {#priority-fee}
-Die Prioritätsgebühr (Trinkgeld) bietet den Validierern einen Anreiz, eine Transaktion in den Block aufzunehmen. Ohne Trinkgeld wäre es für Validierer wirtschaftlich rentabel, leere Blöcke zu schürfen, da sie die gleiche Blockbelohnung erhalten würden. Kleine Trinkgelder geben den Validierern einen minimalen Anreiz, eine Transaktion aufzunehmen. Damit Transaktionen vor anderen Transaktionen im selben Block bevorzugt ausgeführt werden, kann ein höheres Trinkgeld hinzugefügt werden, um zu versuchen, konkurrierende Transaktionen zu überbieten.
+Die Prioritätsgebühr (das Trinkgeld) gibt Validatoren einen Anreiz, die Anzahl der Transaktionen in einem Block zu maximieren, die nur durch das Blockgaslimit begrenzt ist. Ohne Trinkgelder könnte ein rationaler Validator weniger – oder sogar gar keine – Transaktionen aufnehmen, ohne eine direkte Strafe auf der Ausführungsebene oder der Konsens-Ebene zu erhalten, da die Staking-Belohnungen unabhängig davon sind, wie viele Transaktionen sich in einem Block befinden. Zudem ermöglichen es Trinkgelder den Benutzern, andere für eine Priorität innerhalb desselben Blocks zu überbieten, was effektiv Dringlichkeit signalisiert.
### Maximale Gebühr {#maxfee}
-Um eine Transaktion im Netzwerk auszuführen, können Nutzer/Nutzerinnen ein maximales Limit angeben, das sie bereit sind, für die Ausführung ihrer Transaktion zu bezahlen. Dieser optionale Parameter ist als `maxFeePerGas` bekannt. Damit eine Transaktion ausgeführt werden kann, muss die maximale Gebühr die Summe aus der Grundgebühr und dem Trinkgeld übersteigen. Der Absender der Transaktion erhält die Differenz zwischen der maximalen Gebühr und der Summe aus Grundgebühr und Trinkgeld zurück.
+Um eine Transaktion im Netzwerk auszuführen, können Nutzer/Nutzerinnen ein maximales Limit angeben, das sie bereit sind, für die Ausführung ihrer Transaktion zu bezahlen. Dieser optionale Parameter wird als `maxFeePerGas` bezeichnet. Damit eine Transaktion ausgeführt werden kann, muss die maximale Gebühr die Summe aus der Grundgebühr und dem Trinkgeld übersteigen. Der Absender der Transaktion erhält die Differenz zwischen der maximalen Gebühr und der Summe aus Grundgebühr und Trinkgeld zurück.
### Blockgröße {#block-size}
-Jeder Block hat eine Zielgröße von 15 Millionen Gas, aber die Größe der Blöcke wird entsprechend der Netznachfrage erhöht oder verringert, bis zur Blockgrenze von 60 Millionen Gas (die zweifache Zielblockgröße). Das Protokoll erreicht durch den Prozess des _Tâtonnement_ eine gleichgewichtige Blockgröße von durchschnittlich 30 Millionen. Das heißt, wenn die Blockgröße die Zielblockgröße übersteigt, erhöht das Protokoll die Grundgebühr für den folgenden Block. Ebenso senkt das Protokoll die Grundgebühr, wenn die Blockgröße kleiner als die Zielblockgröße ist. Der Betrag, um den die Grundgebühr angepasst wird, ist proportional dazu, wie weit die aktuelle Blockgröße vom Zielwert entfernt ist. [Mehr über Blöcke](/developers/docs/blocks/).
+Jeder Block hat eine Zielgröße, die der Hälfte des aktuellen Gaslimits entspricht, aber die Größe der Blöcke wird entsprechend der Netzwerknachfrage zu- oder abnehmen, bis das Blocklimit erreicht ist (2x die Zielblockgröße). Das Protokoll erreicht eine durchschnittliche Gleichgewichts-Blockgröße am Zielwert durch den Prozess des _Tâtonnement_. Das heißt, wenn die Blockgröße die Zielblockgröße übersteigt, erhöht das Protokoll die Grundgebühr für den folgenden Block. Ebenso senkt das Protokoll die Grundgebühr, wenn die Blockgröße kleiner als die Zielblockgröße ist.
+
+Der Betrag, um den die Grundgebühr angepasst wird, ist proportional dazu, wie weit die aktuelle Blockgröße vom Zielwert entfernt ist. Dies ist eine lineare Berechnung von -12,5 % für einen leeren Block, 0 % bei der Zielgröße, bis zu +12,5 % für einen Block, der das Gaslimit erreicht. Das Gaslimit kann im Laufe der Zeit auf der Grundlage von Signalen der Validatoren sowie durch Netzwerk-Upgrades schwanken. Sie können die Änderungen des Gaslimits im Laufe der Zeit [hier einsehen](https://eth.blockscout.com/stats/averageGasLimit?interval=threeMonths).
+
+[Mehr über Blöcke](/developers/docs/blocks/)
### Berechnung der Gasgebühren in der Praxis {#calculating-fees-in-practice}
@@ -97,15 +103,16 @@ Sie können ausdrücklich angeben, wie viel Sie bereit sind zu zahlen, damit Ihr
Kurzum, Gasgebühren helfen dabei, das Ethereum-Netz sicher zu halten. Indem wir für jede Berechnung, die im Netzwerk ausgeführt wird, eine Gebühr verlangen, verhindern wir, dass Akteure mit böswilligen Absichten das Netzwerk spammen. Um versehentliche oder feindliche Endlosschleifen oder andere Verschwendung von Rechenlast in Code zu vermeiden, muss jede Transaktion eine Grenze für die Anzahl der Rechenschritte festlegen, die sie zur Codeausführung verwenden kann. Die Grundeinheit der Berechnung ist "Gas".
-Auch wenn eine Transaktion ein Limit beinhaltet, wird jedes nicht verbrauchte Gas an den Nutzer zurückgegeben (d. h. `max fee - (base fee + tip)` wird zurückgegeben).
+Obwohl eine Transaktion ein Limit enthält, wird jedes nicht in einer Transaktion verbrauchte Gas an den Nutzer zurückgegeben (z. B. wird `maximale Gebühr - (Grundgebühr + Trinkgeld)` zurückgegeben).
- _Diagramm angepasst von [Ethereum EVM illustriert](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+
+_Diagramm adaptiert von [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
## Was ist das Gaslimit? {#what-is-gas-limit}
-Das Gaslimit bezieht sich auf die maximale Menge an Gas, die Sie bereit sind, bei einer Transaktion zu verbrauchen. Kompliziertere Transaktionen mit [Smart Contracts](/developers/docs/smart-contracts/) erfordern mehr Rechenarbeit und damit ein höheres Gaslimit als eine einfache Zahlung. Ein Standard-ETH-Transfer erfordert ein Gaslimit von 21.000 Gaseinheiten.
+Das Gaslimit bezieht sich auf die maximale Menge an Gas, die Sie bereit sind, bei einer Transaktion zu verbrauchen. Kompliziertere Transaktionen, die [Smart Contracts](/developers/docs/smart-contracts/) beinhalten, erfordern mehr Rechenarbeit, weshalb sie ein höheres Gaslimit als eine einfache Zahlung benötigen. Ein Standard-ETH-Transfer erfordert ein Gaslimit von 21.000 Gaseinheiten.
-Wenn Sie zum Beispiel ein Gaslimit von 50.000 für einen einfachen ETH-Transfer festlegen würden, würde die EVM 21.000 verbrauchen und Sie würden die restlichen 29.000 zurückbekommen. Wenn Sie jedoch zu wenig Gas angeben, z. B. ein Gaslimit von 20.000 für einen einfachen ETH-Transfer, wird die EVM Ihre 20.000 Gaseinheiten verbrauchen und versuchen, die Transaktion durchzuführen, aber sie wird nicht abgeschlossen. Die EVM macht dann alle Änderungen rückgängig, da der Validierer jedoch bereits Arbeit im Wert von 20.000 Gaseinheiten geleistet hat, ist dieses Gas verbraucht.
+Wenn Sie zum Beispiel ein Gaslimit von 50.000 für einen einfachen ETH-Transfer festlegen würden, würde die EVM 21.000 verbrauchen und Sie würden die restlichen 29.000 zurückbekommen. Wenn Sie jedoch zu wenig Gas angeben, zum Beispiel ein Gaslimit von 20.000 für eine einfache ETH-Überweisung, wird die Transaktion während der Validierungsphase fehlschlagen. Sie wird abgelehnt, bevor sie in einen Block aufgenommen wird, und es wird kein Gas verbraucht. Andererseits, wenn eine Transaktion während der Ausführung kein Gas mehr hat (z. B. ein Smart Contract verbraucht auf halber Strecke all das Gas), wird die EVM alle Änderungen rückgängig machen, aber dennoch wird all das bereitgestellte Gas für die geleistete Arbeit verbraucht sein.
## Warum können die Gasgebühren so hoch sein? {#why-can-gas-fees-get-so-high}
@@ -113,26 +120,32 @@ Die hohen Gasgebühren sind auf die Beliebtheit von Ethereum zurückzuführen. W
## Initiativen zur Senkung der Gaskosten {#initiatives-to-reduce-gas-costs}
-Die [Skalierbarkeits-Upgrades](/roadmap/) für Ethereum waren letztendlich dazu gedacht, einige der Probleme mit den Gasgebühren lösen. Das wiederum soll die Plattform in die Lage versetzen, Tausende von Transaktionen pro Sekunde zu verarbeiten und global zu skalieren.
+Die Ethereum-[Skalierbarkeits-Upgrades](/roadmap/) sollten letztendlich einige der Probleme mit den Gasgebühren lösen, was es der Plattform wiederum ermöglichen wird, Tausende von Transaktionen pro Sekunde zu verarbeiten und global zu skalieren.
+
+Die Skalierung auf Layer 2 ist eine der wichtigsten Initiativen, um die Gaskosten, das Nutzererlebnis und die Skalierbarkeit deutlich zu verbessern.
-Die Skalierung auf Layer 2 ist eine der wichtigsten Initiativen, um die Gaskosten, das Nutzererlebnis und die Skalierbarkeit deutlich zu verbessern. [Mehr zur Skalierung mit Layer 2](/developers/docs/scaling/#layer-2-scaling)
+[Mehr zur Layer-2-Skalierung](/developers/docs/scaling/#layer-2-scaling)
-## Gasgebühren überwachen {#monitoring-gas-fees}
+## Überwachung der Gasgebühren {#monitoring-gas-fees}
Wenn Sie die Gaspreise überwachen möchten, damit Sie Ihre ETH günstiger verschicken können, stehen Ihnen unterschiedliche Tools zur Verfügung, wie zum Beispiel:
-- [Etherscan](https://etherscan.io/gastracker) _Transaktionsgaspreis-Schätzer_
-- [Blocknative ETH Gas Estimator](https://chrome.google.com/webstore/detail/blocknative-eth-gas-estim/ablbagjepecncofimgjmdpnhnfjiecfm) _Chrome-Erweiterung zur Gasschätzung, die sowohl Typ 0 Legacy-Transaktionen als auch Typ 2 EIP-1559-Transaktionen unterstützt_
-- [Cryptoneur Gas Fees Calculator](https://www.cryptoneur.xyz/gas-fees-calculator) _Berechnen Sie Gasgebühren in Ihrer lokalen Währung für verschiedene Transaktionsarten im Mainnet, Arbitrum und Polygon._
+- [Etherscan](https://etherscan.io/gastracker) _Schätzung des Transaktions-Gaspreises_
+- [Blockscout](https://eth.blockscout.com/gas-tracker) _Open-Source-Schätzung des Transaktions-Gaspreises_
+- [ETH Gas Tracker](https://www.ethgastracker.com/) _Überwachen und verfolgen Sie die Gaspreise von Ethereum und L2, um Transaktionsgebühren zu senken und Geld zu sparen_
+- [Blocknative ETH Gas Estimator](https://chrome.google.com/webstore/detail/blocknative-eth-gas-estim/ablbagjepecncofimgjmdpnhnfjiecfm) _Chrome-Erweiterung zur Gasschätzung, die sowohl Legacy-Transaktionen vom Typ 0 als auch EIP-1559-Transaktionen vom Typ 2 unterstützt._
+- [Cryptoneur Gas Fees Calculator](https://www.cryptoneur.xyz/gas-fees-calculator) _Berechnen Sie Gasgebühren in Ihrer Landeswährung für verschiedene Transaktionsarten auf Mainnet, Arbitrum und Polygon._
-## Verwandte Werkzeuge {#related-tools}
+## Zugehörige Werkzeuge {#related-tools}
-- [Blocknative's Gas Platform](https://www.blocknative.com/gas) _API zur Gasschätzung von Blocknative's Global Mempool Data Platform_
+- [Blocknative's Gas Platform](https://www.blocknative.com/gas) _API zur Gasschätzung, betrieben von Blocknatives globaler Mempool-Datenplattform_
+- [Gas Network](https://gas.network) On-Chain-Gas-Orakel. Unterstützung für über 35 Chains.
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
- [Ethereum Gas erklärt](https://defiprime.com/gas)
-- [Den Gasverbrauch von Smart Contracts reduzieren](https://medium.com/coinmonks/8-ways-of-reducing-the-gas-consumption-of-your-smart-contracts-9a506b339c0a)
-- [Strategien für Programmierer zur Optimierung des Gasverbrauchs](https://www.alchemy.com/overviews/solidity-gas-optimization)
-- [Spezifikationen zu EIP-1559](https://eips.ethereum.org/EIPS/eip-1559).
-- [Tim Beikos EIP-1559-Ressourcen](https://hackmd.io/@timbeiko/1559-resources).
+- [Reduzierung des Gasverbrauchs Ihrer Smart Contracts](https://medium.com/coinmonks/8-ways-of-reducing-the-gas-consumption-of-your-smart-contracts-9a506b339c0a)
+- [Strategien zur Gasoptimierung für Entwickler](https://www.alchemy.com/overviews/solidity-gas-optimization)
+- [EIP-1559-Dokumentation](https://eips.ethereum.org/EIPS/eip-1559).
+- [Tim Beikos EIP-1559-Ressourcen](https://hackmd.io/@timbeiko/1559-resources)
+- [EIP-1559: Mechanismen von Memes trennen](https://web.archive.org/web/20241126205908/https://research.2077.xyz/eip-1559-separating-mechanisms-from-memes)
diff --git a/public/content/translations/de/developers/docs/ides/index.md b/public/content/translations/de/developers/docs/ides/index.md
index 71ca31bcf64..ef4c4ddbcd7 100644
--- a/public/content/translations/de/developers/docs/ides/index.md
+++ b/public/content/translations/de/developers/docs/ides/index.md
@@ -1,6 +1,6 @@
---
title: Integrierte Entwicklungsumgebungen (Integrated Development Environments, IDEs)
-description:
+description: Erfahren Sie mehr über webbasierte und Desktop IDEs für die Ethereum-Entwicklung, einschließlich Remix, VS Code und beliebte Plugins.
lang: de
---
@@ -10,38 +10,37 @@ Wenn es um die Einrichtung einer [integrierten Entwicklungsumgebung (IDE)](https
Wenn Sie sich erst einmal mit dem Code vertraut machen möchten, bevor Sie [eine lokale Entwicklungsumgebung aufsetzen](/developers/local-environment/), bieten sich diese Web-Apps an, die für die Entwicklung von Ethereum Smart Contracts konzipiert sind.
-**[Remix](https://remix.ethereum.org/)** - **_Webbasierte IDE mit integrierter statischer Analyse und einer virtuellen Test-Blockchain-Maschine_**
+**[Remix](https://remix.ethereum.org/)** – **_webbasierte IDE mit integrierter statischer Analyse und einer virtuellen Test-Blockchain-Maschine_**
- [Dokumentation](https://remix-ide.readthedocs.io/en/latest/#)
- [Gitter](https://gitter.im/ethereum/remix)
-**[ChainIDE](https://chainide.com/)** - **_Eine cloudbasierte Multi-Chain-IDE_**
+**[ChainIDE](https://chainide.com/)** – **_Eine cloudbasierte Multi-Chain-IDE_**
- [Dokumentation](https://chainide.gitbook.io/chainide-english-1/)
- [Hilfeforum](https://forum.chainide.com/)
-**[Replit (Solidity Starter - Beta)](https://replit.com/@replit/Solidity-starter-beta)** - **_Eine anpassbare Entwicklungsumgebung für Ethereum mit Hot Reloading, Fehlerprüfung und erstklassiger Testnetz-Unterstützung_**
+**[Replit (Solidity Starter – Beta)](https://replit.com/@replit/Solidity-starter-beta)** – **_Eine anpassbare Entwicklungsumgebung für Ethereum mit Hot-Reloading, Fehlerprüfung und erstklassiger Testnet-Unterstützung_**
- [Dokumentation](https://docs.replit.com/)
-**[Tenderly Sandbox](https://sandbox.tenderly.co/)** - **_Eine schnelle Prototyping-Umgebung, in der Sie Smart Contracts im Browser mit Solidity und JavaScript schreiben, ausführen und debuggen können_**
+**[Tenderly Sandbox](https://sandbox.tenderly.co/)** – **_Eine schnelle Prototyping-Umgebung, in der Sie Smart Contracts im Browser mit Solidity und JavaScript schreiben, ausführen und debuggen können_**
-**[EthFiddle](https://ethfiddle.com/)** - **_Webbasierte IDE, mit der Sie Ihren Smart Contract schreiben, kompilieren und debuggen können_**
+**[EthFiddle](https://ethfiddle.com/)** – **_Webbasierte IDE, mit der Sie Ihren Smart Contract schreiben, kompilieren und debuggen können_**
- [Gitter](https://gitter.im/loomnetwork/ethfiddle)
## Desktop-IDEs {#desktop-ides}
-Die meisten etablierten IDEs haben Plugins entwickelt, um die Ethereum-Entwicklungserfahrung zu verbessern. Alle bieten mindestens Syntaxhervorhebung für [Smart Contract-Sprachen](/developers/docs/smart-contracts/languages/).
+Die meisten etablierten IDEs haben Plugins entwickelt, um die Ethereum-Entwicklungserfahrung zu verbessern. Sie bieten mindestens eine Syntaxhervorhebung für [Smart-Contract-Sprachen](/developers/docs/smart-contracts/languages/).
-**Visual Studio Code -** **_Eine professionelle plattformübergreifende IDE mit offizieller Ethereum-Unterstützung_**
+**Visual Studio Code –** **_Professionelle plattformübergreifende IDE mit offizieller Ethereum-Unterstützung_**
- [Visual Studio Code](https://code.visualstudio.com/)
-- [Azure Blockchain Workbench](https://azuremarketplace.microsoft.com/en-us/marketplace/apps/microsoft-azure-blockchain.azure-blockchain-workbench?tab=Overview)
-- [Code-Beispiele](https://github.com/Azure-Samples/blockchain/blob/master/blockchain-workbench/application-and-smart-contract-samples/readme.md)
+- [Codebeispiele](https://github.com/Azure-Samples/blockchain/blob/master/blockchain-workbench/application-and-smart-contract-samples/readme.md)
- [GitHub](https://github.com/microsoft/vscode)
-**JetBrains IDEs (IntelliJ IDEA, usw.) ** **_Unverzichtbare Werkzeuge für Softwareentwickler und -teams_**
+**JetBrains IDEs (IntelliJ IDEA, usw.) -** **_Unverzichtbare Werkzeuge für Softwareentwickler und Teams_**
- [JetBrains](https://www.jetbrains.com/)
- [GitHub](https://github.com/JetBrains)
@@ -49,17 +48,17 @@ Die meisten etablierten IDEs haben Plugins entwickelt, um die Ethereum-Entwicklu
**Remix Desktop –** **_Erleben Sie Remix IDE auf Ihrem lokalen Rechner_**
-- [Download](https://github.com/ethereum/remix-desktop/releases)
+- [Herunterladen](https://github.com/ethereum/remix-desktop/releases)
- [GitHub](https://github.com/ethereum/remix-desktop)
-## Plug-ins und Erweiterungen {#plugins-extensions}
+## Plugins und Erweiterungen {#plugins-extensions}
-- [Solidity](https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity) – Ethereum-Solidity-Sprache für Visual Studio Code
-- [Solidity + Hardhat für VS Code](https://marketplace.visualstudio.com/items?itemName=NomicFoundation.hardhat-solidity) - Solidity- und Hardhat-Unterstützung durch das Hardhat-Team
-- [Prettier Solidity](https://github.com/prettier-solidity/prettier-plugin-solidity) – Code-Formatierer mit Prettier
+- [solidity](https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity) – Ethereum Solidity Language für Visual Studio Code
+- [Solidity + Hardhat for VS Code](https://marketplace.visualstudio.com/items?itemName=NomicFoundation.hardhat-solidity) – Solidity- und Hardhat-Unterstützung durch das Hardhat-Team
+- [Prettier Solidity](https://github.com/prettier-solidity/prettier-plugin-solidity) – Code-Formatierung mit Prettier
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
-- [Ethereum IDEs](https://www.alchemy.com/list-of/web3-ides-on-ethereum) _- Liste von Alchemy über Ethereum-IDEs_
+- [Ethereum-IDEs](https://www.alchemy.com/list-of/web3-ides-on-ethereum) _– Alchemys Liste der Ethereum-IDEs_
-_Kennst du eine Community-Ressource, die dir geholfen hat? Bearbeite diese Seite und füge sie hinzu!_
+_Sie kennen Community-Resourcen die Ihnen geholfen haben? Bearbeiten Sie diese Seite und fügen Sie sie hinzu!_
diff --git a/public/content/translations/de/developers/docs/index.md b/public/content/translations/de/developers/docs/index.md
index dfb508cc36b..562e927953b 100644
--- a/public/content/translations/de/developers/docs/index.md
+++ b/public/content/translations/de/developers/docs/index.md
@@ -6,13 +6,13 @@ lang: de
Diese Dokumentation soll Ihnen dabei helfen, mit Ethereum zu entwickeln. Darin wird das Konzept von Ethereum erläutert sowie der Technologie-Stack von Ethereum. Außerdem sind fortgeschrittene Themen für komplexere Anwendungen und Anwendungsfälle dokumentiert.
-Diese Dokumentation wird von der Open-Source-Community gepflegt, also zögern Sie nicht, neue Themen vorzuschlagen oder neue Inhalte hinzuzufügen. Geben Sie dabei Beispiele an, wenn das Ihrer Meinung nach hilfreich ist. Die gesamte Entwicklungsdokumentation kann auf GitHub bearbeitet werden. Falls Sie sich nicht sicher sind wie, [befolgen Sie einfach diese Anleitung](https://github.com/ethereum/ethereum-org-website/blob/dev/docs/editing-markdown.md).
+Diese Dokumentation wird von der Open-Source-Community gepflegt, also zögern Sie nicht, neue Themen vorzuschlagen oder neue Inhalte hinzuzufügen. Geben Sie dabei Beispiele an, wenn das Ihrer Meinung nach hilfreich ist. Die gesamte Dokumentation kann über GitHub bearbeitet werden – wenn Sie sich nicht sicher sind, wie das geht, [folgen Sie diesen Anweisungen](https://github.com/ethereum/ethereum-org-website/blob/dev/docs/editing-markdown.md).
## Entwicklungsmodule {#development-modules}
Wenn das Ihr erster Versuch bei der Entwicklung mit Ethereum ist, empfehlen wir Ihnen, ganz vorne zu beginnen und sich wie bei einem Buch durchzuarbeiten.
-### Grundsätzliche Themen {#foundational-topics}
+### Grundlegende Themen {#foundational-topics}
@:"
```
-## Betrieb eines Bootnodes {#run-a-bootnode}
+## Einen Bootnode betreiben {#run-a-bootnode}
-Bootnodes sind vollständige Knoten, die nicht hinter einem NAT ([Network Address Translation](https://www.geeksforgeeks.org/network-address-translation-nat/)) stehen. Jeder vollständige Knoten kann als Bootnode wirken, solange er öffentlich zugänglich ist.
+Bootnodes sind vollständige Nodes, die sich nicht hinter einem NAT ([Netzwerkadressübersetzung](https://www.geeksforgeeks.org/network-address-translation-nat/)) befinden. Jeder vollständige Knoten kann als Bootnode wirken, solange er öffentlich zugänglich ist.
-Wenn Sie einen Knoten starten, sollte er sich in Ihren ["Enode"](/developers/docs/networking-layer/network-addresses/#enode) einloggen. Dieser ist ein öffentlicher Identifikator, den andere nutzen können, um sich mit Ihrem Knoten zu verbinden.
+Wenn Sie einen Node starten, sollte dieser Ihre [enode](/developers/docs/networking-layer/network-addresses/#enode) protokollieren. Dies ist eine öffentliche Kennung, die andere verwenden können, um sich mit Ihrem Node zu verbinden.
Der Enode wird normalerweise bei jedem Neustart neu generiert, schauen Sie sich daher die Dokumentation Ihres Clients an. Dort erfahren Sie, wie man einen beständigen Enode für Ihren Bootnode erzeugt.
@@ -26,6 +26,6 @@ Ein guter Bootnode benötigt möglichst viele Peers, die an ihm andocken können
## Verfügbare Bootnodes {#available-bootnodes}
-Eine Liste bereits verfügbarer Bootnodes in go-Ethereum finden Sie [hier](https://github.com/ethereum/go-ethereum/blob/master/params/bootnodes.go#L23). Diese Bootnodes werden von der Ethereum Foundation und dem go-Ethereum Team gewartet.
+Eine Liste der integrierten Bootnodes in go-ethereum finden Sie [hier](https://github.com/ethereum/go-ethereum/blob/master/params/bootnodes.go#L23). Diese Bootnodes werden von der Ethereum Foundation und dem go-Ethereum Team gewartet.
Es gibt weitere Listen von Bootnodes, die von Freiwilligen gepflegt werden. Stellen Sie sicher, dass Sie immer mindestens einen offiziellen Bootnode verwenden, da Sie sonst Opfer eines Eclipse-Angriffs werden könnten.
diff --git a/public/content/translations/de/developers/docs/nodes-and-clients/client-diversity/index.md b/public/content/translations/de/developers/docs/nodes-and-clients/client-diversity/index.md
index 4e951c30925..b2109e4bb72 100644
--- a/public/content/translations/de/developers/docs/nodes-and-clients/client-diversity/index.md
+++ b/public/content/translations/de/developers/docs/nodes-and-clients/client-diversity/index.md
@@ -9,101 +9,124 @@ Das Verhalten eines Ethereum-Knotens wird durch die von ihm ausgeführte Client-
## Voraussetzungen {#prerequisites}
-Wenn Sie noch nicht wissen, was Nodes und Clients sind, lesen Sie [Nodes und Clients](/developers/docs/nodes-and-clients/). [Ausführungs-](/glossary/#execution-layer) und [Konsensebenen](/glossary/#consensus-layer) sind im Glossar definiert.
+Wenn Sie noch nicht verstehen, was Nodes und Clients sind, lesen Sie den Artikel über [Nodes und Clients](/developers/docs/nodes-and-clients/). Die [Ausführungs-](/glossary/#execution-layer) und [Konsens-](/glossary/#consensus-layer)Ebenen sind im Glossar definiert.
## Warum gibt es mehrere Clients? {#why-multiple-clients}
-Es gibt mehrere, unabhängig voneinander entwickelte und gewartete Clients, weil die Client-Vielfalt das Netzwerk widerstandsfähiger gegen Angriffe und Fehler macht. Mehrere Clients sind die einzigartige Stärke von Ethereum – andere Blockchains verlassen sich auf die Unfehlbarkeit eines einzigen Clients. Es reicht jedoch nicht aus, einfach mehrere Clients zur Verfügung zu haben, sie müssen von der Community angenommen werden und die Anzahl der aktiven Knoten muss relativ gleichmäßig auf sie verteilt sein.
+Es gibt mehrere, unabhängig voneinander entwickelte und gewartete Clients, weil die Client-Vielfalt das Netzwerk widerstandsfähiger gegen Angriffe und Fehler macht. Mehrere Clients sind die einzigartige Stärke von Ethereum – andere Blockchains verlassen sich auf die Unfehlbarkeit eines einzigen Clients. Es reicht jedoch nicht aus, einfach mehrere Clients zur Verfügung zu haben. Sie müssen von der Community angenommen werden und die Anzahl der aktiven Nodes muss relativ gleichmäßig auf sie verteilt sein.
## Warum ist die Client-Vielfalt wichtig? {#client-diversity-importance}
Viele unabhängig voneinander entwickelte und gewartete Clients sind für die Sicherheit eines dezentralen Netzwerks unerlässlich. Lassen Sie uns die Gründe dafür untersuchen.
-### Fehler {#bugs}
+### Bugs {#bugs}
Ein Fehler in einem einzelnen Client stellt ein geringeres Risiko für das Netzwerk dar, wenn er nur eine Minderheit der Ethereum-Knoten repräsentiert. Bei einer annähernd gleichmäßigen Verteilung der Knoten auf viele Clients ist die Wahrscheinlichkeit, dass die meisten Clients von einem gemeinsamen Problem betroffen sind, gering. Das Netzwerk ist daher robuster.
-### Verteidigung gegen Angriffe {#resilience}
+### Widerstandsfähigkeit gegen Angriffe {#resilience}
-Die Client-Vielfalt bietet auch eine gewisse Widerstandsfähigkeit gegen Angriffe. Ein Angriff, bei dem [ein bestimmter Client in einen bestimmten Bereich der Chain gelockt wird](https://twitter.com/vdWijden/status/1437712249926393858), dürfte zum Besipiel kaum erfolgreich sein, da andere Clients wahrscheinlich nicht auf die gleiche Weise ausgenutzt werden können und die kanonische Chain nicht beschädigt wird. Eine geringe Client-Vielfalt erhöht das Risiko, das mit einem Hack auf den dominanten Client verbunden ist. Die Client-Vielfalt hat sich bereits als wichtiger Schutz gegen böswillige Angriffe auf das Netzwerk erwiesen. So war beispielsweise der Denial-of-Service-Angriff von Shanghai im Jahr 2016 möglich, weil es den Angreifern gelang, den dominanten Client (Geth) dazu zu bringen, einen „Slow Disk I/O-Vorgang“ zehntausende Male pro Block auszuführen. Da auch alternative Clients online waren, die diese Schwachstelle nicht aufwiesen, konnte Ethereum dem Angriff widerstehen und weiterarbeiten, während die Schwachstelle in Geth behoben wurde.
+Die Client-Vielfalt bietet auch eine gewisse Widerstandsfähigkeit gegen Angriffe. Ein Angriff beispielsweise, der [einen bestimmten Client dazu verleitet](https://twitter.com/vdWijden/status/1437712249926393858), auf einen bestimmten Zweig der Chain zu wechseln, wird wahrscheinlich nicht erfolgreich sein, da andere Clients wahrscheinlich nicht auf dieselbe Weise ausnutzbar sind und die kanonische Chain unbeschädigt bleibt. Eine geringe Client-Vielfalt erhöht das Risiko, das mit einem Hack auf den dominanten Client verbunden ist. Die Client-Vielfalt hat sich bereits als wichtiger Schutz gegen böswillige Angriffe auf das Netzwerk erwiesen. So war beispielsweise der Denial-of-Service-Angriff von Shanghai im Jahr 2016 möglich, weil es den Angreifern gelang, den dominanten Client (Geth) dazu zu bringen, einen „Slow Disk I/O-Vorgang“ zehntausende Male pro Block auszuführen. Da auch alternative Clients online waren, die diese Schwachstelle nicht aufwiesen, konnte Ethereum dem Angriff widerstehen und weiterarbeiten, während die Schwachstelle in Geth behoben wurde.
-### Finalität von Proof-of-stake {#finality}
+### Proof-of-Stake-Endgültigkeit {#finality}
Ein Fehler in einem Konsensclient mit mehr als 33 % der Ethereum-Knoten könnte verhindern, dass die Konsensebene finalisieren kann. Das bedeutet, dass die Nutzer nicht darauf vertrauen können, dass Transaktionen nicht irgendwann rückgängig gemacht oder geändert werden. Dies wäre für viele der auf Ethereum aufbauenden Anwendungen, insbesondere DeFi, sehr problematisch.
-) ist ein spieltheoretisches Konzept, das davon ausgeht, dass mehrere Entitäten in Abwesenheit jeglicher Kommunikation immer zu einer gemeinsamen Lösung eines Problems tendieren. Schelling-Punkt-Mechanismen werden häufig in dezentralisierten Oracle-Netzwerken verwendet, um Nodes zu ermöglichen, einen Konsens über Antworten auf Datenanfragen zu erreichen.
+Ein [Schelling-Punkt](https://en.wikipedia.org/wiki/Focal_point_\(game_theory\)) ist ein spieltheoretisches Konzept, das davon ausgeht, dass mehrere Entitäten bei fehlender Kommunikation immer auf eine gemeinsame Lösung für ein Problem zurückgreifen. Schelling-Punkt-Mechanismen werden häufig in dezentralen Orakel-Netzwerken verwendet, um Nodes zu ermöglichen, einen Konsens über Antworten auf Datenanfragen zu erreichen.
-Eine frühe Idee dafür war [SchellingCoin](https://blog.ethereum.org/2014/03/28/schellingcoin-a-minimal-trust-universal-data-feed/), ein vorgeschlagener Datenfeed, bei dem Teilnehmer Antworten auf "skalare" Fragen (Fragen, deren Antworten durch Größe beschrieben werden, z.B. "Was ist der Preis von ETH?") zusammen mit einer Einlage einreichen. Benutzer, die Werte zwischen dem 25. und 75. [Perzentil](https://en.wikipedia.org/wiki/Percentile) liefern, werden belohnt, während diejenigen, deren Werte stark vom Medianwert abweichen, bestraft werden.
+Eine frühe Idee dafür war [SchellingCoin](https://blog.ethereum.org/2014/03/28/schellingcoin-a-minimal-trust-universal-data-feed/), ein vorgeschlagener Datenfeed, bei dem die Teilnehmer Antworten auf „skalare“ Fragen (Fragen, deren Antworten durch eine Größenordnung beschrieben werden, z. B. „Wie hoch ist der Preis von ETH?“) zusammen mit einer Einlage einreichen. Benutzer, die Werte zwischen dem 25. und 75. [Perzentil](https://en.wikipedia.org/wiki/Percentile) angeben, werden belohnt, während diejenigen, deren Werte stark vom Medianwert abweichen, bestraft werden.
-Obwohl SchellingCoin heute nicht existiert, verwenden eine Reihe von dezentralisierten Oracles—insbesondere [Maker Protocol's Oracles](https://docs.makerdao.com/smart-contract-modules/oracle-module)—den Schelling-Punkt-Mechanismus, um die Genauigkeit der Oracle-Daten zu verbessern. Jedes Maker Oracle besteht aus einem Offchain-P2P-Netzwerk von Nodes ("Relayers" und "Feeds"), die Marktpreise für Sicherheiten-Assets einreichen, und einem Onchain-"Medianizer"-Contract, der den Median aller bereitgestellten Werte berechnet. Sobald die festgelegte Verzögerungszeit abgelaufen ist, wird dieser Medianwert zum neuen Referenzpreis für das zugehörige Asset.
+Obwohl es SchellingCoin heute nicht mehr gibt, nutzen eine Reihe dezentraler Oracles – insbesondere die [Oracles des Maker-Protokolls](https://docs.makerdao.com/smart-contract-modules/oracle-module) – den Schelling-Punkt-Mechanismus, um die Genauigkeit der Oracle-Daten zu verbessern. Jeder Maker-Oracle besteht aus einem Off-Chain-P2P-Netzwerk von Nodes ("Relayer" und "Feeds"), die Marktpreise für Sicherungsassets einreichen, sowie einem On-Chain-"Medianizer"-Vertrag, der den Median aller bereitgestellten Werte berechnet. Sobald die festgelegte Verzögerungszeit vorüber ist, wird dieser Medianwert zum neuen Referenzpreis für das zugehörige Asset.
-Andere Beispiele für Oracles, die Schelling-Punkt-Mechanismen verwenden, sind [Chainlink Offchain Reporting](https://docs.chain.link/docs/offchain-reporting/) und [Witnet](https://witnet.io/). In beiden Systemen werden Antworten von Oracle-Nodes im Peer-to-Peer-Netzwerk zu einem einzigen Aggregatwert zusammengefasst, wie z.B. einem Mittelwert oder Median. Nodes werden je nachdem belohnt oder bestraft, inwieweit ihre Antworten mit dem Aggregatwert übereinstimmen oder davon abweichen.
+Andere Beispiele für Oracles, die Schelling-Punkt-Mechanismen verwenden, sind [Chainlink Offchain Reporting](https://docs.chain.link/architecture-overview/off-chain-reporting) und [Witnet](https://witnet.io/). In beiden Systemen werden Antworten von Orakel-Nodes im Peer-to-Peer-Netzwerk zu einem einzigen aggregierten Wert wie einem Mittelwert oder Median zusammengefasst. Nodes werden entsprechend dem Grad belohnt oder bestraft, in dem ihre Antworten mit dem aggregierten Wert übereinstimmen oder von ihm abweichen.
-Schelling-Punkt-Mechanismen sind attraktiv, weil sie den Onchain-Fußabdruck minimieren (nur eine Transaktion muss gesendet werden), während sie gleichzeitig Dezentralisierung garantieren. Letzteres ist möglich, weil Nodes die Liste der eingereichten Antworten unterzeichnen müssen, bevor sie in den Algorithmus eingespeist wird, der den Mittelwert/Medianwert erzeugt.
+Schelling-Punkt-Mechanismen sind attraktiv, da sie den On-Chain-Fußabdruck minimieren (es muss nur eine Transaktion gesendet werden), während gleichzeitig Dezentralisierung garantiert wird. Letzteres ist möglich, weil die Nodes die Liste der eingereichten Antworten signieren müssen, bevor sie in den Algorithmus eingespeist wird, der den Mittelwert/Medianwert berechnet.
### Verfügbarkeit {#availability}
-Dezentralisierte Oracle-Dienste gewährleisten eine hohe Verfügbarkeit von Offchain-Daten für Smart Contracts. Dies wird durch die Dezentralisierung sowohl der Quelle der Offchain-Informationen als auch der Nodes erreicht, die für die Übertragung der Informationen Onchain verantwortlich sind.
+Dezentrale Oracle-Dienste gewährleisten eine hohe Verfügbarkeit von Off-Chain-Daten für Smart Contracts. Dies wird erreicht, indem sowohl die Quelle der Off-Chain-Informationen als auch die Nodes, die für die Übertragung der Informationen On-Chain verantwortlich sind, dezentralisiert werden.
-Dies gewährleistet Fehlertoleranz, da der Oracle-Contract sich auf mehrere Nodes verlassen kann (die sich auch auf mehrere Datenquellen verlassen), um Abfragen von anderen Contracts auszuführen. Dezentralisierung auf der Quellen- _und_ Node-Betreiber-Ebene ist entscheidend—ein Netzwerk von Oracle-Nodes, das Informationen aus derselben Quelle bereitstellt, wird auf das gleiche Problem stoßen wie ein zentralisiertes Oracle.
+Dies gewährleistet Fehlertoleranz, da der Orakelvertrag sich auf mehrere Nodes (die sich auch auf mehrere Datenquellen stützen) verlassen kann, um Abfragen von anderen Verträgen auszuführen. Die Dezentralisierung auf der Ebene der Quelle _und_ des Node-Betreibers ist entscheidend – ein Netzwerk von Oracle-Nodes, das Informationen aus derselben Quelle bereitstellt, wird auf dasselbe Problem stoßen wie ein zentralisiertes Oracle.
-Es ist auch möglich, dass Stake-basierte Oracles Node-Betreiber bestrafen, die nicht schnell genug auf Datenanfragen reagieren. Dies motiviert Oracle-Nodes erheblich, in fehlertolerante Infrastruktur zu investieren und Daten zeitnah bereitzustellen.
+Es ist auch möglich, dass stake-basierte Oracles die Node-Betreiber bestrafen, die nicht schnell auf Datenanfragen reagieren. Dies incentiviert Orakel-Nodes erheblich, in fehlertolerante Infrastruktur zu investieren und Daten rechtzeitig bereitzustellen.
### Gute Anreizkompatibilität {#good-incentive-compatibility}
-Dezentralisierte Oracles implementieren verschiedene Anreizdesigns, um [byzantinisches](https://en.wikipedia.org/wiki/Byzantine_fault) Verhalten unter Oracle-Nodes zu verhindern. Konkret erreichen sie _Zurechenbarkeit_ und _Verantwortlichkeit_:
+Dezentralisierte Oracles implementieren verschiedene Anreizdesigns, um [byzantinisches](https://en.wikipedia.org/wiki/Byzantine_fault) Verhalten unter Oracle-Nodes zu verhindern. Insbesondere erreichen sie _Zurechenbarkeit_ und _Rechenschaftspflicht_:
-1. Dezentralisierte Oracle-Nodes müssen oft die Daten signieren, die sie als Antwort auf Datenanfragen bereitstellen. Diese Informationen helfen bei der Bewertung der historischen Leistung von Oracle-Nodes, sodass Benutzer unzuverlässige Oracle-Nodes bei Datenanfragen herausfiltern können. Ein Beispiel ist Witnets [Algorithmisches Reputationssystem](https://docs.witnet.io/intro/about/architecture#algorithmic-reputation-system).
+1. Dezentralisierte Orakel-Nodes müssen häufig die Daten signieren, die sie als Antwort auf Datenanfragen bereitstellen. Diese Informationen helfen bei der Bewertung der historischen Leistung von Orakel-Nodes, sodass Nutzer unzuverlässige Orakel-Nodes bei Datenanfragen herausfiltern können. Ein Beispiel ist das [Algorithmische Reputationssystem](https://docs.witnet.io/intro/about/architecture#algorithmic-reputation-system) von Witnet.
-2. Dezentralisierte Oracles—wie bereits erklärt—können von Nodes verlangen, dass sie einen Stake auf ihre Überzeugung von der Richtigkeit der von ihnen eingereichten Daten setzen. Wenn sich die Behauptung als richtig erweist, kann dieser Stake zusammen mit Belohnungen für ehrlichen Service zurückgegeben werden. Er kann aber auch gekürzt werden, falls die Informationen falsch sind, was ein gewisses Maß an Verantwortlichkeit bietet.
+2. Dezentralisierte Orakel – wie zuvor erläutert – können verlangen, dass Nodes einen Einsatz auf ihre Überzeugung in die Wahrheit der von ihnen übermittelten Daten setzen. Wenn die Behauptung zutrifft, kann dieser Einsatz zusammen mit Belohnungen für ehrlichen Dienst zurückgegeben werden. But it can also be slashed in case the information is incorrect, which provides some measure of accountability.
## Anwendungen von Oracles in Smart Contracts {#applications-of-oracles-in-smart-contracts}
-Die folgenden sind häufige Anwendungsfälle für Oracles in Ethereum:
+Die folgenden sind häufige Anwendungsfälle für Orakel in Ethereum:
-### Finanzdaten abrufen {#retrieving-financial-data}
+### Abrufen von Finanzdaten {#retrieving-financial-data}
-[Dezentralisierte Finanzanwendungen](/defi/) (DeFi) ermöglichen Peer-to-Peer-Kredite, Kreditaufnahme und Handel mit Assets. Dies erfordert oft den Zugriff auf verschiedene Finanzinformationen, einschließlich Wechselkursdaten (zur Berechnung des Fiat-Werts von Kryptowährungen oder zum Vergleich von Token-Preisen) und Kapitalmarktdaten (zur Berechnung des Werts von tokenisierten Assets wie Gold oder US-Dollar).
+[Dezentralisierte Finanzen](/defi/) (DeFi) ermöglichen Peer-to-Peer-Kreditvergabe, -aufnahme und den Handel mit Vermögenswerten. Dies erfordert oft das Einholen verschiedener Finanzinformationen, einschließlich Wechselkursdaten (zur Berechnung des Fiat-Werts von Kryptowährungen oder zum Vergleich von Token-Preisen) und Kapitalmarktdaten (zur Berechnung des Werts tokenisierter Vermögenswerte, wie Gold oder US-Dollar).
-Ein DeFi-Kreditprotokoll muss beispielsweise aktuelle Marktpreise für als Sicherheit hinterlegte Assets (z.B. ETH) abfragen. Dies ermöglicht es dem Contract, den Wert der Sicherheiten-Assets zu bestimmen und festzulegen, wie viel aus dem System geliehen werden kann.
+Ein DeFi-Kreditprotokoll muss beispielsweise die aktuellen Marktpreise für als Sicherheit hinterlegte Vermögenswerte (z. B. ETH) abfragen. Dies ermöglicht es dem Vertrag, den Wert der Sicherheitsvermögenswerte zu bestimmen und festzulegen, wie viel er vom System leihen kann.
-Beliebte "Preis-Oracles" (wie sie oft genannt werden) in DeFi sind Chainlink Price Feeds, Compound Protocol's [Open Price Feed](https://compound.finance/docs/prices), Uniswap's [Time-Weighted Average Prices (TWAPs)](https://docs.uniswap.org/contracts/v2/concepts/core-concepts/oracles) und [Maker Oracles](https://docs.makerdao.com/smart-contract-modules/oracle-module).
+Beliebte „Preis-Oracles“ (wie sie oft genannt werden) in DeFi umfassen Chainlink Price Feeds, den [Open Price Feed](https://compound.finance/docs/prices) von Compound Protocol, die [zeitgewichteten Durchschnittspreise (TWAPs)](https://docs.uniswap.org/contracts/v2/concepts/core-concepts/oracles) von Uniswap und die [Maker Oracles](https://docs.makerdao.com/smart-contract-modules/oracle-module).
-Entwickler sollten die Einschränkungen dieser Preis-Oracles verstehen, bevor sie sie in ihr Projekt integrieren. Dieser [Artikel](https://blog.openzeppelin.com/secure-smart-contract-guidelines-the-dangers-of-price-oracles/) bietet eine detaillierte Analyse dessen, was bei der Planung der Verwendung eines der genannten Preis-Oracles zu beachten ist.
+Entwickler sollten die Vorbehalte verstehen, die mit diesen Preis-Orakeln einhergehen, bevor sie sie in ihr Projekt integrieren. Dieser [Artikel](https://blog.openzeppelin.com/secure-smart-contract-guidelines-the-dangers-of-price-oracles/) bietet eine detaillierte Analyse dessen, was bei der Planung der Verwendung eines der genannten Preis-Oracles zu beachten ist.
-Hier ist ein Beispiel, wie Sie den neuesten ETH-Preis in Ihrem Smart Contract mit einem Chainlink-Preis-Feed abrufen können:
+Im Folgenden finden Sie ein Beispiel, wie Sie den aktuellen ETH-Preis in Ihrem Smart Contract unter Verwendung eines Chainlink-Preisfeeds abrufen können:
```solidity
pragma solidity ^0.6.7;
@@ -347,81 +354,80 @@ contract PriceConsumerV3 {
}
```
-### Verifizierbare Zufallszahlen generieren {#generating-verifiable-randomness}
+### Generierung nachweisbarer Zufälligkeit {#generating-verifiable-randomness}
-Bestimmte Blockchain-Anwendungen, wie Blockchain-basierte Spiele oder Lotteriesysteme, benötigen ein hohes Maß an Unvorhersehbarkeit und Zufälligkeit, um effektiv zu funktionieren. Die deterministische Ausführung von Blockchains eliminiert jedoch die Zufälligkeit.
+Bestimmte Blockchain-Anwendungen, wie blockchain-basierte Spiele oder Lotteriesysteme, benötigen ein hohes Maß an Unvorhersehbarkeit und Zufälligkeit, um effektiv zu funktionieren. Jedoch eliminiert die deterministische Ausführung von Blockchains die Zufälligkeit.
-Der ursprüngliche Ansatz war die Verwendung pseudozufälliger kryptographischer Funktionen wie `blockhash`, aber diese konnten von [Miner manipuliert werden](https://ethereum.stackexchange.com/questions/3140/risk-of-using-blockhash-other-miners-preventing-attack#:~:text=So%20while%20the%20miners%20can,to%20one%20of%20the%20players.), die den Proof-of-Work-Algorithmus lösen. Außerdem bedeutet Ethereums [Umstellung auf Proof-of-Stake](/roadmap/merge/), dass Entwickler sich nicht mehr auf `blockhash` für Onchain-Zufälligkeit verlassen können. Der [RANDAO-Mechanismus](https://eth2book.info/altair/part2/building_blocks/randomness) der Beacon Chain bietet stattdessen eine alternative Quelle für Zufälligkeit.
+Der ursprüngliche Ansatz war die Verwendung pseudozufälliger kryptografischer Funktionen wie `blockhash`, aber diese konnten von [Minern manipuliert werden](https://ethereum.stackexchange.com/questions/3140/risk-of-using-blockhash-other-miners-preventing-attack#:~:text=So%20while%20the%20miners%20can,to%20one%20of%20the%20players.) Lösung des Proof-of-Work-Algorithmus. Außerdem bedeutet [Ethereums Umstellung auf Proof-of-Stake](/roadmap/merge/), dass Entwickler sich für die Onchain-Zufälligkeit nicht mehr auf `blockhash` verlassen können. Der [RANDAO-Mechanismus](https://eth2book.info/altair/part2/building_blocks/randomness) der Beacon Chain bietet stattdessen eine alternative Quelle für Zufälligkeit.
-Es ist möglich, den Zufallswert Offchain zu generieren und Onchain zu senden, aber dies erfordert ein hohes Maß an Vertrauen von den Benutzern. Sie müssen glauben, dass der Wert wirklich durch unvorhersehbare Mechanismen generiert wurde und nicht während der Übertragung verändert wurde.
+Es ist möglich, den Zufallswert Off-Chain zu generieren und ihn dann On-Chain zu senden, aber dies stellt hohe Vertrauensanforderungen an die Nutzer. Sie müssen glauben, dass der Wert tatsächlich durch unvorhersehbare Mechanismen erzeugt wurde und während der Übertragung nicht verändert wurde.
-Oracles, die für Offchain-Berechnungen konzipiert sind, lösen dieses Problem, indem sie Zufallsergebnisse Offchain sicher generieren und diese Onchain zusammen mit kryptographischen Nachweisen senden, die die Unvorhersehbarkeit des Prozesses belegen. Ein Beispiel ist [Chainlink VRF](https://docs.chain.link/docs/chainlink-vrf/) (Verifiable Random Function), ein nachweislich faires und manipulationssicheres Zufallszahlengeneratorsystem (RNG), das nützlich ist für den Aufbau zuverlässiger Smart Contracts für Anwendungen, die auf unvorhersehbare Ergebnisse angewiesen sind. Ein weiteres Beispiel ist [API3 QRNG](https://docs.api3.org/explore/qrng/), das Quanten-Zufallszahlengenerierung (QRNG) als öffentliche Methode der Web3-Zufallszahlengenerierung basierend auf Quantenphänomenen anbietet, bereitgestellt mit freundlicher Genehmigung der Australian National University (ANU).
+Oracles, die für Off-Chain-Berechnungen entwickelt wurden, lösen dieses Problem, indem sie zufällige Ergebnisse sicher Off-Chain generieren und diese zusammen mit kryptografischen Beweisen, die die Unvorhersehbarkeit des Prozesses bestätigen, On-Chain übertragen. Ein Beispiel ist [Chainlink VRF](https://docs.chain.link/docs/chainlink-vrf/) (Verifiable Random Function), ein nachweislich fairer und manipulationssicherer Zufallszahlengenerator (RNG), der für die Erstellung zuverlässiger Smart Contracts für Anwendungen nützlich ist, die auf unvorhersehbaren Ergebnissen beruhen.
-### Ereignisergebnisse abrufen {#getting-outcomes-for-events}
+### Ergebnisse für Ereignisse erhalten {#getting-outcomes-for-events}
-Mit Oracles ist es einfach, Smart Contracts zu erstellen, die auf Ereignisse in der realen Welt reagieren. Oracle-Dienste machen dies möglich, indem sie Contracts erlauben, über Offchain-Komponenten mit externen APIs zu verbinden und Informationen aus diesen Datenquellen zu konsumieren. Zum Beispiel könnte die zuvor erwähnte Vorhersage-dApp ein Oracle anfordern, Wahlergebnisse aus einer vertrauenswürdigen Offchain-Quelle (z.B. Associated Press) zurückzugeben.
+Mit Orakeln ist es einfach, Smart Contracts zu erstellen, die auf reale Ereignisse reagieren. Oracle-Dienste machen dies möglich, indem sie Verträgen erlauben, sich über Off-Chain-Komponenten mit externen APIs zu verbinden und Informationen aus diesen Datenquellen zu nutzen. Zum Beispiel könnte die zuvor erwähnte Vorhersage-App ein Oracle anfordern, um Wahlergebnisse von einer vertrauenswürdigen Off-Chain-Quelle (z. B. der Associated Press) zurückzuliefern.
-Die Verwendung von Oracles zum Abrufen von Daten basierend auf Ergebnissen aus der realen Welt ermöglicht andere neuartige Anwendungsfälle; zum Beispiel benötigt ein dezentralisiertes Versicherungsprodukt genaue Informationen über Wetter, Katastrophen usw., um effektiv zu funktionieren.
+Die Verwendung von Orakeln, um Daten basierend auf realen Ergebnissen abzurufen, ermöglicht andere neuartige Anwendungsfälle; beispielsweise benötigt ein dezentralisiertes Versicherungsprodukt genaue Informationen über Wetter, Katastrophen usw., um effektiv zu funktionieren.
### Automatisierung von Smart Contracts {#automating-smart-contracts}
-Smart Contracts laufen nicht automatisch; vielmehr muss ein externes Konto (EOA) oder ein anderer Contract-Account die richtigen Funktionen auslösen, um den Contract-Code auszuführen. In den meisten Fällen sind die meisten Funktionen des Contracts öffentlich und können von EOAs und anderen Contracts aufgerufen werden.
+Smart Contracts werden nicht automatisch ausgeführt; vielmehr muss ein externes Eigentümerkonto (EOA) oder ein anderes Vertragskonto die richtigen Funktionen auslösen, um den Code des Vertrags auszuführen. In den meisten Fällen sind der Großteil der Funktionen des Vertrags öffentlich und können von externen Eigentümerkonten (EOAs) und anderen Verträgen aufgerufen werden.
-Es gibt aber auch _private Funktionen_ innerhalb eines Contracts, die für andere unzugänglich sind, aber für die Gesamtfunktionalität einer dApp kritisch sind. Beispiele sind eine `mintERC721Token()`-Funktion, die periodisch neue NFTs für Benutzer prägt, eine Funktion für die Auszahlung in einem Vorhersagemarkt oder eine Funktion zum Entsperren gestaketer Tokens in einer DEX.
+Es gibt aber auch _private Funktionen_ innerhalb eines Vertrags, die für andere unzugänglich sind, aber für die allgemeine Funktionalität einer Dapp entscheidend sind. Beispiele hierfür sind eine `mintERC721Token()`-Funktion, die regelmäßig neue NFTs für Benutzer prägt, eine Funktion zur Auszahlung von Gewinnen in einem Prognosemarkt oder eine Funktion zum Freischalten von gestaketen Token in einer DEX.
-Entwickler müssen solche Funktionen in regelmäßigen Abständen auslösen, um die Anwendung reibungslos laufen zu lassen. Dies kann jedoch zu mehr verlorenen Stunden für routinemäßige Aufgaben führen, weshalb die Automatisierung der Ausführung von Smart Contracts attraktiv ist.
+Entwickler müssen solche Funktionen in Intervallen auslösen, um die Anwendung reibungslos laufen zu lassen. Dies kann jedoch zu mehr verlorenen Stunden bei routinemäßigen Aufgaben für Entwickler führen, weshalb die Automatisierung der Ausführung von Smart Contracts attraktiv ist.
-Einige dezentralisierte Oracle-Netzwerke bieten Automatisierungsdienste an, die es Offchain-Oracle-Nodes ermöglichen, Smart-Contract-Funktionen gemäß den vom Benutzer definierten Parametern auszulösen. Typischerweise erfordert dies die "Registrierung" des Ziel-Contracts beim Oracle-Dienst, die Bereitstellung von Mitteln zur Bezahlung des Oracle-Betreibers und die Angabe der Bedingungen oder Zeiten für die Auslösung des Contracts.
+Einige dezentrale Oracle-Netzwerke bieten Automatisierungsdienste an, die es Off-Chain-Oracle-Nodes ermöglichen, Smart-Contract-Funktionen gemäß von den Nutzern definierten Parametern auszulösen. Üblicherweise erfordert dies die "Registrierung" des Zielvertrags beim Orakeldienst, die Bereitstellung von Mitteln zur Bezahlung des Orakelbetreibers und die Festlegung der Bedingungen oder Zeiten zum Auslösen des Vertrags.
-Chainlinks [Keeper Network](https://chain.link/keepers) bietet Optionen für Smart Contracts, regelmäßige Wartungsaufgaben auf vertrauensminimierte und dezentralisierte Weise auszulagern. Lesen Sie die offizielle [Keeper-Dokumentation](https://docs.chain.link/docs/chainlink-keepers/introduction/), um Informationen darüber zu erhalten, wie Sie Ihren Contract Keeper-kompatibel machen und den Upkeep-Dienst nutzen können.
+Das [Keeper Network](https://chain.link/keepers) von Chainlink bietet Optionen für Smart Contracts, um regelmäßige Wartungsaufgaben auf eine vertrauensminimierte und dezentralisierte Weise auszulagern. Lesen Sie die offizielle [Keeper-Dokumentation](https://docs.chain.link/docs/chainlink-keepers/introduction/) für Informationen darüber, wie Sie Ihren Vertrag Keeper-kompatibel machen und den Upkeep-Service nutzen können.
## Wie man Blockchain-Oracles verwendet {#use-blockchain-oracles}
-Im Ethereum-Ökosystem stehen verschiedene Oracle-Dienste zur Integration zur Verfügung:
+Es gibt mehrere Oracle Anwendungen, die du in den Ethereum Dapp integrieren kannst:
-**[Chainlink](https://chain.link/)** - _Chainlink dezentralisierte Oracle-Netzwerke bieten manipulationssichere Eingaben, Ausgaben und Berechnungen zur Unterstützung fortgeschrittener Smart Contracts auf jeder Blockchain._
+**[Chainlink](https://chain.link/)** – _Dezentrale Oracle-Netzwerke von Chainlink bieten manipulationssichere Eingaben, Ausgaben und Berechnungen zur Unterstützung fortschrittlicher Smart Contracts auf jeder Blockchain._
-**[RedStone Oracles](https://redstone.finance/)** - _RedStone ist ein dezentralisiertes modulares Oracle, das gas-optimierte Datenfeeds bereitstellt. Es spezialisiert sich auf die Bereitstellung von Preis-Feeds für aufstrebende Assets wie Liquid Staking Tokens (LSTs), Liquid Restaking Tokens (LRTs) und Bitcoin Staking-Derivate._
+**[RedStone Oracles](https://redstone.finance/)** – _RedStone ist ein dezentrales, modulares Oracle, das gasoptimierte Datenfeeds bereitstellt. Er spezialisiert sich darauf, Preisfeeds für aufstrebende Assets anzubieten, wie zum Beispiel Liquid-Staking-Token (LSTs), Liquid-Restaking-Token (LRTs) und Bitcoin-Staking-Derivate._
-**[Chronicle](https://chroniclelabs.org/)** - _Chronicle überwindet die aktuellen Einschränkungen bei der Übertragung von Daten Onchain durch die Entwicklung wirklich skalierbarer, kosteneffizienter, dezentralisierter und verifizierbarer Oracles._
+**[Chronicle](https://chroniclelabs.org/)** – _Chronicle überwindet die aktuellen Einschränkungen bei der Übertragung von Daten onchain durch die Entwicklung wirklich skalierbarer, kosteneffizienter, dezentraler und verifizierbarer Oracles._
-**[Witnet](https://witnet.io/)** - _Witnet ist ein erlaubnisfreies, dezentralisiertes und zensurresistentes Oracle, das Smart Contracts hilft, auf Ereignisse in der realen Welt mit starken kryptoökonomischen Garantien zu reagieren._
+**[Witnet](https://witnet.io/)** – _Witnet ist ein erlaubnisfreies, dezentrales und zensurresistentes Oracle, das Smart Contracts dabei hilft, auf Ereignisse in der realen Welt mit starken krypto-ökonomischen Garantien zu reagieren._
-**[UMA Oracle](https://uma.xyz)** - _UMAs optimistisches Oracle ermöglicht es Smart Contracts, schnell jede Art von Daten für verschiedene Anwendungen zu erhalten, einschließlich Versicherungen, Finanzderivate und Vorhersagemärkte._
+**[UMA Oracle](https://uma.xyz)** – _Das optimistische Oracle von UMA ermöglicht es Smart Contracts, schnell jede Art von Daten für verschiedene Anwendungen zu empfangen, einschließlich Versicherungen, Finanzderivaten und Prognosemärkten._
-**[Tellor](https://tellor.io/)** - _Tellor ist ein transparentes und erlaubnisfreies Oracle-Protokoll, mit dem Ihr Smart Contract jederzeit leicht auf Daten zugreifen kann._
+**[Tellor](https://tellor.io/)** – _Tellor ist ein transparentes und erlaubnisfreies Oracle-Protokoll, mit dem Ihr Smart Contract problemlos alle Daten abrufen kann, wann immer er sie benötigt._
-**[Band Protocol](https://bandprotocol.com/)** - _Band Protocol ist eine Cross-Chain-Datenoracle-Plattform, die reale Daten und APIs mit Smart Contracts aggregiert und verbindet._
+**[Band Protocol](https://bandprotocol.com/)** – _Band Protocol ist eine kettenübergreifende Daten-Oracle-Plattform, die reale Daten und APIs aggregiert und mit Smart Contracts verbindet._
-**[Paralink](https://paralink.network/)** - _Paralink bietet eine Open-Source- und dezentralisierte Oracle-Plattform für Smart Contracts, die auf Ethereum und anderen beliebten Blockchains laufen._
+**[Pyth Network](https://pyth.network/)** – _Das Pyth-Netzwerk ist ein First-Party-Finanz-Oracle-Netzwerk, das darauf ausgelegt ist, kontinuierlich Daten aus der realen Welt onchain in einer manipulationssicheren, dezentralen und autarken Umgebung zu veröffentlichen._
-**[Pyth Network](https://pyth.network/)** - _Das Pyth-Netzwerk ist ein First-Party-Finanzoracle-Netzwerk, das darauf ausgelegt ist, kontinuierliche Daten aus der realen Welt in einer manipulationssicheren, dezentralisierten und selbsttragenden Umgebung Onchain zu veröffentlichen._
+**[API3 DAO](https://www.api3.org/)** – _API3 DAO liefert First-Party-Oracle-Lösungen, die eine größere Quellentransparenz, Sicherheit und Skalierbarkeit in einer dezentralen Lösung für Smart Contracts bieten_
-**[API3 DAO](https://www.api3.org/)** - _API3 DAO liefert First-Party-Oracle-Lösungen, die in einer dezentralisierten Lösung für Smart Contracts größere Quellentransparenz, Sicherheit und Skalierbarkeit bieten._
+**[Supra](https://supra.com/)** – Ein vertikal integriertes Toolkit mit kettenübergreifenden Lösungen, das alle Blockchains, ob öffentlich (L1s und L2s) oder privat (Unternehmen), miteinander verbindet und dezentrale Oracle-Preis-Feeds bereitstellt, die für Onchain- und Offchain-Anwendungsfälle genutzt werden können.
-**[Supra](https://supra.com/)** - Ein vertikal integriertes Toolkit von Cross-Chain-Lösungen, das alle Blockchains, öffentliche (L1s und L2s) oder private (Unternehmen), miteinander verbindet und dezentralisierte Oracle-Preis-Feeds bereitstellt, die für Onchain- und Offchain-Anwendungsfälle verwendet werden können.
+**[Gas Network](https://gas.network/)** – Eine dezentrale Oracle-Plattform, die Echtzeit-Gaspreisdaten über die Blockchain hinweg bereitstellt. Indem es Daten von führenden Gaspreis-Datenanbietern onchain bereitstellt, trägt das Gas Network zur Förderung der Interoperabilität bei. Das Gas Network unterstützt Daten für über 35 Chains, einschließlich des Ethereum Mainnets und vieler führender L2s.
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
**Artikel**
-- [Was ist ein Blockchain-Oracle?](https://chain.link/education/blockchain-oracles) - _Chainlink_
-- [Was ist ein Blockchain-Oracle?](https://betterprogramming.pub/what-is-a-blockchain-oracle-f5ccab8dbd72) - _Patrick Collins_
-- [Dezentralisierte Oracle: Ein umfassender Überblick](https://medium.com/fabric-ventures/decentralised-oracles-a-comprehensive-overview-d3168b9a8841) - _Julien Thevenard_
-- [Implementieren eines Blockchain-Oracles auf Ethereum](https://medium.com/@pedrodc/implementieren-ein-blockchain-orakel-auf-ethereum-cedc7e26b49e) - _Pedro Costa_
-- [Warum können Smart Contracts keine API-Aufrufe tätigen?](https://ethereum.stackexchange.com/questions/301/why-cant-contracts-make-api-calls) - _StackExchange_
-- [Sie wollen also ein Preis-Oracle benutzen](https://samczsun.com/so-you-want-to-use-a-price-oracle/) -_samczsun_
+- [Was ist ein Blockchain-Oracle?](https://chain.link/education/blockchain-oracles) – _Chainlink_
+- [Was ist ein Blockchain-Oracle?](https://medium.com/better-programming/what-is-a-blockchain-oracle-f5ccab8dbd72) – _Patrick Collins_
+- [Dezentrale Oracles: ein umfassender Überblick](https://medium.com/fabric-ventures/decentralised-oracles-a-comprehensive-overview-d3168b9a8841) – _Julien Thevenard_
+- [Implementierung eines Blockchain-Oracles auf Ethereum](https://medium.com/@pedrodc/implementing-a-blockchain-oracle-on-ethereum-cedc7e26b49e) – _Pedro Costa_
+- [Warum können Smart Contracts keine API-Aufrufe tätigen?](https://ethereum.stackexchange.com/questions/301/why-cant-contracts-make-api-calls) – _StackExchange_
+- [Sie möchten also ein Preis-Oracle verwenden](https://samczsun.com/so-you-want-to-use-a-price-oracle/) – _samczsun_
**Videos**
-- [Oracles und die Erweiterung der Blockchain-Nützlichkeit](https://youtu.be/BVUZpWa8vpw) — Real Vision Finance
-- [Der Unterschied zwischen First-Party- und Third-Party-Oracles](https://blockchainoraclesummit.io/first-party-vs-third-party-oracles/) - Blockchain Oracle Summit
+- [Oracles und die Erweiterung des Nutzens der Blockchain](https://youtu.be/BVUZpWa8vpw) – _Real Vision Finance_
**Tutorials**
-- [Wie man den aktuellen Ethereum-Preis in Solidity abruft](https://blog.chain.link/fetch-current-crypto-price-data-solidity/) — Chainlink
-- [Oracle-Daten konsumieren](https://docs.chroniclelabs.org/Developers/tutorials/Remix) — Chronicle
+- [Wie man den aktuellen Preis von Ethereum in Solidity abruft](https://blog.chain.link/fetch-current-crypto-price-data-solidity/) – _Chainlink_
+- [Oracle-Daten konsumieren](https://docs.chroniclelabs.org/Developers/tutorials/Remix) – _Chronicle_
**Beispielprojekte**
-- [Chainlink Ethereum Full-Stack-Starter-Projekt](https://github.com/hackbg/chainlink-fullstack) — HackBG
+- [Vollständiges Chainlink-Starterprojekt für Ethereum in Solidity](https://github.com/hackbg/chainlink-fullstack) – _HackBG_
diff --git a/public/content/translations/de/developers/docs/programming-languages/dart/index.md b/public/content/translations/de/developers/docs/programming-languages/dart/index.md
index 25436497765..02446271233 100644
--- a/public/content/translations/de/developers/docs/programming-languages/dart/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/dart/index.md
@@ -5,24 +5,28 @@ lang: de
incomplete: true
---
-## Erste Schritte mit Smart Contracts und der Solidity-Sprache {#getting-started-with-smart-contracts-and-solidity}
+## Erste Schritte mit Smart Contracts und der Sprache Solidity {#getting-started-with-smart-contracts-and-solidity}
## Tutorials {#tutorials}
-- [Flutter und Blockchain – Hello World Dapp](https://www.geeksforgeeks.org/flutter-and-blockchain-hello-world-dapp/) führt Sie durch die ersten Schritte:
- 1. Smart Contract in [Solidity](https://soliditylang.org/) schreiben
- 2. Benutzeroberfläche in Dart schreiben
-- Eine [mobile dApp mit Flutter zu erstellen](https://medium.com/dash-community/building-a-mobile-dapp-with-flutter-be945c80315a) ist wesentlich kürzer und empfehlenswert für alle, die mit den Grundlagen bereits vertraut sind
-- Wenn Sie es vorziehen, durch ein Video zu lernen, können Sie sich [Build Your First Blockchain Flutter App](https://www.youtube.com/watch?v=3Eeh3pJ6PeA) (Erstellen Sie Ihre erste Blockchain-Flutter-App) ansehen, das ungefähr eine Stunde dauert
-- Für Ungeduldige ist [Bau einer dezentralen Blockchain-Anwendung mit Flutter und Dart auf Ethereum](https://www.youtube.com/watch?v=jaMFEOCq_1s) empfehlenswert, denn die Dauer beträgt nur etwa zwanzig Minuten.
-- [Integrating MetaMask in Flutter application with Web3Modal by WalletConnect](https://www.youtube.com/watch?v=v_M2buHCpc4) (MetaMask in Flutter-Anwendung mit Web3Modal von WalletConnect integrieren) – dieses kurze Video führt Sie durch die Schritte zur Integration von MetaMask in Ihre Flutter-Anwendungen mit der [Web3Modal](https://pub.dev/packages/web3modal_flutter)-Bibliothek von WalletConnect
-- [Mobile Blockchain Developer Bootcamp Course With Solidity & Flutter](https://youtube.com/playlist?list=PL4V4Unlk5luhQ26ERO6hWEbcUwHDSSmVH) (Bootcamp-Kurs für mobile Blockchain-Entwickler mit Solidity und Flutter) – Playlist für den Kurs für mobile Blockchain-Entwickler mit vollem Stack
+- [Flutter and Blockchain – Hello World Dapp](https://www.geeksforgeeks.org/flutter-and-blockchain-hello-world-dapp/) führt Sie durch alle Schritte für den Einstieg:
+ 1. Einen Smart Contract in [Solidity](https://soliditylang.org/) schreiben
+ 2. Benutzeroberfläche in Dart schreiben
+- [Building a Mobile dapp with Flutter](https://medium.com/dash-community/building-a-mobile-dapp-with-flutter-be945c80315a) ist viel kürzer und eignet sich möglicherweise besser,
+ wenn Sie die Grundlagen bereits kennen
+- Wenn Sie lieber durch das Ansehen eines Videos lernen, können Sie sich [Build Your First Blockchain Flutter App](https://www.youtube.com/watch?v=3Eeh3pJ6PeA) ansehen, das etwa eine Stunde dauert.
+- Wenn Sie ungeduldig sind, bevorzugen Sie vielleicht [Building a Blockchain Decentralized-app with Flutter and Dart on Ethereum](https://www.youtube.com/watch?v=jaMFEOCq_1s), das nur etwa zwanzig Minuten dauert.
+- [Integrating MetaMask in Flutter application with Web3Modal by WalletConnect](https://www.youtube.com/watch?v=v_M2buHCpc4) – dieses kurze Video führt Sie durch die Schritte zur Integration von MetaMask in Ihre Flutter-Anwendungen mit der [Web3Modal](https://pub.dev/packages/web3modal_flutter)-Bibliothek von WalletConnect.
+- [Mobile Blockchain Developer Bootcamp Course With Solidity & Flutter](https://youtube.com/playlist?list=PL4V4Unlk5luhQ26ERO6hWEbcUwHDSSmVH) – Playlist eines Kurses für Full-Stack-Entwickler mobiler Blockchain-Anwendungen
-## Mit Ethereum Clients arbeiten {#working-with-ethereum-clients}
+## Arbeiten mit Ethereum-Clients {#working-with-ethereum-clients}
-Sie können mit Ethereum dezentrale Anwendungen (oder "dApps") erstellen, die sich die Vorteile von Kryptowährung und der Blockchain-Technologie zu eigen machen. Es gibt mindestens zwei derzeit gepflegte Bibliotheken für Dart, um die [JSON-RPC-API](/developers/docs/apis/json-rpc/) für Ethereum zu verwenden.
+Sie können mit Ethereum dezentrale Anwendungen (oder "dApps") erstellen, die sich die Vorteile von Kryptowährung und der Blockchain-Technologie zu eigen machen.
+Es gibt mindestens zwei derzeit gepflegte Bibliotheken für Dart, um die
+[JSON-RPC API](/developers/docs/apis/json-rpc/) für Ethereum zu verwenden.
-1. [Web3dart von simonbutler.eu](https://pub.dev/packages/web3dart)
-1. [Ethereum 5.0.0 von darticulate.com](https://pub.dev/packages/ethereum)
+1. [Web3dart von pwa.ir](https://pub.dev/packages/web3dart)
+2. [Ethereum 5.0.0 von darticulate.com](https://pub.dev/packages/ethereum)
-Außerdem gibt es zusätzliche Bibliotheken, mit denen Sie bestimmte Ethereum-Adressen bearbeiten könnten oder mit denen sich die Preise verschiedener Kryptowährungen abrufen lassen. [Die vollständige Liste ist hier einsehbar](https://pub.dev/dart/packages?q=ethereum).
+Außerdem gibt es zusätzliche Bibliotheken, mit denen Sie bestimmte Ethereum-Adressen bearbeiten könnten oder mit denen sich die Preise verschiedener Kryptowährungen abrufen lassen.
+[Die vollständige Liste finden Sie hier](https://pub.dev/dart/packages?q=ethereum).
diff --git a/public/content/translations/de/developers/docs/programming-languages/delphi/index.md b/public/content/translations/de/developers/docs/programming-languages/delphi/index.md
index a2d7fae60bc..2482c21b29b 100644
--- a/public/content/translations/de/developers/docs/programming-languages/delphi/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/delphi/index.md
@@ -11,46 +11,46 @@ Lernen, mit der Programmiersprache Delphi für Ethereum zu entwickeln
-Sie können mit Ethereum dezentrale Anwendungen (oder "dApps") erstellen, die von den Vorteilen der Kryptowährung und der Blockchain-Technologie profitieren. dApps sind vertrauenswürdig. Das bedeutet, dass dApps nach dem Hochladen auf Ethereum immer exakt wie programmiert ausgeführt werden. Darüber lassen sich digitale Vermögenswerte verwalten und neuartige Finanzanwendungen erschaffen. Sie können dezentralisiert sein. Das bedeutet, dass keine einzelne Einheit oder Person sie kontrollieren kann. Damit ist es fast unmöglich, sie zu zensieren.
+Sie können mit Ethereum dezentrale Anwendungen (oder „dApps“) erstellen, die von den Vorteilen der Kryptowährung und der Blockchain-Technologie profitieren. Solche dApps sind vertrauenswürdig. Das bedeutet, dass sie, sobald sie auf Ethereum hochgeladen wurden, immer exakt wie programmiert ausgeführt werden. Darüber lassen sich digitale Vermögenswerte verwalten und neuartige Finanzanwendungen erschaffen. Sie können dezentralisiert sein. Das bedeutet, dass keine einzelne Einheit oder Person sie kontrollieren kann. Damit ist es fast unmöglich, sie zu zensieren.
Erstellen Sie dezentrale Anwendungen auf Ethereum und interagieren Sie mit Smart Contracts in der Programmiersprache Delphi.
-## Erste Schritte mit Smart Contracts und der Solidity-Sprache {#getting-started-with-smart-contracts-and-the-solidity-language}
+## Erste Schritte mit Smart Contracts und der Sprache Solidity {#getting-started-with-smart-contracts-and-the-solidity-language}
**Erste Schritte bei der Integration von Delphi mit Ethereum**
-Benötigen Sie für den Einstieg erst einmal allgemeinere Informationen? Dann empfehlen wir Ihnen [ethereum.org/learn](/learn/) oder [ethereum.org/developers](/developers/).
+Sind Sie an einigen grundlegenden Informationen interessiert? Besuchen Sie [ethereum.org/learn](/learn/) oder [ethereum.org/developers](/developers/).
- [Blockchain erklärt](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
- [Smart Contracts verstehen](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
-- [Den ersten Smart Contract schreiben](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
-- [Kompilieren und Bereitstellen von Solidity Code lernen](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [Schreiben Sie Ihren ersten Smart Contract](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
+- [Lernen Sie Solidity zu kompilieren und bereitstellen](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
-## Referenzen und Links für Einsteiger {#beginner-references-and-links}
+## Referenzen und Links für Anfänger {#beginner-references-and-links}
**Einführung der Delphereum-Bibliothek**
- [Was ist Delphereum?](https://github.com/svanas/delphereum/blob/master/README.md)
-- [Verbindung von Delphi mit einer lokalen (in-memory) Blockchain](https://medium.com/@svanas/connecting-delphi-to-a-local-in-memory-blockchain-9a1512d6c5b0)
-- [Anbindung von Delphi an das Ethereum-Mainnet](https://medium.com/@svanas/connecting-delphi-to-the-ethereum-main-net-5faf1feffd83)
-- [Verbindung von Delphi mit Smart Contracts](https://medium.com/@svanas/connecting-delphi-to-smart-contracts-3146b12803a1)
+- [Verbinden von Delphi mit einer lokalen (In-Memory) Blockchain](https://medium.com/@svanas/connecting-delphi-to-a-local-in-memory-blockchain-9a1512d6c5b0)
+- [Verbinden von Delphi mit dem Ethereum Mainnet](https://medium.com/@svanas/connecting-delphi-to-the-ethereum-main-net-5faf1feffd83)
+- [Verbinden von Delphi mit Smart Contracts](https://medium.com/@svanas/connecting-delphi-to-smart-contracts-3146b12803a1)
**Möchten Sie die Einrichtung erst einmal überspringen und direkt zu den Beispielen gehen?**
-- [Ein 3-minütiger Smart Contract und Delphi – Teil 1](https://medium.com/@svanas/a-3-minute-smart-contract-and-delphi-61d998571d)
-- [Ein 3-minütiger Smart Contract und Delphi – Teil 2](https://medium.com/@svanas/a-3-minute-smart-contract-and-delphi-part-2-446925faa47b)
+- [Ein 3-Minuten Smart Contract und Delphi – Teil 1](https://medium.com/@svanas/a-3-minute-smart-contract-and-delphi-61d998571d)
+- [Ein 3-Minuten Smart Contract und Delphi – Teil 2](https://medium.com/@svanas/a-3-minute-smart-contract-and-delphi-part-2-446925faa47b)
## Artikel für Fortgeschrittene {#intermediate-articles}
-- [Ethereum-signierte Nachrichten-Signatur in Delphi erstellen](https://medium.com/@svanas/generating-an-ethereum-signed-message-signature-in-delphi-75661ce5031b)
-- [Ether mit Delphi übertragen](https://medium.com/@svanas/transferring-ether-with-delphi-b5f24b1a98a4)
-- [ERC-20-Token mit Delphi übertragen](https://medium.com/@svanas/transferring-erc-20-tokens-with-delphi-bb44c05b295d)
+- [Erstellen einer von Ethereum signierten Nachrichtensignatur in Delphi](https://medium.com/@svanas/generating-an-ethereum-signed-message-signature-in-delphi-75661ce5031b)
+- [Ether mit Delphi überweisen](https://medium.com/@svanas/transferring-ether-with-delphi-b5f24b1a98a4)
+- [ERC-20-Tokens mit Delphi überweisen](https://medium.com/@svanas/transferring-erc-20-tokens-with-delphi-bb44c05b295d)
## Fortgeschrittene Nutzungsmuster {#advanced-use-patterns}
- [Delphi und Ethereum Name Service (ENS)](https://medium.com/@svanas/delphi-and-ethereum-name-service-ens-4443cd278af7)
- [QuikNode, Ethereum und Delphi](https://medium.com/@svanas/quiknode-ethereum-and-delphi-f7bfc9671c23)
- [Delphi und der Ethereum Dark Forest](https://svanas.medium.com/delphi-and-the-ethereum-dark-forest-5b430da3ad93)
-- [Einen Token gegen einen anderen in Delphi austauschen](https://svanas.medium.com/swap-one-token-for-another-in-delphi-bcb999c47f7)
+- [Einen Token gegen einen anderen in Delphi tauschen](https://svanas.medium.com/swap-one-token-for-another-in-delphi-bcb999c47f7)
-Sind Sie an weiteren Informationen interessiert? Sehen Sie sich [ethereum.org/developers](/developers/) an.
+Sind Sie an weiteren Informationen interessiert? Schauen Sie sich [ethereum.org/developers](/developers/) an.
diff --git a/public/content/translations/de/developers/docs/programming-languages/dot-net/index.md b/public/content/translations/de/developers/docs/programming-languages/dot-net/index.md
index 3c5b6462808..fee6c345b75 100644
--- a/public/content/translations/de/developers/docs/programming-languages/dot-net/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/dot-net/index.md
@@ -5,54 +5,54 @@ lang: de
incomplete: true
---
-Lernen, wie Sie .NET-basierte Projekte und Tools für die Ethereum-Entwicklung nutzen können
+Lernen Sie, wie Sie für Ethereum mithilfe von .NET-basierten Projekten und Tools entwickeln
-Sie können mit Ethereum dezentrale Anwendungen (oder "dApps") erstellen, die von den Vorteilen der Kryptowährung und der Blockchain-Technologie profitieren. dApps sind vertrauenswürdig. Das bedeutet, dass dApps nach dem Hochladen auf Ethereum immer exakt wie programmiert ausgeführt werden. Darüber lassen sich digitale Vermögenswerte verwalten und neuartige Finanzanwendungen erschaffen. Sie können dezentralisiert sein. Das bedeutet, dass keine einzelne Einheit oder Person sie kontrollieren kann. Damit ist es fast unmöglich, sie zu zensieren.
+Sie können mit Ethereum dezentrale Anwendungen (oder „dApps“) erstellen, die von den Vorteilen der Kryptowährung und der Blockchain-Technologie profitieren. Solche dApps sind vertrauenswürdig. Das bedeutet, dass sie, sobald sie auf Ethereum hochgeladen wurden, immer exakt wie programmiert ausgeführt werden. Darüber lassen sich digitale Vermögenswerte verwalten und neuartige Finanzanwendungen erschaffen. Sie können dezentralisiert sein. Das bedeutet, dass keine einzelne Einheit oder Person sie kontrollieren kann. Damit ist es fast unmöglich, sie zu zensieren.
Erstellen Sie dezentrale Anwendungen auf Ethereum und interagieren Sie mit Smart Contracts unter Verwendung von Tools und Sprachen aus dem Microsoft-Technologie-Stack – unterstützt C#, Visual Basic .NET, F#, über Tools wie VSCode und Visual Studio, mit dem .NET Framework/.NET Core/.NET Standard. Stellen Sie eine Ethereum-Blockchain mit Microsoft Azure Blockchain in wenigen Minuten bereit. Ethereum lässt sich eben so gut einsetzen wie .NET.
-## Erste Schritte mit Smart Contracts und der Solidity-Sprache {#getting-started-with-smart-contracts-and-the-solidity-language}
+## Erste Schritte mit Smart Contracts und der Sprache Solidity {#getting-started-with-smart-contracts-and-the-solidity-language}
**Erste Schritte bei der Integration von .Net mit Ethereum**
-Benötigen Sie für den Einstieg erst einmal allgemeinere Informationen? Dann empfehlen wir Ihnen [ethereum.org/learn](/learn/) oder [ethereum.org/developers](/developers/).
+Sind Sie an einigen grundlegenden Informationen interessiert? Besuchen Sie [ethereum.org/learn](/learn/) oder [ethereum.org/developers](/developers/).
- [Blockchain erklärt](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
- [Smart Contracts verstehen](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
-- [Den ersten Smart Contract schreiben](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
-- [Kompilieren und Bereitstellen von Solidity Code lernen](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [Schreiben Sie Ihren ersten Smart Contract](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
+- [Lernen Sie Solidity zu kompilieren und bereitstellen](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
-## Referenzen und Links für Einsteiger {#beginner-references-and-links}
+## Referenzen und Links für Anfänger {#beginner-references-and-links}
-**Einführung der Nethereum-Bibliothek und von VS Code Solidity**
+**Einführung der Nethereum Bibliothek und VS Code Solidity**
-- [Nethereum – Erste Schritte](https://docs.nethereum.com/en/latest/getting-started/)
-- [VS Code Solidity installieren](https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity)
-- [Ein .NET-Entwickler-Workflow zum Erstellen und Aufrufen von Ethereum-Smart-Contracts](https://medium.com/coinmonks/a-net-developers-workflow-for-creating-and-calling-ethereum-smart-contracts-44714f191db2)
-- [Smart-Contract-Integration mit Nethereum](https://kauri.io/#collections/Getting%20Started/smart-contracts-integration-with-nethereum/#smart-contracts-integration-with-nethereumm)
-- [Schnittstellen von .NET und Ethereum-Blockchain-Smart-Contracts mit Nethereum](https://medium.com/my-blockchain-development-daily-journey/interfacing-net-and-ethereum-blockchain-smart-contracts-with-nethereum-2fa3729ac933), auch in [中文版](https://medium.com/my-blockchain-development-daily-journey/%E4%BD%BF%E7%94%A8nethereum%E9%80%A3%E6%8E%A5-net%E5%92%8C%E4%BB%A5%E5%A4%AA%E7%B6%B2%E5%8D%80%E5%A1%8A%E9%8F%88%E6%99%BA%E8%83%BD%E5%90%88%E7%B4%84-4a96d35ad1e1)
-- [Nethereum – Eine Open-Source-.NET-Integrationsbibliothek für Blockchain](https://kauri.io/#collections/a%20hackathon%20survival%20guide/nethereum-an-open-source-.net-integration-library/)
+- [Nethereum, Erste Schritte](https://docs.nethereum.com/en/latest/getting-started/)
+- [Installation von VS Code Solidity](https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity)
+- [Ein Workflow für .NET-Entwickler zum Erstellen und Aufrufen von Ethereum Smart Contracts](https://medium.com/coinmonks/a-net-developers-workflow-for-creating-and-calling-ethereum-smart-contracts-44714f191db2)
+- [Integration von Smart Contracts mit Nethereum](https://kauri.io/#collections/Getting%20Started/smart-contracts-integration-with-nethereum/#smart-contracts-integration-with-nethereumm)
+- [Anbindung von .NET- und Ethereum-Blockchain-Smart-Contracts mit Nethereum](https://medium.com/my-blockchain-development-daily-journey/interfacing-net-and-ethereum-blockchain-smart-contracts-with-nethereum-2fa3729ac933), auch in [中文版](https://medium.com/my-blockchain-development-daily-journey/%E4%BD%BF%E7%94%A8nethereum%E9%80%A3%E6%8E%A5-net%E5%92%8C%E4%BB%A5%E5%A4%AA%E7%B6%B2%E5%8D%80%E5%A1%8A%E9%8F%88%E6%99%BA%E8%83%BD%E5%90%88%E7%B4%84-4a96d35ad1e1)
+- [Nethereum – Eine Open-Source-.NET-Integrationsbibliothek für die Blockchain](https://kauri.io/#collections/a%20hackathon%20survival%20guide/nethereum-an-open-source-.net-integration-library/)
- [Ethereum-Transaktionen mit Nethereum in eine SQL-Datenbank schreiben](https://medium.com/coinmonks/writing-ethereum-transactions-to-sql-database-using-nethereum-fd94e0e4fa36)
-- [Erfahren Sie, wie Sie Smart Contracts mit C# und VisualStudio einfach umsetzen können](https://koukia.ca/deploy-ethereum-smart-contracts-using-c-and-visualstudio-5be188ae928c)
+- [Sehen Sie, wie Sie Ethereum Smart Contracts einfach mit C# und VisualStudio bereitstellen können](https://koukia.ca/deploy-ethereum-smart-contracts-using-c-and-visualstudio-5be188ae928c)
**Möchten Sie die Einrichtung erst einmal überspringen und direkt zu den Beispielen gehen?**
-- [Playground](http://playground.nethereum.com/) – Interagieren Sie mit Ethereum und erfahren Sie, wie Sie Nethereum über den Browser nutzen
+- [Playground](http://playground.nethereum.com/) – Interagieren Sie mit Ethereum und lernen Sie, wie man Nethereum im Browser verwendet.
- Kontostand abfragen [C#](http://playground.nethereum.com/csharp/id/1001) [VB.NET](http://playground.nethereum.com/vb/id/2001)
- - ERC20-Smart-Contract-Kontostand abfragen [C#](http://playground.nethereum.com/csharp/id/1005) [VB.NET](http://playground.nethereum.com/vb/id/2004)
- - Ether auf ein Konto übertragen [C#](http://playground.nethereum.com/csharp/id/1003) [VB.NET](http://playground.nethereum.com/vb/id/2003)
+ - ERC20-Smart-Contract-Guthaben abfragen [C#](http://playground.nethereum.com/csharp/id/1005) [VB.NET](http://playground.nethereum.com/vb/id/2004)
+ - Ether auf ein Konto überweisen [C#](http://playground.nethereum.com/csharp/id/1003) [VB.NET](http://playground.nethereum.com/vb/id/2003)
- ... und mehr
## Artikel für Fortgeschrittene {#intermediate-articles}
-- [Nethereum – Arbeitsbuch/Beispielliste](http://docs.nethereum.com/en/latest/Nethereum.Workbooks/docs/)
-- [Eigene Entwickler-Testchains bereitstellen](https://github.com/Nethereum/Testchains)
-- [VSCode Codegen-Plug-in für Solidity](https://docs.nethereum.com/en/latest/nethereum-codegen-vscodesolidity/)
-- [Unity und Ethereum: warum und wie](https://www.raywenderlich.com/5509-unity-and-ethereum-why-and-how)
-- [ASP.NET Core-Web-API für Ethereum-dApps erstellen](https://tech-mint.com/blockchain/create-asp-net-core-web-api-for-ethereum-dapps/)
-- [Nethereum Web3 zur Implementierung eines Supply Chain-Tracking-Systems erstellen](http://blog.pomiager.com/post/using-nethereum-web3-to-implement-a-supply-chain-traking-system4)
-- [Nethereum-Blockverarbeitung](https://nethereum.readthedocs.io/en/latest/nethereum-block-processing-detail/), mit [C# Playground-Beispiel](http://playground.nethereum.com/csharp/id/1025)
-- [Nethereum Websocket Streaming](https://nethereum.readthedocs.io/en/latest/nethereum-subscriptions-streaming/)
+- [Nethereum-Arbeitsmappe/Beispielliste](http://docs.nethereum.com/en/latest/Nethereum.Workbooks/docs/)
+- [Stellen Sie Ihre eigenen Entwicklungs-Testchains bereit](https://github.com/Nethereum/Testchains)
+- [VSCode-Codegen-Plugin für Solidity](https://docs.nethereum.com/en/latest/nethereum-codegen-vscodesolidity/)
+- [Unity und Ethereum: Warum und Wie](https://www.raywenderlich.com/5509-unity-and-ethereum-why-and-how)
+- [Erstellen einer ASP.NET Core Web API für Ethereum-Dapps](https://tech-mint.com/blockchain/create-asp-net-core-web-api-for-ethereum-dapps/)
+- [Verwendung von Nethereum Web3 zur Implementierung eines Lieferketten-Verfolgungssystems](http://blog.pomiager.com/post/using-nethereum-web3-to-implement-a-supply-chain-traking-system4)
+- [Nethereum-Blockverarbeitung](https://nethereum.readthedocs.io/en/latest/nethereum-block-processing-detail/), mit [C#-Playground-Beispiel](http://playground.nethereum.com/csharp/id/1025)
+- [Nethereum-Websocket-Streaming](https://nethereum.readthedocs.io/en/latest/nethereum-subscriptions-streaming/)
- [Kaleido und Nethereum](https://kaleido.io/kaleido-and-nethereum/)
- [Quorum und Nethereum](https://github.com/Nethereum/Nethereum/blob/master/src/Nethereum.Quorum/README.md)
@@ -60,27 +60,27 @@ Benötigen Sie für den Einstieg erst einmal allgemeinere Informationen? Dann em
- [Azure Key Vault und Nethereum](https://github.com/Azure-Samples/bc-community-samples/tree/master/akv-nethereum)
- [Nethereum.DappHybrid](https://github.com/Nethereum/Nethereum.DappHybrid)
-- [Ujo Nethereum-Backend-Referenzarchitektur](https://docs.nethereum.com/en/latest/nethereum-ujo-backend-sample/)
+- [Ujo-Nethereum-Backend-Referenzarchitektur](https://docs.nethereum.com/en/latest/nethereum-ujo-backend-sample/)
-## .NET-Projekte, Tools und andere interessante Dinge {#dot-net-projects-tools-and-other-fun-stuff}
+## .NET-Projekte, Tools und andere tolle Dinge {#dot-net-projects-tools-and-other-fun-stuff}
-- [Nethereum-Playground](http://playground.nethereum.com/) – _Nethereum-Code-Snippets im Browser kompilieren, erstellen und ausführen_
-- [Nethereum Codegen Blazor](https://github.com/Nethereum/Nethereum.CodeGen.Blazor) – _Nethereum-Codegenerator mit UI in Blazor_
-- [Nethereum Blazor](https://github.com/Nethereum/NethereumBlazor) – _Ein .NET Wasm SPA Light-Blockchain-Explorer und einfache Wallet_
-- [Wonka Business Rules Engine](https://docs.nethereum.com/en/latest/wonka/) – _Eine Business Rules-Engine (für die .NET-Plattform und die Ethereum-Plattform), die von Natur aus Metadaten-basiert ist_
-- [Nethermind](https://github.com/NethermindEth/nethermind) - _Ein .NET Core Ethereum-Client für Linux, Windows, MacOs_
-- [eth-utils](https://github.com/ethereum/eth-utils/) – _Dienstprogrammfunktionen für das Arbeiten mit Codebasen, die mit Ethereum verwandt sind_
-- [TestChains](https://github.com/Nethereum/TestChains) – _vorkonfigurierte .NET-Devchains für schnelles Feedback (PoA)_
+- [Nethereum Playground](http://playground.nethereum.com/) – _Kompilieren, Erstellen und Ausführen von Nethereum-Code-Snippets im Browser_
+- [Nethereum Codegen Blazor](https://github.com/Nethereum/Nethereum.CodeGen.Blazor) – _Nethereum-Codegen mit Benutzeroberfläche in Blazor_
+- [Nethereum Blazor](https://github.com/Nethereum/NethereumBlazor) – _Ein schlanker .NET Wasm SPA Blockchain-Explorer und eine einfache Wallet_
+- [Wonka Business Rules Engine](https://docs.nethereum.com/en/latest/wonka/) – _Eine Business-Rules-Engine (sowohl für die .NET- als auch für die Ethereum-Plattform), die von Natur aus metadatengesteuert ist_
+- [Nethermind](https://github.com/NethermindEth/nethermind) – _Ein .NET-Core-Ethereum-Client für Linux, Windows und macOS_
+- [eth-utils](https://github.com/ethereum/eth-utils/) – _Hilfsfunktionen für die Arbeit mit Ethereum-bezogenen Codebasen_
+- [TestChains](https://github.com/Nethereum/TestChains) – _Vorkonfigurierte .NET-Devchains für schnelle Antwortzeiten (PoA)_
-Sind Sie an weiteren Informationen interessiert? Sehen Sie sich [ethereum.org/developers](/developers/) an.
+Sind Sie an weiteren Informationen interessiert? Schauen Sie sich [ethereum.org/developers](/developers/) an.
-## .NET-Community-Mitwirkende {#dot-net-community-contributors}
+## Mitwirkende der .NET-Community {#dot-net-community-contributors}
-Bei Nethereum halten wir uns meistens bei [Gitter](https://gitter.im/Nethereum/Nethereum) auf, wo jeder gerne Fragen stellen oder beantworten, Hilfe bekommen oder einfach nur beobachten kann. Erstellen Sie gerne einen PR oder öffnen ein Problem im [Nethereum Github Repository](https://github.com/Nethereum) oder durchstöbern Sie einfach nur unsere vielen Seiten/Beispielprojekte. Sie können uns auch auf [Discord](https://discord.gg/jQPrR58FxX) finden.
+Bei Nethereum sind wir meistens auf [Gitter](https://gitter.im/Nethereum/Nethereum) zu finden, wo jeder willkommen ist, Fragen zu stellen und zu beantworten, Hilfe zu erhalten oder einfach nur dabei zu sein. Erstellen Sie gerne einen PR oder eröffnen Sie ein Issue im [Nethereum-GitHub-Repository](https://github.com/Nethereum), oder stöbern Sie einfach durch die vielen Neben- und Beispielprojekte, die wir haben. Sie finden uns auch auf [Discord](https://discord.gg/jQPrR58FxX)!
-Wenn Sie neu bei Nethermind sind und Hilfe beim Einstieg benötigen, treten Sie unserem [Discord](http://discord.gg/PaCMRFdvWT) bei. Unsere Entwickler stehen Ihnen gerne bei Fragen zur Verfügung. Zögern Sie nicht, einen PR zu eröffnen oder Probleme im [Nethermind GitHub-Repository](https://github.com/NethermindEth/nethermind) aufzuzeigen.
+Wenn Sie neu bei Nethermind sind und Hilfe bei den ersten Schritten benötigen, treten Sie unserem [Discord](http://discord.gg/PaCMRFdvWT) bei. Unsere Entwickler stehen Ihnen gerne bei Fragen zur Verfügung. Zögern Sie nicht, einen PR zu eröffnen oder im [Nethermind-GitHub-Repository](https://github.com/NethermindEth/nethermind) Issues zu melden.
## Andere zusammengefasste Listen {#other-aggregated-lists}
-[Offizielle Nethereum-Seite](https://nethereum.com/)
-[Offizielle Nethermind-Seite](https://nethermind.io/)
+[Offizielle Nethereum-Website](https://nethereum.com/)
+[Offizielle Nethermind-Website](https://nethermind.io/)
diff --git a/public/content/translations/de/developers/docs/programming-languages/elixir/index.md b/public/content/translations/de/developers/docs/programming-languages/elixir/index.md
new file mode 100644
index 00000000000..0105be9105f
--- /dev/null
+++ b/public/content/translations/de/developers/docs/programming-languages/elixir/index.md
@@ -0,0 +1,55 @@
+---
+title: Ethereum für Elixir-Entwickler
+description: Lernen Sie, wie Sie für Ethereum entwickeln, mit Elixir-basierten Projekten und Werkzeugen.
+lang: de
+incomplete: false
+---
+
+Lernen Sie, wie Sie für Ethereum entwickeln, mit Elixir-basierten Projekten und Werkzeugen.
+
+Sie können mit Ethereum dezentrale Anwendungen (oder „dApps“) erstellen, die von den Vorteilen der Kryptowährung und der Blockchain-Technologie profitieren. Solche dApps sind vertrauenswürdig. Das bedeutet, dass sie, sobald sie auf Ethereum hochgeladen wurden, immer exakt wie programmiert ausgeführt werden. Darüber lassen sich digitale Vermögenswerte verwalten und neuartige Finanzanwendungen erschaffen. Sie können dezentralisiert sein. Das bedeutet, dass keine einzelne Einheit oder Person sie kontrollieren kann. Damit ist es fast unmöglich, sie zu zensieren.
+
+## Erste Schritte mit Smart Contracts und der Sprache Solidity {#getting-started-with-smart-contracts-and-solidity}
+
+**Starten Sie Ihre ersten Schritte, um Elixir in Ethereum-Projekte zu integrieren.**
+
+Sind Sie an einigen grundlegenden Informationen interessiert? Besuchen Sie [ethereum.org/learn](/learn/) oder [ethereum.org/developers](/developers/).
+
+- [Blockchain erklärt](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [Smart Contracts verstehen](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [Schreiben Sie Ihren ersten Smart Contract](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
+- [Lernen Sie Solidity zu kompilieren und bereitstellen](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+
+## Artikel für Anfänger {#beginner-articles}
+
+- [Ethereum-Accounts endlich verstehen](https://dev.to/q9/finally-understanding-ethereum-accounts-1kpe)
+- [Ethers — Eine erstklassige Ethereum-Web3-Bibliothek für Elixir](https://medium.com/@alisinabh/announcing-ethers-a-first-class-ethereum-web3-library-for-elixir-1d64e9409122)
+
+## Artikel für Fortgeschrittene {#intermediate-articles}
+
+- [Wie Sie rohe Ethereum-Contract-Transaktionen mit Elixir signieren](https://kohlerjp.medium.com/how-to-sign-raw-ethereum-contract-transactions-with-elixir-f8822bcc813b)
+- [Ethereum Smart Contracts und Elixir](https://medium.com/agile-alpha/ethereum-smart-contracts-and-elixir-c7c4b239ddb4)
+
+## Elixir Projekte und Werkzeuge {#elixir-projects-and-tools}
+
+### Aktiv {#active}
+
+- [block_keys](https://github.com/ExWeb3/block_keys) - _BIP32 & BIP44 Implementation in Elixir (Multi-Account Hierarchy for Deterministic Wallets)_
+- ethereumex](https://github.com/mana-ethereum/ethereumex) - _Elixir JSON-RPC client for the Ethereum blockchain_
+- ethers](https://github.com/ExWeb3/elixir_ethers) - _A comprehensive Web3 library for interacting with smart contracts on Ethereum using Elixir_
+- [ethers_kms](https://github.com/ExWeb3/elixir_ethers_kms) - _A KMS signer library for Ethers (sign transactions with AWS KMS)_
+- [ex_abi](https://github.com/poanetwork/ex_abi) - _Ethereum ABI parser/decoder/encoder implementation in Elixir_
+- [ex_keccak](https://github.com/ExWeb3/ex_keccak) - _Elixir library for computing Keccak SHA3-256 hashes using a NIF built tiny-keccak Rust crate_
+- ex_rlp](https://github.com/mana-ethereum/ex_rlp) - _Elixir implementation of Ethereum's RLP (Recursive Length Prefix) encoding_
+
+### Archiviert / Wird nicht mehr gepflegt {#archived--no-longer-maintained}
+
+- [eth](https://hex.pm/packages/eth) - _Ethereum utilities for Elixir_
+- [exw3](https://github.com/hswick/exw3) - _High level Ethereum RPC Client for Elixir_
+- [mana](https://github.com/mana-ethereum/mana) - _Ethereum full node implementation written in Elixir_
+
+Sind Sie an weiteren Informationen interessiert? Besuchen Sie [unser Entwickler-Portal](/developers/).
+
+## Elixir Community Mitwirkende {#elixir-community-contributors}
+
+Der [Elixir's Slack #ethereum channel](https://elixir-lang.slack.com/archives/C5RPZ3RJL) bietet einer schnell wachsenden Community ein Zuhause und ist die Anlaufstelle für alle Diskussionen rund um die genannten Projekte und verwandte Themen.
diff --git a/public/content/translations/de/developers/docs/programming-languages/golang/index.md b/public/content/translations/de/developers/docs/programming-languages/golang/index.md
index 42bb427ee95..8c92290938f 100644
--- a/public/content/translations/de/developers/docs/programming-languages/golang/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/golang/index.md
@@ -5,80 +5,80 @@ lang: de
incomplete: true
---
-Lernen, wie Sie mit Go-basierten Projekten und Werkzeugen für Ethereum entwickeln können
+Lernen Sie, wie Sie mit Go-basierten Projekten und Tools für Ethereum entwickeln
Verwenden Sie Ethereum, um dezentrale Anwendungen (oder "dApps") zu erstellen. Solche dApps sind vertrauenswürdig. Das bedeutet, dass sie, sobald sie auf Ethereum hochgeladen wurden, immer exakt wie programmiert ausgeführt werden. Sie sind dezentralisiert. Das bedeutet, dass sie auf einem Peer-to-Peer-Netzwerk laufen und es keine einzelne Fehlerquelle gibt. Keine einzelne Eintität oder Person kontrolliert sie und es ist fast unmöglich, sie zu zensieren. Sie können digitale Vermögenswerte kontrollieren, um neue Arten von Anwendungen zu erstellen.
-## Erste Schritte mit Smart Contracts und der Solidity-Sprache {#getting-started-with-smart-contracts-and-solidity}
+## Erste Schritte mit Smart Contracts und der Sprache Solidity {#getting-started-with-smart-contracts-and-solidity}
**Starten Sie mit der Integration von Go mit Ethereum durch**
-Sind Sie an einigen grundlegenden Informationen interessiert? Dann sehen Sie sich auf [ethereum.org/learn](/learn/) oder [ethereum.org/developers](/developers/) um.
+Sind Sie an einigen grundlegenden Informationen interessiert? Besuchen Sie [ethereum.org/learn](/learn/) oder [ethereum.org/developers](/developers/).
- [Blockchain erklärt](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
- [Smart Contracts verstehen](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
-- [Den ersten Smart Contract schreiben](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
-- [Kompilieren und Bereitstellen von Solidity Code lernen](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [Schreiben Sie Ihren ersten Smart Contract](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
+- [Lernen Sie Solidity zu kompilieren und bereitstellen](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
- [Vertrags-Tutorial](https://github.com/ethereum/go-ethereum/wiki/Contract-Tutorial)
-## Artikel und Bücher für Einsteiger {#beginner-articles-and-books}
+## Artikel und Bücher für Anfänger {#beginner-articles-and-books}
- [Erste Schritte mit Geth](https://medium.com/@tzhenghao/getting-started-with-geth-c1a30b8d6458)
-- [Golang für die Verbindung mit Ethereum verwenden](https://www.youtube.com/watch?v=-7uChuO_VzM)
-- [Ethereum-Smart Contracts mit Golang bereitstellen](https://www.youtube.com/watch?v=pytGqQmDslE)
-- [Eine Schritt-für-Schritt-Anleitung zum Testen und Verteilen von Ethereum Smart Contracts in Go](https://hackernoon.com/a-step-by-step-guide-to-testing-and-deploying-ethereum-smart-contracts-in-go-9fc34b178d78)
+- [Mit Golang mit Ethereum verbinden](https://www.youtube.com/watch?v=-7uChuO_VzM)
+- [Ethereum Smart Contracts mit Golang bereitstellen](https://www.youtube.com/watch?v=pytGqQmDslE)
+- [Eine Schritt-für-Schritt-Anleitung zum Testen und Bereitstellen von Ethereum Smart Contracts in Go](https://hackernoon.com/a-step-by-step-guide-to-testing-and-deploying-ethereum-smart-contracts-in-go-9fc34b178d78)
- [eBook: Ethereum-Entwicklung mit Go](https://goethereumbook.org/) – _Ethereum-Anwendungen mit Go entwickeln_
-## Artikel und Dokumente für Fortgeschrittene {#intermediate-articles-and-docs}
+## Artikel und Dokumentationen für Fortgeschrittene {#intermediate-articles-and-docs}
-- [Go-Ethereum-Dokumentation](https://geth.ethereum.org/docs/) – _Die Dokumentation für die offizielle Ethereum-Golang_
-- [Leitfaden für Erigon-Programmierer](https://github.com/ledgerwatch/erigon/blob/devel/docs/programmers_guide/guide.md) - _Illustrierter Leitfaden, einschließlich Zustandsbaum, Multi-Beweise und die Transaktionsverarbeitung_
-- [Erigon und zustandsloses Ethereum](https://youtu.be/3-Mn7OckSus?t=394) - _2020 Ethereum Community-Konferenz (EthCC 3)_
-- [Erigon: Optimierung von Ethereum-Clients](https://www.youtube.com/watch?v=CSpc1vZQW2Q) - _2018 Devcon 4_
+- [Go-Ethereum-Dokumentation](https://geth.ethereum.org/docs/) – _Die Dokumentation für das offizielle Ethereum Golang_
+- [Erigon Programmierleitfaden](https://github.com/ledgerwatch/erigon/blob/devel/docs/programmers_guide/guide.md) – _Illustrierter Leitfaden mit Zustandsbaum, Multi-Proofs und Transaktionsverarbeitung_
+- [Erigon und zustandsloses Ethereum](https://youtu.be/3-Mn7OckSus?t=394) – _Ethereum Community Conference 2020 (EthCC 3)_
+- [Erigon: Optimierung von Ethereum-Clients](https://www.youtube.com/watch?v=CSpc1vZQW2Q) – _Devcon 4, 2018_
- [Go Ethereum GoDoc](https://godoc.org/github.com/ethereum/go-ethereum)
-- [Erstellen einer dApp in Go mit Geth](https://kauri.io/#collections/A%20Hackathon%20Survival%20Guide/creating-a-dapp-in-go-with-geth/)
-- [Mit einem privaten Ethereum-Netzwerk in Golang und Geth arbeiten](https://myhsts.org/tutorial-learn-how-to-work-with-ethereum-private-network-with-golang-with-geth.php)
-- [Einheitentests für Solidity-Verträge auf Ethereum mit Go](https://medium.com/coinmonks/unit-testing-solidity-contracts-on-ethereum-with-go-3cc924091281)
-- [Schnellreferenz für die Verwendung von Geth als Bibliothek](https://medium.com/coinmonks/web3-go-part-1-31c68c68e20e)
+- [Erstellen einer Dapp in Go mit Geth](https://kauri.io/#collections/A%20Hackathon%20Survival%20Guide/creating-a-dapp-in-go-with-geth/)
+- [Arbeiten mit einem privaten Ethereum-Netzwerk mit Golang und Geth](https://myhsts.org/tutorial-learn-how-to-work-with-ethereum-private-network-with-golang-with-geth.php)
+- [Unit-Tests für Solidity-Verträge auf Ethereum mit Go](https://medium.com/coinmonks/unit-testing-solidity-contracts-on-ethereum-with-go-3cc924091281)
+- [Kurzanleitung zur Verwendung von Geth als Bibliothek](https://medium.com/coinmonks/web3-go-part-1-31c68c68e20e)
## Fortgeschrittene Nutzungsmuster {#advanced-use-patterns}
-- [Das GETH-simulierte Backend](https://kauri.io/#collections/An%20ethereum%20test%20toolkit%20in%20Go/the-geth-simulated-backend/#_top)
+- [Das simulierte GETH-Backend](https://kauri.io/#collections/An%20ethereum%20test%20toolkit%20in%20Go/the-geth-simulated-backend/#_top)
- [Blockchain-as-a-Service-Apps mit Ethereum und Quorum](https://blockchain.dcwebmakers.com/blockchain-as-a-service-apps-using-ethereum-and-quorum.html)
-- [Verteilte Speicher-IPFS und Swarm in Ethereum-Blockchain-Anwendungen](https://blockchain.dcwebmakers.com/work-with-distributed-storage-ipfs-and-swarm-in-ethereum.html)
-- [Mobile Clients: Bibliotheken und Inproc-Ethereum-Nodes](https://github.com/ethereum/go-ethereum/wiki/Mobile-Clients:-Libraries-and-Inproc-Ethereum-Nodes)
-- [Native dAapps: Go-Bindings für Ethereum-Verträge](https://github.com/ethereum/go-ethereum/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts)
+- [Verteilter Speicher IPFS und Swarm in Ethereum-Blockchain-Anwendungen](https://blockchain.dcwebmakers.com/work-with-distributed-storage-ipfs-and-swarm-in-ethereum.html)
+- [Mobile Clients: Bibliotheken und Inproc-Ethereum-Knoten](https://github.com/ethereum/go-ethereum/wiki/Mobile-Clients:-Libraries-and-Inproc-Ethereum-Nodes)
+- [Native Dapps: Go-Bindings für Ethereum-Verträge](https://github.com/ethereum/go-ethereum/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts)
-## Go-Projekte und Tools {#go-projects-and-tools}
+## Go-Projekte und -Tools {#go-projects-and-tools}
-- [Geth/Go Ethereum](https://github.com/ethereum/go-ethereum) - _Offizielle Go-Implementierung des Ethereum-Protokolls_
-- [Go Ethereum-Codeanalyse](https://github.com/ZtesoftCS/go-ethereum-code-analysis) – _Überprüfung und Analyse des Go Ethereum-Quellcodes_
-- [Erigon](https://github.com/ledgerwatch/erigon) - _Eine schnellere Variante von Go Ethereum mit Schwerpunkt auf Archivierungsknoten_
+- [Geth / Go Ethereum](https://github.com/ethereum/go-ethereum) – _Offizielle Go-Implementierung des Ethereum-Protokolls_
+- [Go Ethereum Code-Analyse](https://github.com/ZtesoftCS/go-ethereum-code-analysis) – _Überprüfung und Analyse des Go Ethereum-Quellcodes_
+- [Erigon](https://github.com/ledgerwatch/erigon) – _Eine schnellere Variante von Go Ethereum mit Schwerpunkt auf Archivierungsknoten_
- [Golem](https://github.com/golemfactory/golem) – _Golem schafft einen globalen Markt für Rechenleistung_
-- [Quorum](https://github.com/jpmorganchase/quorum) – _Eine private Implementierung von Ethereum, die Datenprivatsphäre unterstützt_
-- [Prysm](https://github.com/prysmaticlabs/prysm) – _Ethereum 'Serenity' 2.0 Go-Implementation_
-- [Eth Tweet](https://github.com/yep/eth-tweet) – _Dezentralisiertes Twitter: ein Microblogging-Service, der auf der Ethereum-Blockchain läuft_
-- [Plasma MVP Golang](https://github.com/kyokan/plasma) – _Golang-Implementierung und Erweiterung der Minimal Viable Plasma-Spezifikation_
-- [Offener Ethereum-Mining-Pool](https://github.com/sammy007/open-ethereum-pool) – _Ein Open-Source-Ethereum-Mining-Pool_
-- [Ethereum-HD Wallet](https://github.com/miguelmota/go-ethereum-hdwallet) – _Ethereum-HD Wallet Derivate im Go_
+- [Quorum](https://github.com/jpmorganchase/quorum) – _Eine zugangsbeschränkte Implementierung von Ethereum, die den Datenschutz unterstützt_
+- [Prysm](https://github.com/prysmaticlabs/prysm) – _Go-Implementierung von Ethereum „Serenity“ 2.0_
+- [Eth Tweet](https://github.com/yep/eth-tweet) – _Dezentralisiertes Twitter: Ein Microblogging-Dienst, der auf der Ethereum-Blockchain läuft_
+- [Plasma MVP Golang](https://github.com/kyokan/plasma) — _Golang-Implementierung und Erweiterung der Minimum Viable Plasma-Spezifikation_
+- [Open Ethereum Mining-Pool](https://github.com/sammy007/open-ethereum-pool) – _Ein Open-Source-Ethereum-Mining-Pool_
+- [Ethereum-HD-Wallet](https://github.com/miguelmota/go-ethereum-hdwallet) – _Ableitungen für Ethereum-HD-Wallets in Go_
- [Multi Geth](https://github.com/multi-geth/multi-geth) – _Unterstützung für viele Arten von Ethereum-Netzwerken_
-- [Geth Light Client](https://github.com/zsfelfoldi/go-ethereum/wiki/Geth-Light-Client) – _Light Ethereum-Subprotokoll-Geth-Implementierung_
-- [Ethereum Golang SDK](https://github.com/everFinance/goether) - _Eine einfache Ethereum-Wallet-Implementierung und Hilfsprogramme in Golang_
-- [Covalent Golang SDK](https://github.com/covalenthq/covalent-api-sdk-go) – _effizienter Blockchain-Datenzugriff via Go SDK für über 200 Blockchains_
+- [Geth Light Client](https://github.com/zsfelfoldi/go-ethereum/wiki/Geth-Light-Client) – _Geth-Implementierung des Light Ethereum Subprotocol_
+- [Ethereum Golang SDK](https://github.com/everFinance/goether) – _Eine einfache Ethereum-Wallet-Implementierung und Dienstprogramme in Golang_
+- [Covalent Golang SDK](https://github.com/covalenthq/covalent-api-sdk-go) – _Effizienter Zugriff auf Blockchain-Daten über das Go-SDK für über 200 Blockchains_
-Sind Sie an weiteren Informationen interessiert? Sehen Sie sich [ethereum.org/developers](/developers/) an.
+Sind Sie an weiteren Informationen interessiert? Besuchen Sie [ethereum.org/developers](/developers/)
-## Go-Community-Mitwirkende {#go-community-contributors}
+## Mitwirkende der Go-Community {#go-community-contributors}
- [Geth Discord](https://discordapp.com/invite/nthXNEv)
- [Geth Gist](https://gitter.im/ethereum/go-ethereum)
-- [Gophers Slack](https://invite.slack.golangbridge.org/) – [#ethereum channel](https://gophers.slack.com/messages/C9HP1S9V2)
+- [Gophers Slack](https://invite.slack.golangbridge.org/) – [Kanal #ethereum](https://gophers.slack.com/messages/C9HP1S9V2)
- [StackExchange – Ethereum](https://ethereum.stackexchange.com/)
- [Multi Geth Gitter](https://gitter.im/ethoxy/multi-geth)
- [Ethereum Gitter](https://gitter.im/ethereum/home)
-- [Geth light Client Gitter](https://gitter.im/ethereum/light-client)
+- [Geth Light Client Gitter](https://gitter.im/ethereum/light-client)
## Andere zusammengefasste Listen {#other-aggregated-lists}
- [Awesome Ethereum](https://github.com/btomashvili/awesome-ethereum)
-- [Consensys: eine maßgebliche Liste der Ethereum-Entwicklertools](https://media.consensys.net/an-definitive-list-of-ethereum-developer-tools-2159ce865974) | [GitHub-Quelle](https://github.com/ConsenSys/ethereum-developer-tools-list)
+- [Consensys: Eine endgültige Liste von Ethereum-Entwickler-Tools](https://media.consensys.net/an-definitive-list-of-ethereum-developer-tools-2159ce865974) | [GitHub-Quelle](https://github.com/ConsenSys/ethereum-developer-tools-list)
diff --git a/public/content/translations/de/developers/docs/programming-languages/index.md b/public/content/translations/de/developers/docs/programming-languages/index.md
index 719f7cdcf48..1a2899b4301 100644
--- a/public/content/translations/de/developers/docs/programming-languages/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/index.md
@@ -1,20 +1,22 @@
---
title: Programmiersprachen
-description:
+description: Entdecken Sie Ethereum-Entwicklungsressourcen für verschiedene Programmiersprachen, darunter JavaScript, Python, Go, Rust und mehr.
lang: de
---
-Ein häufiges Missverständnis ist, dass Entwickler [Smart Contracts](/developers/docs/smart-contracts/) schreiben müssen, um auf Ethereum aufzubauen. Doch das ist falsch. Einer der Vorteile des Ethereum-Netzwerks und der Ethereum-Community besteht darin, dass es möglich ist, in jeder Programmiersprache am Netzwerk und der Community [teilzunehmen](/community/).
+Ein häufiges Missverständnis ist, dass Entwickler [Smart Contracts](/developers/docs/smart-contracts/) schreiben müssen, um auf Ethereum aufzubauen. Doch das ist falsch.
+Einer der Vorteile des Ethereum-Netzwerks und der Community ist, dass man in so ziemlich jeder Programmiersprache [teilnehmen](/community/) kann.
Die Community von Ethereum und Ethereum selbst ist offen für Open Source, also Quelloffenheit. Zu finden sind Community Projekte – Kundenumsetzungen, APIs (Programmierschnittstellen), Entwickleroberflächen, Tools zu Testzwecken – in einer großen Auswahl an Sprachen.
-## Ihre Sprache wählen {#data}
+## Wählen Sie Ihre Sprache {#data}
Wählen Sie eine Programmiersprache, um Projekte, Ressourcen und virtuelle Communitys zu finden:
- [Ethereum für Dart-Entwickler](/developers/docs/programming-languages/dart/)
- [Ethereum für Delphi-Entwickler](/developers/docs/programming-languages/delphi/)
- [Ethereum für .NET-Entwickler](/developers/docs/programming-languages/dot-net/)
+- [Ethereum für Elixir-Entwickler](/developers/docs/programming-languages/elixir/)
- [Ethereum für Go-Entwickler](/developers/docs/programming-languages/golang/)
- [Ethereum für Java-Entwickler](/developers/docs/programming-languages/java/)
- [Ethereum für JavaScript-Entwickler](/developers/docs/programming-languages/javascript/)
@@ -26,4 +28,5 @@ Wählen Sie eine Programmiersprache, um Projekte, Ressourcen und virtuelle Commu
Wenn Sie auf Ressourcen verlinken oder auf eine virtuelle Gemeinschaft für eine weitere Programmiersprache hinweisen möchten, können Sie eine neue Seite beantragen, indem Sie [ein Thema eröffnen](https://github.com/ethereum/ethereum-org-website/issues/new/choose).
-Wenn Sie nur Code schreiben möchten, um mit einer derzeit nicht unterstützten Sprache mit der Blockchain zu kommunizieren, können Sie die [JSON-RPC-Schnittstelle](/developers/docs/apis/json-rpc/) verwenden, um sich mit dem Ethereum-Netzwerk zu verbinden. Jede Programmiersprache, die TCP/IP verwenden kann, kann diese Schnittstelle nutzen.
+Wenn Sie nur Code schreiben möchten, um mit einer derzeit nicht unterstützten Sprache mit der Blockchain zu kommunizieren,
+können Sie die [JSON-RPC-Schnittstelle](/developers/docs/apis/json-rpc/) verwenden, um sich mit dem Ethereum-Netzwerk zu verbinden. Jede Programmiersprache, die TCP/IP verwenden kann, kann diese Schnittstelle nutzen.
diff --git a/public/content/translations/de/developers/docs/programming-languages/java/index.md b/public/content/translations/de/developers/docs/programming-languages/java/index.md
index 6bd66f3d937..b573d6f5341 100644
--- a/public/content/translations/de/developers/docs/programming-languages/java/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/java/index.md
@@ -5,59 +5,60 @@ lang: de
incomplete: true
---
-Lernen, wie Sie mit Java-basierten Projekten und Werkzeugen für Ethereum entwickeln können
+Lernen Sie, wie Sie mit Java-basierten Projekten und Tools für Ethereum entwickeln
Sie können mit Ethereum dezentrale Anwendungen (oder „dApps“) erstellen, die von den Vorteilen der Kryptowährung und der Blockchain-Technologie profitieren. Solche dApps sind vertrauenswürdig. Das bedeutet, dass sie, sobald sie auf Ethereum hochgeladen wurden, immer exakt wie programmiert ausgeführt werden. Darüber lassen sich digitale Vermögenswerte verwalten und neuartige Finanzanwendungen erschaffen. Sie können dezentralisiert sein. Das bedeutet, dass keine einzelne Einheit oder Person sie kontrollieren kann. Damit ist es fast unmöglich, sie zu zensieren.
-## Erste Schritte mit Smart Contracts und der Solidity-Sprache {#getting-started-with-smart-contracts-and-solidity}
+## Erste Schritte mit Smart Contracts und der Sprache Solidity {#getting-started-with-smart-contracts-and-solidity}
**Erste Schritte bei der Integration von Java mit Ethereum**
-Sind Sie an einigen grundlegenden Informationen interessiert? Dann sehen Sie sich auf [ethereum.org/learn](/learn/) oder [ethereum.org/developers](/developers/) um.
+Sind Sie an einigen grundlegenden Informationen interessiert? Besuchen Sie [ethereum.org/learn](/learn/) oder [ethereum.org/developers.](/developers/)
- [Blockchain erklärt](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
- [Smart Contracts verstehen](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
-- [Den ersten Smart Contract schreiben](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
-- [Kompilieren und Bereitstellen von Solidity Code lernen](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [Schreiben Sie Ihren ersten Smart Contract](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
+- [Lernen Sie Solidity zu kompilieren und bereitstellen](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
-## Mit Ethereum Clients arbeiten {#working-with-ethereum-clients}
+## Arbeiten mit Ethereum-Clients {#working-with-ethereum-clients}
Lernen Sie, wie Sie [Web3J](https://github.com/web3j/web3j) und Hyperledger Besu, zwei führende Java-Ethereum-Clients, nutzen
- [Verbindung zu einem Ethereum-Client mit Java, Eclipse und Web3J](https://kauri.io/article/b9eb647c47a546bc95693acc0be72546/connecting-to-an-ethereum-client-with-java-eclipse-and-web3j)
-- [Ein Ethereum-Konto mit Java und Web3j verwalten](https://kauri.io/article/925d923e12c543da9a0a3e617be963b4/manage-an-ethereum-account-with-java-and-web3j)
-- [Einen Java-Wrapper aus Ihrem Smart Contract erstellen](https://kauri.io/article/84475132317d4d6a84a2c42eb9348e4b/generate-a-java-wrapper-from-your-smart-contract)
-- [Integration mit einem Ethereum-Smart Contact](https://kauri.io/article/14dc434d11ef4ee18bf7d57f079e246e/interacting-with-an-ethereum-smart-contract-in-java)
-- [Empfangsbereitschaft für Ethereum-Smart-Contract-Ereignisse](https://kauri.io/article/760f495423db42f988d17b8c145b0874/listening-for-ethereum-smart-contract-events-in-java)
-- [Besu (Pantheon), den Java-Ethereum-Client, mit Linux verwenden](https://kauri.io/article/276dd27f1458443295eea58403fd6965/using-pantheon-the-java-ethereum-client-with-linux)
-- [Einen Hyperledger-Besu-(Pantheon)-Node in Java-Integrationstests ausführen](https://kauri.io/article/7dc3ecc391e54f7b8cbf4e5fa0caf780/running-a-pantheon-node-in-java-integration-tests)
-- [Web3j Cheat Sheet](https://kauri.io/web3j-cheat-sheet-(java-ethereum)/5dfa1ea941ac3d0001ce1d90/c)
+- [Verwaltung eines Ethereum-Kontos mit Java und Web3j](https://kauri.io/article/925d923e12c543da9a0a3e617be963b4/manage-an-ethereum-account-with-java-and-web3j)
+- [Generieren eines Java-Wrappers aus Ihrem Smart Contract](https://kauri.io/article/84475132317d4d6a84a2c42eb9348e4b/generate-a-java-wrapper-from-your-smart-contract)
+- [Interagieren mit einem Ethereum Smart Contract](https://kauri.io/article/14dc434d11ef4ee18bf7d57f079e246e/interacting-with-an-ethereum-smart-contract-in-java)
+- [Warten auf Ethereum Smart Contract-Ereignisse](https://kauri.io/article/760f495423db42f988d17b8c145b0874/listening-for-ethereum-smart-contract-events-in-java)
+- [Verwendung von Besu (Pantheon), dem Java-Ethereum-Client, unter Linux](https://kauri.io/article/276dd27f1458443295eea58403fd6965/using-pantheon-the-java-ethereum-client-with-linux)
+- [Ausführen eines Hyperledger Besu (Pantheon)-Nodes in Java-Integrationstests](https://kauri.io/article/7dc3ecc391e54f7b8cbf4e5fa0caf780/running-a-pantheon-node-in-java-integration-tests)
+- [Web3j-Spickzettel](https://kauri.io/web3j-cheat-sheet-\(java-ethereum\)/5dfa1ea941ac3d0001ce1d90/c)
Lernen Sie, wie Sie [ethers-kt](https://github.com/Kr1ptal/ethers-kt) verwenden – eine asynchrone, hochleistungsfähige Kotlin-Bibliothek zur Interaktion mit EVM-basierten Blockchains. Ausgelegt für JVM und Android-Plattfomen.
-- [ERC20-Token übertragen](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/abi/TransferERC20.kt)
-- [UniswapV2-Tausch mit Ereignisüberwachung](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/tokenswapwitheventlistening/TokenSwapWithEventListening.kt)
-- [ETH-/ERC20-Saldo-Tracker](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/balancetracker/BalanceTracker.kt)
+
+- [Übertragen von ERC20-Tokens](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/abi/TransferERC20.kt)
+- [UniswapV2-Swap mit Ereignisüberwachung](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/tokenswapwitheventlistening/TokenSwapWithEventListening.kt)
+- [ETH / ERC20-Guthaben-Tracker](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/balancetracker/BalanceTracker.kt)
## Artikel für Fortgeschrittene {#intermediate-articles}
-- [Speicher in einer Java-Anwendung mit IPFS verwalten](https://kauri.io/article/3e8494f4f56f48c4bb77f1f925c6d926/managing-storage-in-a-java-application-with-ipfs)
-- [ERC20-Token in Java mit Web3j verwalten](https://kauri.io/article/d13e911bbf624108b1d5718175a5e0a0/manage-erc20-tokens-in-java-with-web3j)
+- [Speicherverwaltung in einer Java-Anwendung mit IPFS](https://kauri.io/article/3e8494f4f56f48c4bb77f1f925c6d926/managing-storage-in-a-java-application-with-ipfs)
+- [Verwaltung von ERC20-Tokens in Java mit Web3j](https://kauri.io/article/d13e911bbf624108b1d5718175a5e0a0/manage-erc20-tokens-in-java-with-web3j)
- [Web3j-Transaktionsmanager](https://kauri.io/article/4cb780bb4d0846438d11885a25b6d7e7/web3j-transaction-managers)
## Fortgeschrittene Nutzungsmuster {#advanced-use-patterns}
-- [Eventeum verwenden, um einen Java-Smart-Contract-Daten-Cache zu erstellen](https://kauri.io/article/fe81ee9612eb4e5a9ab72790ef24283d/using-eventeum-to-build-a-java-smart-contract-data-cache)
+- [Verwendung von Eventeum zum Erstellen eines Java-Smart-Contract-Datencaches](https://kauri.io/article/fe81ee9612eb4e5a9ab72790ef24283d/using-eventeum-to-build-a-java-smart-contract-data-cache)
-## Java-Projekte und Tools {#java-projects-and-tools}
+## Java-Projekte und -Tools {#java-projects-and-tools}
-- [Web3J (Bibliothek für Interaktion mit Ethereum-Clients)](https://github.com/web3j/web3j)
-- [ethers-kt (eine asynchrone, hochleistungsfähige Kotlin-/Java-/Android-Bibliothek für EVM-basierte Blockchains.)](https://github.com/Kr1ptal/ethers-kt)
-- [Eventeum (Event Listener)](https://github.com/ConsenSys/eventeum)
-- [Mahuta (IPFS-Entwicklertools)](https://github.com/ConsenSys/mahuta)
+- [Web3J (Bibliothek für die Interaktion mit Ethereum-Clients)](https://github.com/web3j/web3j)
+- [ethers-kt (Asynchrone, hochleistungsfähige Kotlin-/Java-/Android-Bibliothek für EVM-basierte Blockchains.)](https://github.com/Kr1ptal/ethers-kt)
+- [Eventeum (Event-Listener)](https://github.com/ConsenSys/eventeum)
+- [Mahuta (IPFS-Entwickler-Tools)](https://github.com/ConsenSys/mahuta)
-Sind Sie an weiteren Informationen interessiert? Sehen Sie sich [ethereum.org/developers](/developers/) an.
+Sind Sie an weiteren Informationen interessiert? Schauen Sie sich [ethereum.org/developers.](/developers/) an.
-## Java-Community-Mitwirkende {#java-community-contributors}
+## Mitwirkende der Java-Community {#java-community-contributors}
- [IO Builders](https://io.builders)
- [Kauri](https://kauri.io)
diff --git a/public/content/translations/de/developers/docs/programming-languages/javascript/index.md b/public/content/translations/de/developers/docs/programming-languages/javascript/index.md
index 4ac1dd46c30..817db545e85 100644
--- a/public/content/translations/de/developers/docs/programming-languages/javascript/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/javascript/index.md
@@ -4,35 +4,36 @@ description: Lernen, wie Sie JavaScript-basierte Projekte und Tools für die Eth
lang: de
---
-JavaScript ist eine der beliebtesten Sprachen im Ethereum-Ökosystem. Es gibt sogar ein [-Team](https://github.com/ethereumjs), das sich dafür einsetzt, so viel von Ethereum wie möglich auf JavaScript zu bringen.
+JavaScript ist eine der beliebtesten Sprachen im Ethereum-Ökosystem. Tatsächlich gibt es ein [Team](https://github.com/ethereumjs), das sich dafür einsetzt, so viel von Ethereum wie möglich auf JavaScript zu bringen.
-Es gibt Möglichkeiten, JavaScript (oder etwas Ahnliches) auf [allen Ebenen des Stacks](/developers/docs/ethereum-stack/) zu schreiben.
+Es gibt Möglichkeiten, JavaScript (oder etwas Ähnliches) auf [allen Ebenen des Stacks](/developers/docs/ethereum-stack/) zu schreiben.
## Mit Ethereum interagieren {#interact-with-ethereum}
### JavaScript-API-Bibliotheken {#javascript-api-libraries}
-Wenn Sie mit JavaScript Abfragen für die Blockchain, das Senden von Transaktionen und weitere Aktionen vornehmen möchten, ist es am einfachsten, dafür eine [JavaScript-API-Bibliothek](/developers/docs/apis/javascript/) zu verwenden. Diese APIs ermöglichen Entwicklern die einfache Interaktion mit den [Nodes im Ethereum-Netzwerk](/developers/docs/nodes-and-clients/).
+Wenn du JavaScript schreiben möchtest, um die Blockchain abzufragen, Transaktionen zu senden und mehr, ist die Verwendung einer [JavaScript-API-Bibliothek](/developers/docs/apis/javascript/) der bequemste Weg. Diese APIs ermöglichen es Entwicklern, einfach mit den [Nodes im Ethereum-Netzwerk](/developers/docs/nodes-and-clients/) zu interagieren.
Sie können diese Bibliotheken verwenden, um mit Smart Contracts auf Ethereum zu interagieren. Das ermöglicht es, eine dApp für Fälle zu erstellen, in denen Sie nur JavaScript verwenden, um mit bereits bestehenden Verträgen zu interagieren.
-**Wissenswertes**
+**Ansehen**
-- [Web3.js](https://web3js.readthedocs.io/)
-- [Ethers.js](https://docs.ethers.io/) _– beinhaltet die Implementierung von Ethereum-Wallets und -Utilities in JavaScript und TypeScript._
-- [Viem](https://viem.sh) – Eine TypeScript-Schnittstelle für Ethereum, die zustandslose Primitive auf unterer Ebene für die Interaktion mit Ethereum bereitstellt.
+- [Web3.js](https://web3js.readthedocs.io)
+- [Ethers.js](https://ethers.org) – _beinhaltet die Implementierung von Ethereum-Wallets und Utilities in JavaScript und TypeScript._
+- [viem](https://viem.sh) – _eine TypeScript-Schnittstelle für Ethereum, die zustandslose Low-Level-Primitive für die Interaktion mit Ethereum bereitstellt._
+- [Drift](https://ryangoree.github.io/drift/) – _eine TypeScript-Meta-Bibliothek mit integriertem Caching, Hooks und Test-Mocks für eine mühelose Ethereum-Entwicklung über Web3-Bibliotheken hinweg._
### Smart Contracts {#smart-contracts}
-Wenn Sie ein JavaScript-Entwickler sind und Ihren eigenen Smart Contract schreiben möchten, sollten Sie sich mit [Solidity](https://solidity.readthedocs.io) vertraut machen. Das ist die am weitesten verbreitete Smart-Contract-Sprache. Sie ist syntaktisch ähnlich wie JavaScript und erleichtert damit das Lernen.
+Wenn du ein JavaScript-Entwickler bist und deinen eigenen Smart Contract schreiben möchtest, solltest du dich mit [Solidity](https://solidity.readthedocs.io) vertraut machen. Das ist die am weitesten verbreitete Smart-Contract-Sprache. Sie ist syntaktisch ähnlich wie JavaScript und erleichtert damit das Lernen.
-Mehr erfahren über [Smart Contracts](/developers/docs/smart-contracts/).
+Mehr über [Smart Contracts](/developers/docs/smart-contracts/).
## Das Protokoll verstehen {#understand-the-protocol}
-### Die Ethereum-Virtual Machine (EVM) {#the-ethereum-virtual-machine}
+### Die Ethereum Virtual Machine {#the-ethereum-virtual-machine}
-Es gibt eine JavaScript-Implementierung der [Ethereum-Virtual Machine (EVM)](/developers/docs/evm/). Sie unterstützt die neuesten Fork-Regeln. Fork-Regeln beziehen sich auf Änderungen, die durch geplante Upgrades an EVM vorgenommen wurden.
+Es gibt eine JavaScript-Implementierung der [Ethereum Virtual Machine](/developers/docs/evm/). Sie unterstützt die neuesten Fork-Regeln. Fork-Regeln beziehen sich auf Änderungen, die durch geplante Upgrades an EVM vorgenommen wurden.
Aufteteilt wird sie in verschiedene JavaScript-Pakete. Die können Sie sich ansehen, um ein besseres Verständnis zu erlangen:
@@ -46,28 +47,26 @@ Auf diese Weise werden Fragen wie "Was ist die Datenstruktur eines Kontos?" leic
Wenn Sie sich lieber den geschriebenen Code durchlesen, ist dieses JavaScript eine gute Alternative, um sich all unsere Dokumente durchzulesen.
-**Sehen Sie sich das monorepo an**
-[`ethereumjs`](https://github.com/ethereumjs/ethereumjs-vm)
+**Schau dir die EVM an**
+[`@ethereumjs/evm`](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/evm)
-### Knotenpunkte (Nodes) und Anwendungen (Clients) {#nodes-and-clients}
+### Nodes und Clients {#nodes-and-clients}
Einer der Clients von Ethereum befindet sich derzeit in der aktiven Entwicklungsphase, sodass Sie einen Einblick in die Funktionsweise der Ethereum-Clients erhalten können, in einer Programmiersprache, die Sie verstehen: JavaScript!
-Früher wurde es auf unabhängigen [`Repositories`](https://github.com/ethereumjs/ethereumjs-client) aufgebaut, später wurde es jedoch als Paket in die Monorepo der virtuellen Maschine von Ethereum implementiert.
+**Schau dir den Client an**
+[`@ethereumjs/client`](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/client)
-**Sehen Sie sich den Client**
-[`ethereumjs-client`](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/client) an
-
-## Andere Projekte {#other-projects}
+## Weitere Projekte {#other-projects}
Im Bereich Ethereum-JavaScript gibt es noch weitere Neuerungen, darunter:
- Bibliotheken mit Wallet-Dienstprogrammen
- Tools zum Erstellen, Importieren und Exportieren von Ethereum-Schlüsseln
-- Eine Implementierung des `merkle-patricia-Baumes` – Eine Datenstruktur, die im Yellow-Paper von Ethereum skizziert wird.
+- eine Implementierung des `merkle-patricia-tree` – eine Datenstruktur, die im Ethereum Yellow Paper beschrieben wird.
-Forschen Sie in dem Bereich, der Sie am meisten interessiert, im [EthereumJS-Repository](https://github.com/ethereumjs)
+Tauche im [EthereumJS-Repo](https://github.com/ethereumjs) in das ein, was dich am meisten interessiert.
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
_Sie kennen Community-Resourcen die Ihnen geholfen haben? Bearbeiten Sie diese Seite und fügen Sie sie hinzu!_
diff --git a/public/content/translations/de/developers/docs/programming-languages/python/index.md b/public/content/translations/de/developers/docs/programming-languages/python/index.md
index 0ba8e42c693..dcb6cf77de9 100644
--- a/public/content/translations/de/developers/docs/programming-languages/python/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/python/index.md
@@ -1,90 +1,99 @@
---
title: Ethereum für Python-Entwickler
-description: Lernen, wie Sie mit Python-basierten Projekten und Tools für Ethereum entwickeln können
+description: Erfahre, wie du mit Python-basierten Projekten und Werkzeugen für Ethereum entwickeln kannst
lang: de
incomplete: true
---
-Erfahren Sie, wie Sie mit Python-basierten Projekten und Werkzeugen für Ethereum entwickeln können
+Lernen Sie, wie Sie mit Python-basierten Projekten und Tools für Ethereum entwickeln
-Sie können mit Ethereum dezentrale Anwendungen (oder "dApps") erstellen, die von den Vorteilen der Kryptowährung und der Blockchain-Technologie profitieren. Solche dApps sind vertrauenswürdig. Das bedeutet, dass sie, sobald sie auf Ethereum hochgeladen wurden, immer exakt wie programmiert ausgeführt werden. Darüber lassen sich digitale Vermögenswerte verwalten und neuartige Finanzanwendungen erschaffen. Sie können dezentralisiert sein. Das bedeutet, dass keine einzelne Einheit oder Person sie kontrollieren kann. Damit ist es fast unmöglich, sie zu zensieren.
+Sie können mit Ethereum dezentrale Anwendungen (oder „dApps“) erstellen, die von den Vorteilen der Kryptowährung und der Blockchain-Technologie profitieren. Solche dApps sind vertrauenswürdig. Das bedeutet, dass sie, sobald sie auf Ethereum hochgeladen wurden, immer exakt wie programmiert ausgeführt werden. Darüber lassen sich digitale Vermögenswerte verwalten und neuartige Finanzanwendungen erschaffen. Sie können dezentralisiert sein. Das bedeutet, dass keine einzelne Einheit oder Person sie kontrollieren kann. Damit ist es fast unmöglich, sie zu zensieren.
-## Erste Schritte mit Smart Contracts und der Solidity-Sprache {#getting-started-with-smart-contracts-and-solidity}
+## Erste Schritte mit Smart Contracts und der Sprache Solidity {#getting-started-with-smart-contracts-and-solidity}
**Starten Sie mit der Integration von Python mit Ethereum durch**
-Sind Sie an einigen grundlegenden Informationen interessiert? Dann sehen Sie sich auf [ethereum.org/learn](/learn/) oder [ethereum.org/developers](/developers/) um.
+Sind Sie an einigen grundlegenden Informationen interessiert? Besuchen Sie [ethereum.org/learn](/learn/) oder [ethereum.org/developers](/developers/).
- [Blockchain erklärt](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
- [Smart Contracts verstehen](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
-- [Den ersten Smart Contract schreiben](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
-- [Kompilieren und Bereitstellen von Solidity Code lernen](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [Schreiben Sie Ihren ersten Smart Contract](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
+- [Lernen Sie Solidity zu kompilieren und bereitstellen](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [Bericht über den Stand von Python in der Blockchain 2023](https://tradingstrategy.ai/blog/the-state-of-python-in-blockchain-in-2023)
-## Informationen für Einsteiger {#beginner-articles}
+## Artikel für Anfänger {#beginner-articles}
-- [Ein (Python)-Entwicklerhandbuch für Ethereum](https://snakecharmers.ethereum.org/a-developers-guide-to-ethereum-pt-1/)
-- [Bericht über den Zustand von Python im Jahr 2023](https://tradingstrategy.ai/blog/the-state-of-python-in-blockchain-in-2023)
+- [web3.py-Überblick](https://web3py.readthedocs.io/en/latest/overview.html)
+- [Tour durch das Ethereum-Python-Ökosystem](https://snakecharmers.ethereum.org/python-ecosystem/)
+- [Ein Leitfaden für (Python-)Entwickler zu Ethereum](https://snakecharmers.ethereum.org/a-developers-guide-to-ethereum-pt-1/)
+- [Preiswürdig: Ein Leitfaden für den Ethereum-Python-Hackathon](https://snakecharmers.ethereum.org/prize-worthy/)
- [Eine Einführung in Smart Contracts mit Vyper](https://kauri.io/#collections/Getting%20Started/an-introduction-to-smart-contracts-with-vyper/)
-- [Einen eigenen ERC20-Token mit Python und Brownie bereitstellen](https://betterprogramming.pub/python-blockchain-token-deployment-tutorial-create-an-erc20-77a5fd2e1a58)
- [Wie entwickelt man einen Ethereum-Vertrag mit Python Flask?](https://medium.com/coinmonks/how-to-develop-ethereum-contract-using-python-flask-9758fe65976e)
- [Einführung in Web3.py · Ethereum für Python-Entwickler](https://www.dappuniversity.com/articles/web3-py-intro)
- [Wie man eine Smart Contract-Funktion mit Python und web3.py aufruft](https://stackoverflow.com/questions/57580702/how-to-call-a-smart-contract-function-using-python-and-web3-py)
-## Vertiefende Artikel {#intermediate-articles}
+## Artikel für Fortgeschrittene {#intermediate-articles}
-- [dApp-Entwicklung für Python-Programmierer](https://levelup.gitconnected.com/dapps-development-for-python-developers-f52b32b54f28)
-- [Eine Python-Ethereum-Schnittstelle erstellen: Teil 1](https://hackernoon.com/creating-a-python-ethereum-interface-part-1-4d2e47ea0f4d)
-- [Ethereum-Smart Contracts in Python: ein umfassendes Tutorial](https://hackernoon.com/ethereum-smart-contracts-in-python-a-comprehensive-ish-guide-771b03990988)
-- [Brownie und Python zur Bereitstellung von Smart Contracts nutzen](https://dev.to/patrickalphac/using-brownie-for-to-deploy-smart-contracts-1kkp)
-- [NFTs mit Brownie auf OpenSea erstellen](https://www.freecodecamp.org/news/how-to-make-an-nft-and-render-on-opensea-marketplace/)
+- [Freunde von web3.py: Einführung in Ape](https://snakecharmers.ethereum.org/intro-to-ape/)
+- [Dapp-Entwicklung für Python-Programmierer](https://levelup.gitconnected.com/dapps-development-for-python-developers-f52b32b54f28)
+- [Erstellen einer Python-Ethereum-Schnittstelle: Teil 1](https://hackernoon.com/creating-a-python-ethereum-interface-part-1-4d2e47ea0f4d)
+- [Ethereum Smart Contracts in Python: ein (fast) umfassender Leitfaden](https://hackernoon.com/ethereum-smart-contracts-in-python-a-comprehensive-ish-guide-771b03990988)
## Fortgeschrittene Nutzungsmuster {#advanced-use-patterns}
-- [Ethereum-Smart Contracts mit Python kompilieren, bereistellen und aufrufen](https://yohanes.gultom.id/2018/11/28/compiling-deploying-and-calling-ethereum-smartcontract-using-python/)
-- [Solidity-Smart Contracts mit Slither analysieren](https://kauri.io/#collections/DevOps/analyze-solidity-smart-contracts-with-slither/#analyze-solidity-smart-contracts-with-slither)
-- [Blockchain-Fintech-Tutorial: Kreditvergabe und ‑aufnahme mit Python](https://blog.chain.link/blockchain-fintech-defi-tutorial-lending-borrowing-python/)
+- [web3.py-Muster: Echtzeit-Ereignis-Abonnements](https://snakecharmers.ethereum.org/subscriptions/)
+- [web3.py-Muster: WebSocketProvider](https://snakecharmers.ethereum.org/websocketprovider/)
+- [Kompilieren, Bereitstellen und Aufrufen von Ethereum-Smart-Contracts mit Python](https://yohanes.gultom.id/2018/11/28/compiling-deploying-and-calling-ethereum-smartcontract-using-python/)
+- [Analysieren von Solidity Smart Contracts mit Slither](https://kauri.io/#collections/DevOps/analyze-solidity-smart-contracts-with-slither/#analyze-solidity-smart-contracts-with-slither)
+- [Blockchain-Fintech-Tutorial: Leihen und Verleihen mit Python](https://blog.chain.link/blockchain-fintech-defi-tutorial-lending-borrowing-python/)
-## Python-Projekte und Tools {#python-projects-and-tools}
+## Archivierte Artikel
+
+- [Bereitstellen Ihres eigenen ERC20-Tokens mit Python und Brownie](https://betterprogramming.pub/python-blockchain-token-deployment-tutorial-create-an-erc20-77a5fd2e1a58)
+- [Verwendung von Brownie und Python zur Bereitstellung von Smart Contracts](https://dev.to/patrickalphac/using-brownie-for-to-deploy-smart-contracts-1kkp)
+- [Erstellen von NFTs auf OpenSea mit Brownie](https://www.freecodecamp.org/news/how-to-make-an-nft-and-render-on-opensea-marketplace/)
+
+## Python-Projekte und -Tools {#python-projects-and-tools}
### Aktiv: {#active}
- [Web3.py](https://github.com/ethereum/web3.py) – _Python-Bibliothek für die Interaktion mit Ethereum_
-- [Vyper](https://github.com/ethereum/vyper/) – _Pythonic Smart Contract-Sprache für EVM_
-- [Ape](https://github.com/ApeWorX/ape) – _Das Smart Contract-Entwicklungstool für Python-Experten, Datenwissenschaftler und Sicherheitsexperten_
-- [py-evm](https://github.com/ethereum/py-evm) – _Implementierung der Ethereum -Virtual Machine_
-- [eth-tester](https://github.com/ethereum/eth-tester) – _Tools zum Testen von Ethereum-basierten Anwendungen_
-- [eth-utils](https://github.com/ethereum/eth-utils/) – _Dienstprogrammfunktionen für das Arbeiten mit Codebasen, die mit Ethereum verwandt sind_
-- [py-solc-x](https://pypi.org/project/py-solc-x/) – _Python-Wrapper um den Solc Solidity-Compiler mit 0.5.x Unterstützung_
+- [Vyper](https://github.com/ethereum/vyper/) – _Pythonische Smart-Contract-Sprache für die EVM_
+- [Ape](https://github.com/ApeWorX/ape) – _Das Entwicklungstool für Smart Contracts für Python-Experten, Datenwissenschaftler und Sicherheitsexperten_
+- [py-evm](https://github.com/ethereum/py-evm) – _Implementierung der Ethereum Virtual Machine_
+- [eth-tester](https://github.com/ethereum/eth-tester) – _Tools zum Testen Ethereum-basierter Anwendungen_
+- [eth-utils](https://github.com/ethereum/eth-utils/) – _Hilfsfunktionen für die Arbeit mit Ethereum-bezogenen Codebasen_
+- [py-solc-x](https://pypi.org/project/py-solc-x/) – _Python-Wrapper um den solc Solidity-Compiler mit Unterstützung für 0.5.x_
- [pymaker](https://github.com/makerdao/pymaker) – _Python-API für Maker-Verträge_
-- [siwe](https://github.com/signinwithethereum/siwe-py) – _Mit Ethereum (siwe) für Python anmelden_
-- [Web3 DeFi für Ethereum-Integrationen](https://github.com/tradingstrategy-ai/web3-ethereum-defi) - _Ein Python-Paket mit fertigen Integrationen für ERC-20, Uniswap und andere populäre Projekte_
-- [Wake](https://getwake.io) – _All-in-One-Python-Framework für das Testen von Contracts, Fuzzing, die Bereitstellung, Schwachstellenscans und die Code-Navigation (Sprachserver – [Tools for Solidity](https://marketplace.visualstudio.com/items?itemName=AckeeBlockchain.tools-for-solidity))_
+- [siwe](https://github.com/signinwithethereum/siwe-py) – _Sign in with Ethereum (siwe) für Python_
+- [Web3 DeFi für Ethereum-Integrationen](https://github.com/tradingstrategy-ai/web3-ethereum-defi) – _Ein Python-Paket mit fertigen Integrationen für ERC-20, Uniswap und andere beliebte Projekte_
+- [Wake](https://getwake.io) – _All-in-one Python-Framework zum Testen von Verträgen, Fuzzing, Bereitstellung, Scannen von Sicherheitslücken und Code-Navigation (Sprachserver – [Tools für Solidity](https://marketplace.visualstudio.com/items?itemName=AckeeBlockchain.tools-for-solidity))_
-### Archiviert/Nicht mehr verwaltet: {#archived--no-longer-maintained}
+### Archiviert / Wird nicht mehr gepflegt: {#archived--no-longer-maintained}
- [Trinity](https://github.com/ethereum/trinity) – _Ethereum-Python-Client_
- [Mamba](https://github.com/arjunaskykok/mamba) – _Framework zum Schreiben, Kompilieren und Bereitstellen von Smart Contracts in der Sprache Vyper_
- [Brownie](https://github.com/eth-brownie/brownie) – _Python-Framework zum Bereitstellen, Testen und Interagieren mit Ethereum Smart Contracts_
- [pydevp2p](https://github.com/ethereum/pydevp2p) – _Implementierung des Ethereum-P2P-Stacks_
-- [py-wasm](https://github.com/ethereum/py-wasm) – _Python-Implementierung des Web Assembly Interpreters_
+- [py-wasm](https://github.com/ethereum/py-wasm) – _Python-Implementierung des Web-Assembly-Interpreters_
-Sind Sie an weiteren Informationen interessiert? Sehen Sie sich [ethereum.org/developers](/developers/) an.
+Sind Sie an weiteren Informationen interessiert? Schauen Sie sich [ethereum.org/developers](/developers/) an.
-## Projekte mit Python-Tools {#projects-using-python-tooling}
+## Projekte, die Python-Tools verwenden {#projects-using-python-tooling}
Die folgenden Ethereum-basierten Projekte verwenden die auf dieser Seite erwähnten Tools. Die zugehörigen Open-Source-Repositorys dienen als gute Referenz für Beispielcode und Best-Practice -Ansätze.
-- [Yearn Finance](https://yearn.finance/) und [Yearn Vault Contracts Repository](https://github.com/yearn/yearn-vaults)
-- [Curve](https://curve.fi/) und [Curve Smart Contracts Repository](https://github.com/curvefi/curve-contract)
-- [BadgerDAO](https://badger.com/) und [Smart Contract mit Brownie-Toolchain](https://github.com/Badger-Finance/badger-system)
-- [Sushi](https://sushi.com/) verwendet [Python zum Verwalten und Bereitstellen ihrer Übertragungsverträge](https://github.com/sushiswap/sushi-vesting-protocols)
-- [Alpha Finance](https://alphafinance.io/) von Alpha Homora verwendet [ Brownie zum Testen und Bereitstellen von Smart Contracts](https://github.com/AlphaFinanceLab/alpha-staking-contract)
+- [Yearn Finance](https://yearn.finance/) und [Yearn Vault Contracts-Repository](https://github.com/yearn/yearn-vaults)
+- [Curve](https://www.curve.finance/) und [Curve-Smart-Contracts-Repository](https://github.com/curvefi/curve-contract)
+- [BadgerDAO](https://badger.com/) und [Smart Contracts, die die Brownie-Toolchain verwenden](https://github.com/Badger-Finance/badger-system)
+- [Sushi](https://sushi.com/) verwendet [Python bei der Verwaltung und Bereitstellung seiner Vesting-Verträge](https://github.com/sushiswap/sushi-vesting-protocols)
+- [Alpha Finance](https://alphafinance.io/), bekannt für Alpha Homora, verwendet [Brownie zum Testen und Bereitstellen von Smart Contracts](https://github.com/AlphaFinanceLab/alpha-staking-contract)
-## Python Community-Diskussionen {#python-community-contributors}
+## Python-Community-Diskussion {#python-community-contributors}
-- [Ethereum Python Community Discord](https://discord.gg/9zk7snTfWe) für Web3.py und andere Python Framework-Diskussionen
-- [Vyper Discord](https://discord.gg/SdvKC79cJk) für Diskussionen zur Vyper-Smart-Contract-Programmierung
+- [Ethereum Python Community Discord](https://discord.gg/9zk7snTfWe) für Diskussionen über Web3.py und andere Python-Frameworks
+- [Vyper Discord](https://discord.gg/SdvKC79cJk) für Diskussionen zur Programmierung von Vyper Smart Contracts
-## Andere aggregierte Listen {#other-aggregated-lists}
+## Andere zusammengefasste Listen {#other-aggregated-lists}
-Das Vyper-Wiki verfügt über eine [umfangreiche Liste mit Ressourcen für Vyper](https://github.com/vyperlang/vyper/wiki/Vyper-tools-and-resources)
\ No newline at end of file
+Das Vyper-Wiki enthält eine [unglaubliche Liste von Ressourcen für Vyper](https://github.com/vyperlang/vyper/wiki/Vyper-tools-and-resources)
\ No newline at end of file
diff --git a/public/content/translations/de/developers/docs/programming-languages/ruby/index.md b/public/content/translations/de/developers/docs/programming-languages/ruby/index.md
index 4324733ac0a..bf5a417351c 100644
--- a/public/content/translations/de/developers/docs/programming-languages/ruby/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/ruby/index.md
@@ -5,56 +5,56 @@ lang: de
incomplete: false
---
-Lernen, wie Sie mit Ruby-basierten Projekten und Tools für Ethereum entwickeln
+Lernen Sie, wie Sie mit Ruby-basierten Projekten und Werkzeugen für Ethereum entwickeln.
-Sie können mit Ethereum dezentrale Anwendungen (oder "dApps") erstellen, die von den Vorteilen der Kryptowährung und der Blockchain-Technologie profitieren. Solche dApps sind vertrauenswürdig. Das bedeutet, dass sie, sobald sie auf Ethereum hochgeladen wurden, immer exakt wie programmiert ausgeführt werden. Darüber lassen sich digitale Vermögenswerte verwalten und neuartige Finanzanwendungen erschaffen. Sie können dezentralisiert sein. Das bedeutet, dass keine einzelne Einheit oder Person sie kontrollieren kann. Damit ist es fast unmöglich, sie zu zensieren.
+Sie können mit Ethereum dezentrale Anwendungen (oder „dApps“) erstellen, die von den Vorteilen der Kryptowährung und der Blockchain-Technologie profitieren. Solche dApps sind vertrauenswürdig. Das bedeutet, dass sie, sobald sie auf Ethereum hochgeladen wurden, immer exakt wie programmiert ausgeführt werden. Darüber lassen sich digitale Vermögenswerte verwalten und neuartige Finanzanwendungen erschaffen. Sie können dezentralisiert sein. Das bedeutet, dass keine einzelne Einheit oder Person sie kontrollieren kann. Damit ist es fast unmöglich, sie zu zensieren.
-## Erste Schritte mit Smart Contracts und der Solidity-Sprache {#getting-started-with-smart-contracts-and-solidity}
+## Erste Schritte mit Smart Contracts und der Sprache Solidity {#getting-started-with-smart-contracts-and-solidity}
**Starten Sie mit der Integration von Ruby mit Ethereum durch**
-Sind Sie an einigen grundlegenden Informationen interessiert? Dann sehen Sie sich auf [ethereum.org/learn](/learn/) oder [ethereum.org/developers](/developers/) um.
+Sind Sie an einigen grundlegenden Informationen interessiert? Besuchen Sie [ethereum.org/learn](/learn/) oder [ethereum.org/developers](/developers/).
- [Blockchain erklärt](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
- [Smart Contracts verstehen](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
-- [Den ersten Smart Contract schreiben](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
-- [Kompilieren und Bereitstellen von Solidity Code lernen](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [Schreiben Sie Ihren ersten Smart Contract](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
+- [Lernen Sie Solidity zu kompilieren und bereitstellen](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
-## Informationen für Einsteiger {#beginner-articles}
+## Artikel für Anfänger {#beginner-articles}
-- [Endlich Ethereum-Konten verstehen](https://dev.to/q9/finally-understanding-ethereum-accounts-1kpe)
+- [Ethereum-Accounts endlich verstehen](https://dev.to/q9/finally-understanding-ethereum-accounts-1kpe)
- [Endlich Rails-Benutzer mit MetaMask authentifizieren](https://dev.to/q9/finally-authenticating-rails-users-with-metamask-3fj)
-- [So verbinden Sie sich über Ruby mit dem Ethereum-Netzwerk](https://www.quicknode.com/guides/web3-sdks/how-to-connect-to-the-ethereum-network-using-ruby)
-- [So erzeugen Sie eine neue Ethereum-Adresse in Ruby](https://www.quicknode.com/guides/web3-sdks/how-to-generate-a-new-ethereum-address-in-ruby)
+- [Wie man sich mit Ruby mit dem Ethereum-Netzwerk verbindet](https://www.quicknode.com/guides/web3-sdks/how-to-connect-to-the-ethereum-network-using-ruby)
+- [Wie man eine neue Ethereum-Adresse in Ruby generiert](https://www.quicknode.com/guides/web3-sdks/how-to-generate-a-new-ethereum-address-in-ruby)
## Artikel für Fortgeschrittene {#intermediate-articles}
-- [Blockchain - mit Ruby](https://www.nopio.com/blog/blockchain-app-ruby/)
-- [Verwenden Sie Ruby, das mit Ethereum verbunden ist, um den Smart Contract auszuführen](https://titanwolf.org/Network/Articles/Article?AID=87285822-9b25-49d5-ba2a-7ad95fff7ef9)
+- [Blockchain-App mit Ruby](https://www.nopio.com/blog/blockchain-app-ruby/)
+- [Den Smart Contract mit Ruby ausführen, das mit Ethereum verbunden ist](https://titanwolf.org/Network/Articles/Article?AID=87285822-9b25-49d5-ba2a-7ad95fff7ef9)
-## Ruby-Projekte und Tools {#ruby-projects-and-tools}
+## Ruby-Projekte und -Werkzeuge {#ruby-projects-and-tools}
### Aktiv {#active}
- [eth.rb](https://github.com/q9f/eth.rb) – _Ruby-Bibliothek und RPC-Client zur Verwaltung von Ethereum-Konten, Nachrichten und Transaktionen_
-- [keccak.rb](https://github.com/q9f/keccak.rb) – _Der von Ethereum verwendete Keccak (SHA3) Hash_
-- [siwe-ruby](https://github.com/signinwithethereum/siwe-ruby) – _Ruby-Implementierung der Anmeldung mit Ethereum_
+- [keccak.rb](https://github.com/q9f/keccak.rb) – _Der von Ethereum verwendete Keccak-(SHA3-)Hash_
+- [siwe-ruby](https://github.com/signinwithethereum/siwe-ruby) – _Ruby-Implementierung von „Sign-In with Ethereum“_
- [siwe-rails](https://github.com/signinwithethereum/siwe-rails) – _Rails-Gem, das lokale SIWE-Anmelderouten hinzufügt_
-- [siwe-rails-examples](https://github.com/signinwithethereum/siwe-rails-examples) – _SIWE-Beispiel mit Ruby on Rails und benutzerdefiniertem Controller_
-- [omniauth-siwe](https://github.com/signinwithethereum/omniauth-siwe) – _OmniAuth-Strategie für Anmelden mit Ethereum (SIWE)_
+- [siwe-rails-examples](https://github.com/signinwithethereum/siwe-rails-examples) – _SIWE-Beispiel unter Verwendung von Ruby on Rails mit benutzerdefiniertem Controller_
+- [omniauth-siwe](https://github.com/signinwithethereum/omniauth-siwe) – _OmniAuth-Strategie für Sign In With Ethereum (SIWE)_
- [omniauth-nft](https://github.com/valthon/omniauth-nft) – _OmniAuth-Strategie für die Authentifizierung über NFT-Besitz_
-- [ethereum-on-rails](https://github.com/q9f/ethereum-on-rails) – _Ethereum on Rails-Vorlage, um MetaMask mit Ruby on Rails zu verbinden_
+- [ethereum-on-rails](https://github.com/q9f/ethereum-on-rails) – _Ethereum on Rails-Vorlage, die es ermöglicht, MetaMask mit Ruby on Rails zu verbinden_
-### Archiviert/Nicht mehr verwaltet {#archived--no-longer-maintained}
+### Archiviert / Wird nicht mehr gepflegt {#archived--no-longer-maintained}
-- [web3-eth](https://github.com/spikewilliams/vtada-ethereum) – _RPC-Methoden des Ethereum-Nodes mit Ruby aufrufen_
+- [web3-eth](https://github.com/spikewilliams/vtada-ethereum) – _Aufrufen von RPC-Methoden eines Ethereum-Nodes mit Ruby_
- [ethereum_tree](https://github.com/longhoangwkm/ethereum_tree) – _Ruby-Bibliothek zur Generierung von ETH-Adressen aus einer Hierarchical Deterministic Wallet nach dem BIP32-Standard_
- [etherlite](https://github.com/budacom/etherlite) – _Ethereum-Integration für Ruby on Rails_
-- [ethereum.rb](https://github.com/EthWorks/ethereum.rb) – _Ruby-Ethereum-Client verwendet die JSON-RPC-Schnittstelle zum Versenden von Transaktionen, zum Erstellen von und Interagieren mit Verträgen und ist ein nützliches Toolkit für die Arbeit mit dem Ethereum-Node_
+- [ethereum.rb](https://github.com/EthWorks/ethereum.rb) – _Ruby-Ethereum-Client mit JSON-RPC-Schnittstelle zum Senden von Transaktionen, Erstellen und Interagieren mit Verträgen sowie ein nützliches Toolkit für die Arbeit mit einem Ethereum-Node_
- [omniauth-ethereum.rb](https://github.com/q9f/omniauth-ethereum.rb) – _Implementiert die Ethereum-Anbieterstrategie für OmniAuth_
-Sind Sie an weiteren Informationen interessiert? Besuchen Sie [unsere Entwickler-Homepage](/developers/).
+Sind Sie an weiteren Informationen interessiert? Besuchen Sie [unser Entwickler-Portal](/developers/).
## Mitwirkende der Ruby-Community {#ruby-community-contributors}
-Die [Ethereum-Ruby-Telegram-Gruppe](https://t.me/ruby_eth) ist eine schnell wachsende Community und genau die richtige Anlaufstelle für Diskussionen über die oben genannten Projekte und verwandte Themen.
+Die [Ethereum Ruby Telegram-Gruppe](https://t.me/ruby_eth) beherbergt eine schnell wachsende Community und ist die zentrale Anlaufstelle für Diskussionen über die oben genannten Projekte und verwandte Themen.
diff --git a/public/content/translations/de/developers/docs/programming-languages/rust/index.md b/public/content/translations/de/developers/docs/programming-languages/rust/index.md
index 50bfd54d92f..437094e44c9 100644
--- a/public/content/translations/de/developers/docs/programming-languages/rust/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/rust/index.md
@@ -5,57 +5,59 @@ lang: de
incomplete: true
---
-Erfahren Sie, wie Sie mit Rust-basierten Projekten und Tools für Ethereum entwickeln können
+Lernen Sie, wie Sie für Ethereum mit Rust-basierten Projekten und Werkzeugen entwickeln
-Sie können mit Ethereum dezentrale Anwendungen (oder "dApps") erstellen, die von den Vorteilen der Kryptowährung und der Blockchain-Technologie profitieren. Solche dApps sind vertrauenswürdig. Das bedeutet, dass sie, sobald sie auf Ethereum hochgeladen wurden, immer exakt wie programmiert ausgeführt werden. Darüber lassen sich digitale Vermögenswerte verwalten und neuartige Finanzanwendungen erschaffen. Sie können dezentralisiert sein. Das bedeutet, dass keine einzelne Einheit oder Person sie kontrollieren kann. Damit ist es fast unmöglich, sie zu zensieren.
+Sie können mit Ethereum dezentrale Anwendungen (oder „dApps“) erstellen, die von den Vorteilen der Kryptowährung und der Blockchain-Technologie profitieren. Solche dApps sind vertrauenswürdig. Das bedeutet, dass sie, sobald sie auf Ethereum hochgeladen wurden, immer exakt wie programmiert ausgeführt werden. Darüber lassen sich digitale Vermögenswerte verwalten und neuartige Finanzanwendungen erschaffen. Sie können dezentralisiert sein. Das bedeutet, dass keine einzelne Einheit oder Person sie kontrollieren kann. Damit ist es fast unmöglich, sie zu zensieren.
-## Erste Schritte mit Smart Contracts und der Solidity-Sprache {#getting-started-with-smart-contracts-and-solidity}
+## Erste Schritte mit Smart Contracts und der Sprache Solidity {#getting-started-with-smart-contracts-and-solidity}
**Starten Sie mit der Integration von Rust mit Ethereum durch**
-Sind Sie an einigen grundlegenden Informationen interessiert? Dann sehen Sie sich auf [ethereum.org/learn](/learn/) oder [ethereum.org/developers](/developers/) um.
+Sind Sie an einigen grundlegenden Informationen interessiert? Besuchen Sie [ethereum.org/learn](/learn/) oder [ethereum.org/developers](/developers/).
- [Blockchain erklärt](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
- [Smart Contracts verstehen](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
-- [Den ersten Smart Contract schreiben](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
-- [Kompilieren und Bereitstellen von Solidity Code lernen](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [Schreiben Sie Ihren ersten Smart Contract](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
+- [Lernen Sie Solidity zu kompilieren und bereitstellen](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
-## Informationen für Einsteiger {#beginner-articles}
+## Artikel für Anfänger {#beginner-articles}
-- [Der Rust-Ethereum-Client](https://openethereum.github.io/) \* **Beachten Sie, dass OpenEthereum [veraltet](https://medium.com/openethereum/gnosis-joins-erigon-formerly-turbo-geth-to-release-next-gen-ethereum-client-c6708dd06dd) ist und nicht mehr gepflegt wird.** Nutzen Sie es mit Vorsicht und wechseln Sie besser zu einer anderen Client-Implementierung.
-- [Transaktion mit Rust an Ethereum senden](https://kauri.io/#collections/A%20Hackathon%20Survival%20Guide/sending-ethereum-transactions-with-rust/)
-- [Ein Schritt-für-Schritt-Tutorial dazu, wie Sie Contracts in Rust Wasm für Kovan verfassen können](https://github.com/paritytech/pwasm-tutorial)
+- [Der Rust Ethereum-Client](https://openethereum.github.io/) \* **Bitte beachten Sie, dass OpenEthereum [veraltet ist](https://medium.com/openethereum/gnosis-joins-erigon-formerly-turbo-geth-to-release-next-gen-ethereum-client-c6708dd06dd) und nicht mehr gewartet wird.** Verwenden Sie es mit Vorsicht und wechseln Sie vorzugsweise zu einer anderen Client-Implementierung.
+- [Senden einer Transaktion an Ethereum mit Rust](https://kauri.io/#collections/A%20Hackathon%20Survival%20Guide/sending-ethereum-transactions-with-rust/)
+- [Eine Schritt-für-Schritt-Anleitung, wie Sie Contracts in Rust Wasm für Kovan schreiben](https://github.com/paritytech/pwasm-tutorial)
## Artikel für Fortgeschrittene {#intermediate-articles}
## Fortgeschrittene Nutzungsmuster {#advanced-use-patterns}
-- [pwasm_ethereum Bibliothek von Externen, um mit dem Ethereum-ähnlichen Netzwerk zu interagieren](https://github.com/openethereum/pwasm-ethereum)
-- [Einen dezentralisierten Chat mit JavaScript und Rust erstellen](https://medium.com/perlin-network/build-a-decentralized-chat-using-javascript-rust-webassembly-c775f8484b52)
-- [Erstelle eine dezentralisierte Todo-App mit Vue.js & Rust](https://medium.com/@jjmace01/build-a-decentralized-todo-app-using-vue-js-rust-webassembly-5381a1895beb)
+- [pwasm_ethereum externs-Bibliothek zur Interaktion mit einem Ethereum-ähnlichen Netzwerk](https://github.com/openethereum/pwasm-ethereum)
-- [Erstellen einer Blockchain in Rust](https://blog.logrocket.com/how-to-build-a-blockchain-in-rust/)
+- [Erstellen eines dezentralen Chats mit JavaScript und Rust](https://medium.com/perlin-network/build-a-decentralized-chat-using-javascript-rust-webassembly-c775f8484b52)
-## Rust-Projekte und Tools {#rust-projects-and-tools}
+- [Erstellen einer dezentralen To-do-App mit Vue.js & Rust](https://medium.com/@jjmace01/build-a-decentralized-todo-app-using-vue-js-rust-webassembly-5381a1895beb)
-- [pwasm-ethereum](https://github.com/paritytech/pwasm-ethereum) - _Sammlung von Externen zur Interaktion mit einem Ethereum-ähnlichen Netzwerk_
-- [Lighthouse](https://github.com/sigp/lighthouse) – _Schneller Ethereum-Client auf Konsensebene_
-- [Ethereum WebAssembly](https://ewasm.readthedocs.io/en/mkdocs/) - _Vorgeschlagene Neugestaltung der Ausführungsebene für Ethereum Smart-Contracts mit einer deterministischen Teilmenge von WebAssembly_
-- [oasis_std](https://docs.rs/oasis-std/latest/oasis_std/index.html) – _OASIS-API-Referenz_
-- [Solaris](https://github.com/paritytech/sol-rs) - _Testumgebung für Solidity Smart Contracts Einheitstests unter Verwendung der nativen Parity Client EVM._
-- [SputnikVM](https://github.com/rust-blockchain/evm) – _Implementierung der virtuellen Maschine von Rust Ethereum_
+- [Eine Blockchain in Rust erstellen](https://blog.logrocket.com/how-to-build-a-blockchain-in-rust/)
+
+## Rust-Projekte und -Werkzeuge {#rust-projects-and-tools}
+
+- [pwasm-ethereum](https://github.com/paritytech/pwasm-ethereum) – _Sammlung von externen Komponenten zur Interaktion mit einem Ethereum-ähnlichen Netzwerk_
+- [Lighthouse](https://github.com/sigp/lighthouse) - _Schneller Client für die Ethereum-Konsens-Ebene_
+- [Ethereum WebAssembly](https://ewasm.readthedocs.io/en/mkdocs/) – _Vorgeschlagene Neugestaltung der Ausführungsebene für Ethereum Smart Contracts mit einer deterministischen Teilmenge von WebAssembly_
+- [oasis_std](https://docs.rs/oasis-std/latest/oasis_std/index.html) - _OASIS API-Referenz_
+- [Solaris](https://github.com/paritytech/sol-rs) – _Testumgebung für Solidity Smart Contracts Einheitstests unter Verwendung der nativen Parity Client EVM._
+- [SputnikVM](https://github.com/rust-blockchain/evm) - _Rust-Implementierung der Ethereum Virtual Machine_
- [Wavelet](https://wavelet.perlin.net/docs/smart-contracts) - _Wavelet Smart Contract in Rust_
-- [Foundry](https://github.com/foundry-rs/foundry) – _Toolkit für Ethereum-Anwendungsentwicklung_
+- [Foundry](https://github.com/foundry-rs/foundry) - _Toolkit für die Entwicklung von Ethereum-Anwendungen_
- [Alloy](https://alloy.rs) – _Hochleistungsfähige, gut getestete und dokumentierte Bibliotheken zur Interaktion mit Ethereum und anderen EVM-basierten Ketten._
-- [Ethers_rs](https://github.com/gakonst/ethers-rs) – _Ethereum-Bibliothek und Wallet-Implementierung_
-- [SewUp](https://github.com/second-state/SewUp) – _Eine Bibliothek, die Ihnen hilft, Ihren Ethereum-Webassembly-Vertrag mit Rust zu erstellen und genau wie in einem gemeinsamen Backend zu entwickeln_
-- [Substreams](https://github.com/streamingfast/substreams) - _Indexierungstechnologie für parallele Blockchain-Daten_
+- [Ethers_rs](https://github.com/gakonst/ethers-rs) - _Ethereum-Bibliothek und Wallet-Implementierung_
+- [SewUp](https://github.com/second-state/SewUp) – _Eine Bibliothek, die Ihnen hilft, Ihren Ethereum-Webassembly-Vertrag mit Rust zu erstellen und genau wie in einem gängigen Backend zu entwickeln_
+- [Substreams](https://github.com/streamingfast/substreams) - _Parallelisierte Technologie zur Indexierung von Blockchain-Daten_
- [Reth](https://github.com/paradigmxyz/reth) – Reth (kurz für Rust Ethereum) ist eine neue Full-Node-Implementierung für Ethereum
-- [Awesome Ethereum Rust](https://github.com/Vid201/awesome-ethereum-rust) – _eine kuratierte Sammlung von Projekten im Ethereum-Ökosystem, die in Rust geschrieben sind_
+- [Awesome Ethereum Rust](https://github.com/Vid201/awesome-ethereum-rust) – _Eine kuratierte Sammlung von Projekten im Ethereum-Ökosystem, die in Rust geschrieben sind_
-Sind Sie an weiteren Informationen interessiert? Sehen Sie sich [ethereum.org/developers](/developers/) an.
+Sind Sie an weiteren Informationen interessiert? Schauen Sie sich [ethereum.org/developers.](/developers/) an.
-## Mitwirkende der Rust-Community {#rust-community-contributors}
+## Rust-Community-Mitwirkende {#rust-community-contributors}
- [Ethereum WebAssembly](https://gitter.im/ewasm/Lobby)
- [Oasis Gitter](https://gitter.im/Oasis-official/Lobby)
diff --git a/public/content/translations/de/developers/docs/scaling/index.md b/public/content/translations/de/developers/docs/scaling/index.md
index 0bafa5539ce..3f2e98dee3c 100644
--- a/public/content/translations/de/developers/docs/scaling/index.md
+++ b/public/content/translations/de/developers/docs/scaling/index.md
@@ -9,103 +9,105 @@ sidebarDepth: 3
Da die Zahl der Nutzer von Ethereum gestiegen ist, hat die Blockchain gewisse Kapazitätsgrenzen erreicht. Dies hat die Kosten für die Nutzung des Netzes in die Höhe getrieben und den Bedarf an „Skalierungslösungen" geschaffen. Es gibt mehrere Lösungen, die erforscht, getestet und umgesetzt werden, die unterschiedliche Ansätze verfolgen, um ähnliche Ziele zu erreichen.
-Das Hauptziel der Skalierbarkeit ist die Erhöhung der Transaktionsgeschwindigkeit (schnellere Endgültigkeit) und des Transaktionsdurchsatzes (viele Transaktionen pro Sekunde), ohne dabei die Dezentralisierung oder die Sicherheit zu opfern (mehr zur [Ethereum Vision](/roadmap/vision/)). Hohe Nachfrage auf der Layer-1 Ethereum Blockchain, führt zu langsameren Transaktionen und untragbaren [Gas Preisen](/developers/docs/gas/). Die Erhöhung der Netzwerkkapazität in Bezug auf Geschwindigkeit und Durchsatz ist von grundlegender Bedeutung für eine sinnvolle und massenhafte Einführung von Ethereum.
+Das Hauptziel der Skalierbarkeit besteht darin, die Transaktionsgeschwindigkeit (schnellere Finalität) und den Transaktionsdurchsatz (höhere Anzahl von Transaktionen pro Sekunde) zu erhöhen, ohne die Dezentralisierung oder die Sicherheit zu beeinträchtigen. Auf der Layer-1-Ethereum-Blockchain führt eine hohe Nachfrage zu langsameren Transaktionen und untragbaren [Gaspreisen](/developers/docs/gas/). Die Erhöhung der Netzwerkkapazität in Bezug auf Geschwindigkeit und Durchsatz ist von grundlegender Bedeutung für eine sinnvolle und massenhafte Einführung von Ethereum.
Geschwindigkeit und Durchsatz sind zwar von Bedeutung, aber es ist entscheidend, dass Skalierungslösungen, die diese Ziele ermöglichen, dezentralisiert und sicher bleiben. Eine niedrige Einstiegshürde für die Betreiber von Knotenpunkten ist von entscheidender Bedeutung, um eine Entwicklung hin zu zentralisierter und unsicherer Rechenleistung zu verhindern.
-Konzeptionell unterteilen wir die Skalierung zunächst in On-Chain-Skalierung und Off-Chain-Skalierung.
+Konzeptionell kategorisieren wir Skalierung zunächst entweder als Onchain-Skalierung oder Offchain-Skalierung.
## Voraussetzungen {#prerequisites}
Sie sollten über ein gutes Verständnis aller grundlegenden Themen verfügen. Die Umsetzung von Skalierungslösungen ist weit fortgeschritten, da die Technologie weniger erprobt ist und weiter erforscht und entwickelt wird.
-## On-Chain Skalierung {#on-chain-scaling}
+## Onchain-Skalierung {#onchain-scaling}
-Diese Methode der Skalierung erfordert Änderungen am Ethereum-Protokoll (Layer 1 [Mainnet](/glossary/#mainnet)). Dem Sharding gilt derzeit das Hauptaugenmerk für diese Skalierungsmethode.
+Onchain-Skalierung erfordert Änderungen am Ethereum-Protokoll (Layer-1-[Mainnet](/glossary/#mainnet)). Seit langem wurde die Partitionierung von Ethereum erwartet: Eine Skalierungslösung für Ethereum. Dies würde beinhalten, die Blockchain in diskrete Stücke (Shards) aufzuteilen, die von Teilgruppen von Validatoren verifiziert werden. Jedoch hat das Skalieren durch Layer-2 Rollups als primäre Skalierungstechnik die Führung übernommen. Dies wird durch die Hinzufügung einer neuen kostengünstigeren Form von Daten unterstützt, die an Ethereum-Blöcke angehängt ist und speziell entwickelt wurde, um Rollups für Benutzer kostengünstig zu machen.
### Sharding {#sharding}
-Unter Sharding versteht man die horizontale Aufteilung einer Datenbank, um die Last zu verteilen. Im Ethereum-Kontext wird das Sharding die Netzwerküberlastung reduzieren und die Transaktionen pro Sekunde erhöhen, indem neue Ketten, die sogenannten „Shards", geschaffen werden. Dies entlastet auch die einzelnen Prüfer, die nicht mehr die Gesamtheit aller Transaktionen im Netz bearbeiten müssen.
+Sharding ist ein Prozess der Datenverwaltung, bei dem alle gespeicherten Daten in mehrere Fragmente aufgeteilt werden. Unterklassen von Validatoren wären für ihre eigenen Shards verantwortlich, anstatt dafür zu sorgen, dass die Gesamtlast des Ethereum-Systems aufrechterhalten wird. Sharding war lange Zeit Teil der Ethereum-[Roadmap](/roadmap/) und sollte ursprünglich vor The Merge zum Proof-of-Stake-Verfahren implementiert werden. Die schnelle Entwicklung von [Layer-2-Rollups](#layer-2-scaling) und die Erfindung von [Danksharding](/roadmap/danksharding) (das Hinzufügen von Blobs mit Rollup-Daten zu Ethereum-Blöcken, die von Validatoren sehr effizient verifiziert werden können) hat jedoch dazu geführt, dass die Ethereum-Community eine Rollup-zentrierte Skalierung anstelle der Skalierung durch Sharding bevorzugt. Dies wird auch dazu beitragen, die Konsenslogik von Ethereum einfacher zu halten.
-Erfahren Sie mehr über [Sharding](/roadmap/danksharding/).
+## Offchain-Skalierung {#offchain-scaling}
-## Off-Chain-Skalierung {#off-chain-scaling}
+Offchain-Lösungen werden separat von Layer 1 Mainnet implementiert – sie erfordern keine Änderungen am bestehenden Ethereum-Protokoll. Einige Lösungen, die als „Layer-2“-Lösungen bekannt sind, leiten ihre Sicherheit direkt vom Layer-1-Ethereum-Konsens ab, wie z. B. [Optimistic Rollups](/developers/docs/scaling/optimistic-rollups/), [Zero-Knowledge-Rollups](/developers/docs/scaling/zk-rollups/) oder [State Channels](/developers/docs/scaling/state-channels/). Andere Lösungen umfassen die Erstellung neuer Chains in verschiedenen Formen, die ihre Sicherheit separat vom Mainnet ableiten, wie z. B. [Sidechains](#sidechains), [Validiums](#validium) oder [Plasma-Chains](#plasma). Diese Lösungen kommunizieren mit dem Mainnet, leiten aber ihre Sicherheit anders ab, um eine Vielzahl von Zielen zu erreichen.
-Off-Chain-Lösungen werden getrennt vom Layer 1 Mainnet implementiert - sie erfordern keine Änderungen am bestehenden Ethereum-Protokoll. Einige Lösungen, die als „Layer-2"-Lösungen bekannt sind, leiten ihre Sicherheit direkt vom Layer-1 Ethereum Konsens her, wie zum Beispiel [optimistische Rollups](/developers/docs/scaling/optimistic-rollups/),[Zero-Knowledge Rollups](/developers/docs/scaling/zk-rollups/) oder [State Channels](/developers/docs/scaling/state-channels/). Andere Lösungen beinhalten die Schaffung neuer Ketten in verschiedenen Formen, die ihre Sicherheit getrennt vom Mainnet beziehen, wie [Sidechains](#sidechains) oder [Plasma](#plasma) Ketten. Diese Lösungen kommunizieren mit dem Mainnet, leiten aber ihre Sicherheit anders ab, um eine Vielzahl von Zielen zu erreichen.
+### Layer-2-Skalierung {#layer-2-scaling}
-### Layer-2 Skalierung {#layer-2-scaling}
-
-Diese Kategorie von Off-Chain-Lösungen bezieht ihre Sicherheit aus dem Mainnet Ethereum.
+Diese Kategorie von Offchain-Lösungen bezieht ihre Sicherheit aus dem Ethereum-Mainnet.
Layer-2 ist ein Sammelbegriff für Lösungen, die dazu dienen, Ihre Anwendung zu skalieren, indem sie Transaktionen außerhalb des Ethereum Mainnet (Layer-1) abwickeln und gleichzeitig das robuste dezentrale Sicherheitsmodell vom Mainnet nutzen. Die Transaktionsgeschwindigkeit leidet, wenn das Netzwerk ausgelastet ist, was die Benutzererfahrung im Umgang mit bestimmten Arten von dApps verschlechtert. Und wenn die Netzwerk-Aktivitäten steigen, dann steigen auch die Gaspreise, während sich Transaktionsabsender gegenseitig überbieten wollen. Dies kann die Verwendung von Ethereum sehr teuer machen.
-Die meisten Layer-2-Lösungen basieren auf einem Server oder einer Gruppe von Servern, von denen jeder als Knotenpunkt, Validator, Operator, Sequenzer, Blockproduzent oder ähnlich bezeichnet wird. Je nach Implementierung können diese Layer-2-Knotenpunkte von Einzelpersonen, Unternehmen oder Einrichtungen, die sie nutzen, oder von einem Drittanbieter oder von einer großen Gruppe von Einzelpersonen (ähnlich wie beim Mainnet) betrieben werden. Im Allgemeinen werden die Transaktionen an diese Layer-2-Knotenpunkte übermittelt, anstatt direkt an Layer-1 (Mainnet) übermittelt zu werden. Bei einigen Lösungen fasst die Layer-2-Instanz diese dann in Gruppen zusammen, bevor sie sie in Layer-1 verankert werden, woraufhin sie wiederum von Layer-1 gesichert werden und nicht mehr verändert werden können. Die Details, wie dies geschieht, variieren erheblich zwischen verschiedenen Layer-2-Technologien und -Implementierungen.
+Die meisten Layer-2-Lösungen basieren auf einem Server oder einer Gruppe von Servern, von denen jeder als Knotenpunkt, Validator, Operator, Sequenzer, Blockproduzent oder ähnlich bezeichnet wird. Je nach Implementierung können diese Layer-2-Knotenpunkte von Einzelpersonen, Unternehmen oder Einrichtungen, die sie nutzen, oder von einem Drittanbieter oder von einer großen Gruppe von Einzelpersonen (ähnlich wie beim Mainnet) betrieben werden. Im Allgemeinen werden die Transaktionen an diese Layer-2-Knotenpunkte übermittelt, anstatt direkt an Layer-1 (Mainnet) übermittelt zu werden. Bei einigen Lösungen fasst die Layer-2-Instanz diese dann in Gruppen zusammen, bevor sie sie an Layer 1 anheftet, wonach sie durch Layer 1 gesichert sind und nicht mehr geändert werden können. Die Details, wie dies geschieht, variieren erheblich zwischen verschiedenen Layer-2-Technologien und -Implementierungen.
Eine bestimmte Layer-2-Instanz kann offen sein und von vielen Anwendungen gemeinsam genutzt werden, oder sie kann von einem Projekt bereitgestellt werden und nur dessen Anwendung unterstützen.
#### Warum wird Layer-2 gebraucht? {#why-is-layer-2-needed}
- Mehr Transaktionen pro Sekunde verbessern die Benutzererfahrung erheblich und reduzieren die Netzwerküberlastung auf dem Ethereum Mainnet.
-- Transaktionen werden zu einer einzigen Transaktion auf dem Ethereum Mainnet zusammengefasst, wodurch die Gasgebühren für Benutzer gesenkt werden. Dadurch wiederum wird Ethereum für die Menschen überall integrativer und zugänglicher.
+- Transaktionen werden in einer einzigen Transaktion an das Ethereum-Mainnet gebündelt, was die Gasgebühren für die Nutzer reduziert und Ethereum für Menschen überall integrativer und zugänglicher macht.
- Keine Aktualisierungen der Skalierbarkeit sollten auf Kosten der Dezentralisierung oder Sicherheit gehen - Layer-2 baut auf Ethereum auf.
- Es gibt anwendungsspezifische Layer-2-Netzwerke, die ihre eigenen Vorteile im Umgang mit Assets im großen Maßstab mit sich bringen.
+[Mehr über Layer 2](/layer-2/).
+
#### Rollups {#rollups}
Rollups führen Transaktionen außerhalb von Layer-1 aus, und die Daten werden dann an Layer-1 weitergeleitet, wo ein Konsens erzielt wird. Da die Transaktionsdaten in Layer-1-Blöcken enthalten sind, können Rollups durch die eigene Ethereum-Sicherheit gesichert werden.
Es gibt zwei Arten von Rollups mit verschiedenen Sicherheitsmodellen:
-- **Optimistische Rollups**: geht davon aus, dass Transaktionen standardmäßig gültig sind, und führt nur im Falle einer Anfechtung Berechnungen über einen [**Betrugsnachweis**](/glossary/#fraud-proof) durch. [Mehr über Optimistische Rollups](/Developers/Docs/Scaling/Optimistic-Rollups/).
-- **Zero-Knowledge Rollups**: Führt die Berechnung außerhalb der Kette durch und reicht einen [**Gültigkeitsnachweis**](/glossary/#validity-proof) an die Kette ein. [Mehr zu Zero-Knowledge Rollups](/Developers/Docs/Scaling/Zk-Rollups/).
+- **Optimistic Rollups**: Gehen standardmäßig davon aus, dass Transaktionen gültig sind, und führen Berechnungen nur im Falle einer Anfechtung mittels eines [**Betrugsbeweises**](/glossary/#fraud-proof) durch. [Mehr über Optimistic Rollups](/developers/docs/scaling/optimistic-rollups/).
+- **Zero-Knowledge-Rollups**: Führen Berechnungen offchain durch und übermitteln einen [**Gültigkeitsnachweis**](/glossary/#validity-proof) an die Chain. [Mehr über Zero-Knowledge-Rollups](/developers/docs/scaling/zk-rollups/).
-#### Zustandskanäle {#channels}
+#### State Channels {#channels}
-Zustandskanäle nutzen Multisig-Verträge, um den Teilnehmenden die Möglichkeit zu geben, schnell und frei Transaktionen außerhalb der Kette durchzuführen und diese dann über das Mainnet abzurechnen. Dadurch werden Netzwerküberlastungen, Gebühren und Verzögerungen auf ein Minimum reduziert. Die beiden Arten von Kanälen sind derzeit Zustandskanäle und Zahlungskanäle.
+State Channels nutzen Multisig-Verträge, um Teilnehmern schnelle und freie Transaktionen offchain zu ermöglichen, bevor sie die Endgültigkeit mit dem Mainnet abwickeln. Dadurch werden Netzwerküberlastungen, Gebühren und Verzögerungen auf ein Minimum reduziert. Die beiden Arten von Kanälen sind derzeit Zustandskanäle und Zahlungskanäle.
-Erfahren Sie mehr über [Zustandskanäle](/Developers/Docs/Scaling/State-Channels/).
+Erfahren Sie mehr über [State Channels](/developers/docs/scaling/state-channels/).
-### Seitenketten {#sidechains}
+### Sidechains {#sidechains}
-Eine Seitenkette ist eine unabhängige EVM-kompatible Blockchain, die parallel zum Mainnet läuft. Diese sind über Zweiseitige Brücken mit Ethereum kompatibel und laufen nach ihren eigenen Konsensregeln und Blockparametern.
+Eine Sidechain ist eine unabhängige, EVM-kompatible Blockchain, die parallel zum Mainnet läuft. Diese sind über zweiseitige kettenübergreifende Brücken mit Ethereum kompatibel und laufen nach ihren eigenen gewählten Konsensregeln und Blockparametern.
-Erfahren Sie mehr über [Seitenketten](/developers/docs/scaling/sidechains/).
+Erfahren Sie mehr über [Sidechains](/developers/docs/scaling/sidechains/).
### Plasma {#plasma}
-Eine Plasmakette ist eine separate Blockchain, die an der Ethereum-Blockchain verankert ist und Betrugsnachweise (wie [Optimistische Rollups](/developers/docs/scaling/optimistic-rollups/)) verwendet, um Streitigkeiten zu schlichten.
+Eine Plasma-Chain ist eine separate Blockchain, die an der Ethereum-Hauptchain verankert ist und Betrugsbeweise (wie [Optimistic Rollups](/developers/docs/scaling/optimistic-rollups/)) verwendet, um Streitigkeiten beizulegen.
-Erfahren Sie mehr über [Plasma](/Developers/Docs/Scaling/Plasma/).
+Erfahren Sie mehr über [Plasma](/developers/docs/scaling/plasma/).
### Validium {#validium}
Eine Validium-Kette nutzt Gültigkeitsnachweise wie Zero-Knowledge-Rollups, aber Daten werden nicht auf der Main Layer-1 Ethereum Chain gespeichert. Dies kann zu 10.000 Transaktionen pro Sekunde pro Validium-Kette führen, zudem können mehrere Ketten parallel laufen.
-Lernen Sie mehr über [Validium](/developers/docs/scaling/validium/).
+Erfahren Sie mehr über [Validium](/developers/docs/scaling/validium/).
## Warum werden so viele Skalierungslösungen benötigt? {#why-do-we-need-these}
-- Mehrere Lösungen können dazu beitragen, die Gesamtüberlastung in einem Teil des Netzes zu verringern, und verhindern außerdem einzelne Fehlerquellen.
+- Mehrere Lösungen können helfen, die allgemeine Überlastung eines Teils des Netzwerks zu reduzieren und einzelne Fehlerquellen zu vermeiden.
- Das Ganze ist größer als die Summe seiner Teile. Es können verschiedene Lösungen existieren und miteinander harmonieren, was einen exponentiellen Effekt auf die künftige Transaktionsgeschwindigkeit und den Durchsatz ermöglicht.
- Nicht alle Lösungen erfordern die direkte Nutzung des Ethereum-Konsens-Algorithmus, und Alternativen können Vorteile bieten, die sonst nur schwer zu erreichen wären.
-- Eine einzige Skalierungslösung reicht nicht aus, um die [Ethereum Vision](/roadmap/vision/) zu erfüllen.
## Eher der visuelle Lernende? {#visual-learner}
Hinweis: Ethereum nutzt regelmäßig Hashfunktionen, um Werte mit fester Länge (Hashes) zu erzeugen. Hashes spielen eine wichtige Rolle in Ethereum, für den Einstieg können Sie sie einfach als eindeutige ID vorstellen.
+Hinweis: Ethereum verwendet regelmäßig Hash-Funktionen, um Werte fester Größe („Hashes“) zu erzeugen. Hashes spielen eine wichtige Rolle in Ethereum, aber vorerst können Sie sie sich einfach als eindeutige IDs vorstellen.
-_Eine Blockchain ist im Grunde eine verknüpfte Liste. Jeder Block verweist auf den vorangehenden Block._
+_Eine Blockchain ist im Grunde eine verkettete Liste; jeder Block hat eine Referenz auf den vorherigen Block._
-Diese Datenstruktur ist nicht neu. Aber die Regeln (z. B. Peer-to-Peer-Protokolle), die im Netzwerk gelten, sind neu. Es gibt keine zentrale Autorität. Die Netzwerkteilnehmer (Peers) müssen zusammenarbeiten und konkurrieren, um das Netzwerk aufrechtzuerhalten und zu entscheiden, welche Transaktionen in den nächsten Block aufgenommen werden. Wenn Sie also einem Freund Geld schicken möchten, müssen Sie diese Transaktion an das Netzwerk senden und dann darauf warten, dass sie in einen kommenden Block aufgenommen wird.
+Diese Datenstruktur ist nichts Neues, aber die Regeln (d. h. die Peer-to-Peer-Protokolle), die das Netzwerk steuern, sind es. Es gibt keine zentrale Autorität; das Netzwerk von Peers muss zusammenarbeiten, um das Netzwerk aufrechtzuerhalten, und konkurrieren, um zu entscheiden, welche Transaktionen in den nächsten Block aufgenommen werden. Wenn Sie also einem Freund Geld schicken möchten, müssen Sie diese Transaktion an das Netzwerk senden und dann darauf warten, dass sie in einen kommenden Block aufgenommen wird.
-Die einzige Möglichkeit für die Blockchain, zu verifizieren, dass Geld wirklich von einem Nutzer zu einem anderen gesendet wurde, ist die Nutzung einer für diese Blockchain nativen Währung (d. h. die von ihr geschaffen und verwaltet wird). Bei Ethereum heißt diese Währung Ether. Die Ethereum-Blockchain enthält die einzigen offiziellen Aufzeichnungen über die Kontostände.
+Die einzige Möglichkeit für die Blockchain, zu verifizieren, dass Geld wirklich von einem Nutzer zu einem anderen gesendet wurde, ist die Nutzung einer für diese Blockchain nativen Währung (d. h. die von ihr geschaffen und verwaltet wird). In Ethereum heißt diese Währung Ether, und die Ethereum-Blockchain enthält die einzige offizielle Aufzeichnung der Kontostände.
-## Ein neues Modell {#a-new-paradigm}
+## Ein neues Paradigma {#a-new-paradigm}
-Dieser neue dezentralisierte Technologie-Stack hat neue Entwicklertools hervorgebracht. Solche Tools gibt es in vielen Programmiersprachen, aber in diesem Beitrag schauen wir durch die Python-Brille. Um es noch einmal zu betonen: Selbst wenn Python nicht Ihre bevorzugte Sprache ist, sollten Sie den Anweisungen trotzdem leicht folgen können.
+Dieser neue dezentralisierte Technologie-Stack hat neue Entwicklertools hervorgebracht. Solche Tools gibt es in vielen Programmiersprachen, aber wir werden sie aus der Python-Perspektive betrachten. Um es noch einmal zu wiederholen: Auch wenn Python nicht Ihre bevorzugte Sprache ist, sollte es kein Problem sein, mitzukommen.
-Python-Entwickler, die mit Ethereum interagieren möchten, nutzen wahrscheinlich [Web3.py](https://web3py.readthedocs.io/). Web3.py ist eine Bibliothek, die es sehr einfach macht, sich mit einem Ethereum-Node zu verbinden und dann Daten zu senden und zu empfangen.
+Python-Entwickler, die mit Ethereum interagieren möchten, greifen wahrscheinlich zu [Web3.py](https://web3py.readthedocs.io/). Web3.py ist eine Bibliothek, die die Verbindung zu einem Ethereum-Node sowie das Senden und Empfangen von Daten von diesem erheblich vereinfacht.
-Hinweis: "Ethereum-Node" und "Ethereum-Client" werden synonym verwendet. In beiden Fällen ist Software gemeint, die ein Teilnehmer am Ethereum-Netzwerk ausführt. Diese Software kann Blockdaten lesen, Updates empfangen, wenn neue Blöcke zur Kette hinzugefügt ("geminted") werden, neue Transaktionen übertragen und vieles mehr.
+Hinweis: „Ethereum-Node“ und „Ethereum-Client“ werden synonym verwendet. In beiden Fällen bezieht es sich auf die Software, die ein Teilnehmer im Ethereum-Netzwerk ausführt. Diese Software kann Blockdaten lesen, Aktualisierungen empfangen, wenn neue Blöcke zur Kette hinzugefügt werden, neue Transaktionen übertragen und vieles mehr. Technisch gesehen ist der Client die Software, der Node ist der Computer, auf dem die Software läuft.
-[Ethereum-Clients](/developers/docs/nodes-and-clients/) können so konfiguriert werden, dass sie über [IPC](https://wikipedia.org/wiki/Inter-process_communication), HTTP oder Websockets erreichbar sind. Daher muss Web3.py diese Konfiguration spiegeln. Web3.py bezeichnet diese Verbindungsoptionen als **Anbieter**. Sie müssen einen der drei Anbieter wählen, um eine Web3.py-Instanz mit Ihrem Node zu verbinden.
+[Ethereum-Clients](/developers/docs/nodes-and-clients/) können so konfiguriert werden, dass sie über [IPC](https://wikipedia.org/wiki/Inter-process_communication), HTTP oder Websockets erreichbar sind, daher muss Web3.py diese Konfiguration widerspiegeln. Web3.py bezeichnet diese Verbindungsoptionen als **Anbieter**. Sie sollten einen der drei Anbieter wählen, um die Web3.py-Instanz mit Ihrem Node zu verbinden.
-_Konfigurieren Sie den Ethereum-Node und Web3.py so, dass sie über das gleiche Protokoll kommunizieren. Im folgenden Diagramm ist das beispielsweise IPC._
+_Konfigurieren Sie den Ethereum-Node und Web3.py so, dass sie über dasselbe Protokoll kommunizieren, z. B. IPC in diesem Diagramm._
-Sobald Web3.py richtig konfiguriert ist, können Sie mit der Blockchain interagieren. Hier sind eine paar Anwendungsbeispiele für Web3.py als Vorschau auf das was noch folgt:
+Sobald Web3.py richtig konfiguriert ist, können Sie mit der Blockchain interagieren. Hier sind ein paar Anwendungsbeispiele für Web3.py als Vorschau auf das, was noch folgt:
```python
-# read block data:
+# Blockdaten lesen:
w3.eth.get_block('latest')
-# send a transaction:
+# eine Transaktion senden:
w3.eth.send_transaction({'from': ..., 'to': ..., 'value': ...})
```
## Installation {#installation}
-In dieser Einführung arbeiten wir nur mit dem Python-Interpreter. Wir erzeugen keine Verzeichnisse, Dateien, Klassen oder Funktionen.
+In dieser exemplarischen Vorgehensweise arbeiten wir nur innerhalb eines Python-Interpreters. Wir werden keine Verzeichnisse, Dateien, Klassen oder Funktionen erstellen.
-Hinweis: In den folgenden Beispielen kennzeichnet '$' Befehle, die im Terminal ausgeführt werden. (Geben Sie dabei das '$' nicht mit ein. Es ist nur ein Hinweis auf den Beginn einer Zeile.)
+Hinweis: In den folgenden Beispielen sind Befehle, die mit `$` beginnen, für die Ausführung im Terminal vorgesehen. (Geben Sie das `$` nicht mit ein, es kennzeichnet nur den Zeilenanfang.)
-Installieren Sie zuerst [IPython](https://ipython.org/), um eine benutzerfreundliche Umgebung zu erstellen. IPython bietet neben anderen Funktionen eine Tab-Vervollständigung an. Damit lässt sich einfacher heruasfinden, was innerhalb von Web3.py möglich ist.
+Installieren Sie zuerst [IPython](https://ipython.org/), um eine benutzerfreundliche Umgebung zum Erkunden zu erhalten. IPython bietet unter anderem eine Tab-Vervollständigung an, die es viel einfacher macht, zu erkennen, was mit Web3.py alles möglich ist.
```bash
-$ pip install ipython
+pip install ipython
```
-Web3.py wird unter dem Namen `web3` publiziert. Nehmen Sie die Installation wie folgt vor:
+Web3.py wird unter dem Namen `web3` veröffentlicht. Installieren Sie es wie folgt:
```bash
-$ pip install web3
+pip install web3
```
-Als Nächstes werden wir eine Blockchain-Simulation durchführen, die noch einige weitere Abhängigkeiten erfordert. Nehmen Sie die Installation wie folgt vor:
+Noch etwas – wir werden später eine Blockchain simulieren, was ein paar weitere Abhängigkeiten erfordert. Sie können diese wie folgt installieren:
```bash
-$ pip install 'web3[tester]'
+pip install 'web3[tester]'
```
-Nun kann es losgehen.
+Jetzt sind Sie startklar!
+
+Hinweis: Das `web3[tester]`-Paket funktioniert bis Python 3.10.xx
## Eine Sandbox einrichten {#spin-up-a-sandbox}
-Öffnen Sie eine neue Python-Umgebung, indem Sie `ipython` in Ihrem Terminal ausführen. Diese Ausführung ist vergleichbar mit `python`, bietet aber deutlich mehr Funktionen.
+Öffnen Sie eine neue Python-Umgebung, indem Sie `ipython` in Ihrem Terminal ausführen. Dies ist vergleichbar mit der Ausführung von `python`, bietet aber deutlich mehr Funktionen.
```bash
-$ ipython
+ipython
```
-Es werden einige Informationen über Ihre aktuelle Version von Python und IPython angezeigt. Anschließend sollten Sie eine Aufforderung zur Eingabe erhalten:
+Es werden einige Informationen über die Versionen von Python und IPython angezeigt, die Sie verwenden. Anschließend sollten Sie eine Aufforderung zur Eingabe sehen:
```python
In [1]:
```
-Sie befinden sich jetzt in einer interaktiven Python-Shell-Umgebung. Hier können Sie sich nun austoben. Nun ist es an der Zeit, Web3.py zu importieren:
+Sie sehen nun eine interaktive Python-Shell. Im Grunde ist es eine Sandbox zum Herumspielen. Wenn Sie es bis hierher geschafft haben, ist es an der Zeit, Web3.py zu importieren:
```python
In [1]: from web3 import Web3
@@ -125,74 +124,75 @@ In [1]: from web3 import Web3
## Einführung in das Web3-Modul {#introducing-the-web3-module}
-Das [Web3](https://web3py.readthedocs.io/en/stable/overview.html#base-api)-Modul ist nicht nur ein Gateway zu Ethereum, sondern bietet auch einige komfortable Funktionen an. Sehen wir uns ein paar davon genauer an.
+Das [Web3](https://web3py.readthedocs.io/en/stable/overview.html#base-api)-Modul ist nicht nur ein Gateway zu Ethereum, sondern bietet auch einige praktische Funktionen. Sehen wir uns ein paar davon an.
-In einer Ethereum-Anwendung müssen Sie üblicherweise Währungsbezeichnungen umrechnen. Das Web3-Modul stellt Ihnen dazu hilfreiche Methoden zur Verfügung: [fromWei](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.fromWei) und [toWei](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.toWei).
+In einer Ethereum-Anwendung müssen Sie üblicherweise Währungsbezeichnungen umrechnen. Das Web3-Modul bietet hierfür ein paar Hilfsmethoden: [from_wei](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.from_wei) und [to_wei](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.to_wei).
-Hinweis: Computer sind bekanntermaßen schlecht bei der Verarbeitung von Dezimalmathematik. Um das zu umgehen, geben Entwickler Dollarbeträge oft in Cent an. Beispiel: Ein Artikel mit einem Preis von 5,99 USD wird in der Datenbank als 599 angelegt.
+Hinweis: Computer sind bekanntermaßen schlecht bei der Verarbeitung von Dezimalzahlen. Um dies zu umgehen, speichern Entwickler Dollarbeträge oft in Cent. Beispielsweise kann ein Artikel mit einem Preis von 5,99 $ in der Datenbank als 599 gespeichert werden.
-Transaktionen in Ether werden in ähnlicher Weise verwaltet. Aber statt zwei Dezimalstellen hat Ether 18 Stück. Die kleinste Einheit von Ether wird Wei genannt. Das ist auch der Wert, der beim Senden von Transaktionen angegeben wird.
+Ein ähnliches Muster wird beim Umgang mit Transaktionen in Ether verwendet. Doch anstelle von zwei Dezimalstellen hat Ether 18! Die kleinste Einheit von Ether wird Wei genannt. Das ist also der Wert, der beim Senden von Transaktionen angegeben wird.
-1 Ether = 1000000000000000000 Wei
+1 Ether = 1.000.000.000.000.000.000 Wei
-1 Wei = 0.000000000000000001 Ether
+1 Wei = 0,000000000000000001 Ether
-Versuchen Sie, einige Werte nach und von Wei zu konvertieren. [Beachten Sie](https://web3py.readthedocs.io/en/stable/troubleshooting.html#how-do-i-convert-currency-denominations), dass es zwischen Ether und Wei noch andere Einheiten gibt. Eine der bekanntesten ist **Gwei**, da Transaktionsgebühren in dieser Einheit angegeben werden.
+Versuchen Sie, einige Werte von und in Wei umzurechnen. Beachten Sie, dass es [Namen für viele der Denominationen](https://web3py.readthedocs.io/en/stable/troubleshooting.html#how-do-i-convert-currency-denominations) zwischen Ether und Wei gibt. Eine der bekanntesten davon ist **Gwei**, da Transaktionsgebühren oft in dieser Einheit dargestellt werden.
```python
-In [2]: Web3.toWei(1, 'ether')
+In [2]: Web3.to_wei(1, 'ether')
Out[2]: 1000000000000000000
-In [3]: Web3.fromWei(500000000, 'gwei')
+In [3]: Web3.from_wei(500000000, 'gwei')
Out[3]: Decimal('0.5')
```
-Das Web3-Modul enthält außerdem einen Datenformatkonvertierer (z. B. [`toHex`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.toHex)), Adresse (z. B., [`isAddress`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.isAddress)), und Hashfunktionen (z. B., [`keccak`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.keccak)). Viele davon werden hier genauer erklärt. Um alle verfügbaren Funktionen und Eigenschaften anzuzeigen, können Sie die Autovervollständigung in IPython nutzen. Geben Sie dafür den folgenden Code ein: `Web3`. Anschließend drücken Sie bitte zweimal die Tab-Taste.
+Weitere Hilfsmethoden im Web3-Modul umfassen Datenformat-Konverter (z. B. [`toHex`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.toHex)), Adress-Hilfsfunktionen (z. B. [`isAddress`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.isAddress)) und Hash-Funktionen (z. B. [`keccak`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.keccak)). Viele davon werden später in dieser Reihe behandelt. Um alle verfügbaren Methoden und Eigenschaften anzuzeigen, nutzen Sie die automatische Vervollständigung von IPython, indem Sie `Web3` eingeben. und nach dem Punkt zweimal die Tab-Taste drücken.
-## Kommunikation mit der Blockchain {#talk-to-the-chain}
+## Kommunikation mit der Chain {#talk-to-the-chain}
-Die bisher vorgestellten Funktionen sind toll. Aber sehen wir uns nun einmal die Blockchain genauer an. Im nächsten Schritt konfiguireren wir Web3.py für die Kommunikation mit einem Ethereum-Node. Dabei können wir IPC, HTTP oder Websocket-Anbieter verwenden.
+Die Hilfsmethoden sind schön und gut, aber lassen Sie uns zur Blockchain übergehen. Der nächste Schritt ist die Konfiguration von Web3.py zur Kommunikation mit einem Ethereum-Node. Hier haben wir die Möglichkeit, die Anbieter IPC, HTTP oder Websocket zu verwenden.
-Wir werden hier nicht weiter darauf eingehen, aber ein Beispiel für einen kompletten Workflow mit dem HTTP-Provider könnte wie folgt aussehen:
+Wir werden diesen Weg nicht weiter verfolgen, aber ein Beispiel für einen kompletten Arbeitsablauf mit dem HTTP-Anbieter könnte etwa so aussehen:
- Laden Sie einen Ethereum-Node herunter, z. B. [Geth](https://geth.ethereum.org/).
-- Starten Sie Geth in einem Terminalfenster und warten Sie bis die Netzwerksynchronisierung abgeschlossen ist. Der Standard-HTTP-Port ist `8545`, kann jedoch umkonfiguriert werden.
-- Stellen Sie eine Verbindung von Web3.py zu dem Ethereum-Node über HTTP, `localhost:8545`, her. `w3 = Web3(Web3.HTTPProvider('http://127.0.0.1:8545'))`
-- Agieren Sie über die `w3`-Instanz mit dem Node.
+- Starten Sie Geth in einem Terminalfenster und warten Sie, bis es sich mit dem Netzwerk synchronisiert hat. Der Standard-HTTP-Port ist `8545`, ist aber konfigurierbar.
+- Weisen Sie Web3.py an, sich mit dem Node über HTTP auf `localhost:8545` zu verbinden.
+ `w3 = Web3(Web3.HTTPProvider('http://127.0.0.1:8545'))`
+- Verwenden Sie die `w3`-Instanz, um mit dem Node zu interagieren.
-Wenn Sie nur an einer Entwicklungsumgebung interessiert sind, ist dieser Weg unnötig, da der Synchronisierungsprozess mehrere Stunden dauert. Web3.py stellt für diesen Zweck einen vierten Provider zur Verfügung, den **EthereumTesterProvider**. Dieser Test-Provider ist mit einem simulierten Ethereum-Node mit Fake-Währungen und einfachen Berechtigungen verknüpft.
+Obwohl dies ein „echter“ Weg ist, dauert der Synchronisierungsprozess Stunden und ist unnötig, wenn Sie nur eine Entwicklungsumgebung wollen. Web3.py stellt für diesen Zweck einen vierten Anbieter bereit, den **EthereumTesterProvider**. Dieser Testanbieter verknüpft sich mit einem simulierten Ethereum-Node mit gelockerten Berechtigungen und einer Spielwährung.
_Der EthereumTesterProvider verbindet sich mit einem simulierten Node und ist praktisch für schnelle Entwicklungsumgebungen._
-Dieser simulierter Node heißt [eth-tester](https://github.com/ethereum/eth-tester) und wurde mit dem Befehl `pip install web3[tester]` installiert. Um das Web3.py mit dem Testanbieter zu verbinden, geben Sie Folgendes ein:
+Dieser simulierte Node heißt [eth-tester](https://github.com/ethereum/eth-tester) und wurde als Teil des `pip install web3[tester]`-Befehls installiert. Die Konfiguration von Web3.py zur Verwendung dieses Testanbieters ist so einfach wie:
```python
In [4]: w3 = Web3(Web3.EthereumTesterProvider())
```
-Jetzt können Sie mit der Blockchain kommunizieren. Wie das genau funktioniert? Ich habe da etwas für Sie zusammengestellt. Machen wir eine schnelle Tour.
+Jetzt sind Sie bereit, auf der Chain zu surfen! Das ist kein gängiger Ausdruck. Das habe ich mir gerade ausgedacht. Machen wir eine kurze Tour.
-## Los geht's {#the-quick-tour}
+## Die Kurztour {#the-quick-tour}
-Zuallererst eine Zuverlässigkeitsüberprüfung:
+Zuallererst ein Sanity-Check:
```python
-In [5]: w3.isConnected()
+In [5]: w3.is_connected()
Out[5]: True
```
-Da wir einen Testanbieter verwenden, ist der Test nicht sehr aussagekräftig, doch falls er fehlschlägt, ist die Wahrscheinlichkeit hoch, dass Sie eine falsche Variable in `w3` eingegeben haben. Überprüfen Sie, ob Sie die inneren Klammern eingefügt haben, also `Web3.EthereumTesterProvider()`.
+Da wir den Testanbieter verwenden, ist dies kein sehr aussagekräftiger Test, aber wenn er fehlschlägt, haben Sie wahrscheinlich bei der Instanziierung der `w3`-Variable etwas falsch eingegeben. Überprüfen Sie, ob Sie die inneren Klammern eingefügt haben, d. h. `Web3.EthereumTesterProvider()`.
-## 1. Stop auf der Tour: [Konten](/developers/docs/accounts/) {#tour-stop-1-accounts}
+## Tour-Stopp Nr. 1: [Konten](/developers/docs/accounts/) {#tour-stop-1-accounts}
-Der Einfachheit halber hat der Testanbieter bereits einige Konten eingerichtet und sie mit Test-Ether gefüllt.
+Der Einfachheit halber hat der Testanbieter einige Konten erstellt und sie mit Test-Ether vorgeladen.
-Zunächst sehen wir uns die folgende Kontenliste an:
+Zuerst sehen wir uns eine Liste dieser Konten an:
```python
In [6]: w3.eth.accounts
@@ -201,27 +201,27 @@ Out[6]: ['0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf',
'0x6813Eb9362372EEF6200f3b1dbC3f819671cBA69', ...]
```
-Wenn Sie diesen Befehl ausführen, sollten Sie eine Liste von zehn Zeichenketten sehen, die mit `0x` beginnen. Jede davon ist eine **öffentliche Adresse** und gewissermaßen analog zur Kontonummer auf einem Prüfkonto. Diese Adresse würden Sie angeben, wenn Ihnen jemand Ether senden will.
+Wenn Sie diesen Befehl ausführen, sollten Sie eine Liste von zehn Zeichenketten sehen, die mit `0x` beginnen. Jede davon ist eine **öffentliche Adresse** und ist in gewisser Weise analog zur Kontonummer eines Girokontos. Sie würden diese Adresse jemandem geben, der Ihnen Ether senden möchte.
-Wie bereits erwähnt, hat der Testanbieter jedes dieser Konten mit Test-Ether gefüllt. Lassen Sie uns herausfinden, wie viel sich auf dem ersten Konto befindet:
+Wie bereits erwähnt, hat der Testanbieter jedes dieser Konten mit etwas Test-Ether vorgeladen. Finden wir heraus, wie viel sich auf dem ersten Konto befindet:
```python
In [7]: w3.eth.get_balance(w3.eth.accounts[0])
Out[7]: 1000000000000000000000000
```
-Das sind viele Nullen. Bevor Sie vor Freude in die Luft springen, erinnern Sie sich bitte an unsere vorherige Lektion über die Schreibweise von Währungen. Ether wird in der kleinsten Einheit Wei angegeben. Rechnen Sie dies in Ether um:
+Das sind eine Menge Nullen! Bevor Sie lachend zur falschen Bank gehen, erinnern Sie sich an die Lektion über Währungsbezeichnungen von vorhin. Ether-Werte werden in der kleinsten Einheit, Wei, dargestellt. Rechnen Sie das in Ether um:
```python
-In [8]: w3.fromWei(1000000000000000000000000, 'ether')
+In [8]: w3.from_wei(1000000000000000000000000, 'ether')
Out[8]: Decimal('1000000')
```
-Eine Millionen Test-Ether – sind immer noch gut.
+Eine Million Test-Ether – immer noch nicht zu verachten.
-## 2. Stop auf der Tour: Blockdaten {#tour-stop-2-block-data}
+## Tour-Stopp Nr. 2: Blockdaten {#tour-stop-2-block-data}
-Werfen wir einen Blick auf den Status dieser simulierten Blockchain:
+Werfen wir einen Blick auf den Zustand dieser simulierten Blockchain:
```python
In [9]: w3.eth.get_block('latest')
@@ -234,32 +234,35 @@ Out[9]: AttributeDict({
})
```
-Über einen Block werden viele Informationen zurückgegeben, doch auf ein paar davon sollten Sie achten:
+Über einen Block werden viele Informationen zurückgegeben, aber hier sind nur ein paar Dinge hervorzuheben:
-- Die Blocknummer ist Null – unabhängig davon, wie lange es her ist, dass Sie den Testanbieter konfiguriert haben. Im Gegensatz zum echten Ethereum-Netzwerk, das ungefähr alle 15 Sekunden einen neuen Block erstellt, wartet diese Simulation, bis sie von Ihnen etwas zu tun bekommt.
-- Die `transactions` sind ebenfalls leer, da wir bisher noch nichts gemacht haben. Dieser erste Block ist ein **leerer Block**, nur um die Kette in Gang zu setzen.
-- Beachten Sie, dass der `parentHash` nur ein Bund aus leeren Bytes ist. Das bedeutet, dass es sich um den ersten Block in der Kette handelt, auch bekannt als **Genesis Block**.
+- Die Blocknummer ist Null – egal, wie lange es her ist, dass Sie den Testanbieter konfiguriert haben. Im Gegensatz zum echten Ethereum-Netzwerk, das alle 12 Sekunden einen neuen Block hinzufügt, wartet diese Simulation, bis Sie ihr Arbeit geben.
+- `transactions` ist aus demselben Grund eine leere Liste: Wir haben noch nichts getan. Dieser erste Block ist ein **leerer Block**, nur um die Kette zu starten.
+- Beachten Sie, dass der `parentHash` nur eine Reihe von leeren Bytes ist. Dies bedeutet, dass es sich um den ersten Block in der Kette handelt, auch bekannt als **Genesis-Block**.
-## 3. Stop auf der Tour: [Transaktionen](/developers/docs/transactions/) {#tour-stop-3-transactions}
+## Tour-Stopp Nr. 3: [Transaktionen](/developers/docs/transactions/) {#tour-stop-3-transactions}
-Wir verharren bei Block Null bis es eine Transaktion zum Minen gibt, also geben wir ihm eine. Senden Sie ein paar Test-Ether von einem Konto zum anderem:
+Wir stecken bei Block Null fest, bis eine Transaktion ansteht, also geben wir ihm eine. Senden Sie ein paar Test-Ether von einem Konto zum anderen:
```python
In [10]: tx_hash = w3.eth.send_transaction({
'from': w3.eth.accounts[0],
'to': w3.eth.accounts[1],
- 'value': w3.toWei(3, 'ether'),
+ 'value': w3.to_wei(3, 'ether'),
'gas': 21000
})
```
-Das ist typischerweise der Punkt, an dem Sie mehrere Sekunden warten würden, bis Ihre Transaktion in einem neuen Block erstellt wurde. Der gesamte Prozess läuft wie folgt ab:
+Dies ist normalerweise der Punkt, an dem Sie mehrere Sekunden warten müssten, bis Ihre Transaktion in einen neuen Block aufgenommen wird. Der gesamte Prozess läuft ungefähr so ab:
-1. Übermitteln Sie eine Transaktion und halten Sie den Transaktions-Hash bereit. Die Transaktion ist ausstehend bis sie geminted wurde. `tx_hash = w3.eth.send_transaction({ … })`
-2. Warten Sie, bis die Transaktion geminted wurde: `w3.eth.wait_for_transaction_receipt(tx_hash)`
-3. Setzen Sie die Anwendungslogik fort. Um die erfolgreiche Transaktion anzuzeigen: `w3.eth.get_transaction(tx_hash)`
+1. Senden Sie eine Transaktion und behalten Sie den Transaktions-Hash. Bis der Block mit der Transaktion erstellt und übertragen wird, ist die Transaktion „ausstehend“.
+ `tx_hash = w3.eth.send_transaction({ … })`
+2. Warten Sie, bis die Transaktion in einen Block aufgenommen wird:
+ `w3.eth.wait_for_transaction_receipt(tx_hash)`
+3. Setzen Sie die Anwendungslogik fort. Um die erfolgreiche Transaktion anzuzeigen:
+ `w3.eth.get_transaction(tx_hash)`
-Unsere simulierte Umgebung wird die Transaktion sofort in einem neuen Block hinzufügen, so dass wir die Transaktion direkt sehen können:
+Unsere simulierte Umgebung fügt die Transaktion sofort in einem neuen Block hinzu, sodass wir die Transaktion sofort anzeigen können:
```python
In [11]: w3.eth.get_transaction(tx_hash)
@@ -274,22 +277,24 @@ Out[11]: AttributeDict({
})
```
-Hier werden sie einige bekannte Details sehen: Die Felder `from`, `to` und `value` sollten mit den Einträgen unseres `send_transaction`-Aufrufs übereinstimmen. Das andere beruhigende Aspekt ist, dass diese Transaktion als erste Transaktion (`'transactionIndex': 0`) in Block Nr. 1 enthalten war.
+Hier sehen Sie einige vertraute Details: Die Felder `from`, `to` und `value` sollten mit den Eingaben unseres `send_transaction`-Aufrufs übereinstimmen. Der andere beruhigende Aspekt ist, dass diese Transaktion als erste Transaktion (`'transactionIndex': 0`) in Block Nummer 1 aufgenommen wurde.
-Wir können den Erfolg dieser Transaktion auch leicht überprüfen, indem wir die Salden der beiden beteiligten Konten kontrollieren. Drei Ether sollten sich von einem auf das andere Konto bewegt haben.
+Wir können den Erfolg dieser Transaktion auch leicht überprüfen, indem wir die Salden der beiden beteiligten Konten kontrollieren. Drei Ether sollten von einem zum anderen transferiert worden sein.
```python
In [12]: w3.eth.get_balance(w3.eth.accounts[0])
-Out[12]: 999996999999999999969000
+Out[12]: 999996999979000000000000
In [13]: w3.eth.get_balance(w3.eth.accounts[1])
Out[13]: 1000003000000000000000000
```
-Letzteres sieht gut aus. Der Saldo hat sich von 1.000.000 auf 1.000.003 Ether erhöht. Aber was ist mit dem ersten Konto passiert? Es scheint etwas mehr, als drei Ether verloren zu haben. Leider ist nichts im Leben kostenlos. Die Nutzung des öffentlichen Netzes von Ethereum erfordert, dass das Netzwerk für seine Unterstützung eine Aufwandsentschädigung erhält. Eine kleine Transaktionsgebühr wurde vom Konto abgezogen, in Größenordnung von 31000 Wei.
+Letzteres sieht gut aus! Der Saldo stieg von 1.000.000 auf 1.000.003 Ether. Aber was ist mit dem ersten Konto passiert? Es scheint etwas mehr als drei Ether verloren zu haben. Leider ist nichts im Leben umsonst, und die Nutzung des öffentlichen Ethereum-Netzwerks erfordert, dass Sie Ihre Peers für ihre unterstützende Rolle entschädigen. Eine kleine Transaktionsgebühr wurde von dem Konto abgezogen, das die Transaktion übermittelt hat – diese Gebühr ist die Menge des verbrauchten Gases (21.000 Gaseinheiten für eine ETH-Überweisung) multipliziert mit einer Grundgebühr, die je nach Netzwerkaktivität variiert, plus einem Trinkgeld, das an den Validator geht, der die Transaktion in einen Block aufnimmt.
+
+Mehr zu [Gas](/developers/docs/gas/#post-london)
-Hinweis: Im öffentlichen Netzwerk basieren Transaktionsgebühren auf variablen Netzanforderungen und wie schnell Sie eine Transaktion verarbeiten möchten. Wenn Sie an einer Aufschlüsselung der Berechnung der Gebühren interessiert sind, sehen Sie sich meinen früheren Beitrag auf "Wie Transaktionen in einem Block enthalten sind" an.
+Hinweis: Im öffentlichen Netzwerk sind die Transaktionsgebühren variabel und basieren auf der Netzwerknachfrage und der gewünschten Verarbeitungsgeschwindigkeit einer Transaktion. Wenn Sie an einer Aufschlüsselung der Gebührenberechnung interessiert sind, lesen Sie meinen früheren Beitrag darüber, wie Transaktionen in einen Block aufgenommen werden.
-## Und atmen {#and-breathe}
+## Und durchatmen {#and-breathe}
-Wir sind schon eine ganze Weile dabei, daher ist jetzt ein guter Zeitpunkt für eine Pause. Im zweiten Teil unserer Serie befassen wir uns weiter mit der Materie. Einige der weiteren Konzepte: Verbindung zu einem echten Node, Smart Contracts und Token. Haben Sie weitere Fragen? Lassen Sie es mich wissen. Ihr Feedback hat Einfluss darauf, wohin die Reise geht. Anfragen können Sie gerne über [Twitter](https://twitter.com/wolovim) stellen.
+Wir sind schon eine ganze Weile dabei, also scheint dies ein guter Zeitpunkt für eine Pause zu sein. Der Kaninchenbau geht weiter, und wir werden im zweiten Teil dieser Serie weiterforschen. Einige der kommenden Konzepte: Verbindung zu einem echten Node, Smart Contracts und Token. Haben Sie weitere Fragen? Lassen Sie es mich wissen! Ihr Feedback wird beeinflussen, wie wir von hier aus weitermachen. Anfragen sind über [Twitter](https://twitter.com/wolovim) willkommen.
diff --git a/public/content/translations/de/developers/tutorials/all-you-can-cache/index.md b/public/content/translations/de/developers/tutorials/all-you-can-cache/index.md
new file mode 100644
index 00000000000..7645215f097
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/all-you-can-cache/index.md
@@ -0,0 +1,866 @@
+---
+title: "Alles, was Sie cachen können"
+description: Erfahren Sie, wie Sie einen Caching-Vertrag für günstigere Rollup-Transaktionen erstellen und verwenden.
+author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+tags: [ "Layer 2", "Caching", "Speicher" ]
+skill: intermediate
+published: 2022-09-15
+lang: de
+---
+
+Bei der Verwendung von Rollups sind die Kosten für ein Byte in der Transaktion viel höher als die Kosten für einen Storage-Slot. Daher ist es sinnvoll, so viele Informationen wie möglich on-chain zu cachen.
+
+In diesem Artikel erfahren Sie, wie Sie einen Caching-Vertrag so erstellen und verwenden, dass jeder wahrscheinlich mehrfach genutzte Parameterwert zwischengespeichert wird. Nach der ersten Verwendung ist er dann mit einer viel kleineren Anzahl von Bytes verfügbar. Außerdem lernen Sie, wie Sie Off-Chain-Code schreiben, der diesen Cache nutzt.
+
+Wenn Sie den Artikel überspringen und nur den Quellcode sehen möchten, [finden Sie ihn hier](https://github.com/qbzzt/20220915-all-you-can-cache). Der Entwicklungs-Stack ist [Foundry](https://getfoundry.sh/introduction/installation/).
+
+## Gesamtdesign {#overall-design}
+
+Der Einfachheit halber gehen wir davon aus, dass alle Transaktionsparameter `uint256` sind und eine Länge von 32 Bytes haben. Wenn wir eine Transaktion erhalten, parsen wir jeden Parameter wie folgt:
+
+1. Wenn das erste Byte `0xFF` ist, nehmen Sie die nächsten 32 Bytes als Parameterwert und schreiben Sie ihn in den Cache.
+
+2. Wenn das erste Byte `0xFE` ist, nehmen Sie die nächsten 32 Bytes als Parameterwert, aber schreiben Sie ihn _nicht_ in den Cache.
+
+3. Für jeden anderen Wert nehmen Sie die oberen vier Bits als Anzahl der zusätzlichen Bytes und die unteren vier Bits als die höchstwertigen Bits des Cache-Schlüssels. Hier sind einige Beispiele:
+
+ | Bytes in Calldata | Cache-Schlüssel |
+ | :---------------- | --------------: |
+ | 0x0F | 0x0F |
+ | 0x10,0x10 | 0x10 |
+ | 0x12,0xAC | 0x02AC |
+ | 0x2D,0xEA, 0xD6 | 0x0DEAD6 |
+
+## Cache-Manipulation {#cache-manipulation}
+
+Der Cache ist in [`Cache.sol`](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/src/Cache.sol) implementiert. Gehen wir ihn Zeile für Zeile durch.
+
+```solidity
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+
+contract Cache {
+
+ bytes1 public constant INTO_CACHE = 0xFF;
+ bytes1 public constant DONT_CACHE = 0xFE;
+```
+
+Diese Konstanten werden verwendet, um die Sonderfälle zu interpretieren, in denen wir alle Informationen bereitstellen und sie entweder in den Cache geschrieben haben wollen oder nicht. Das Schreiben in den Cache erfordert zwei [`SSTORE`](https://www.evm.codes/#55)-Operationen in zuvor ungenutzte Storage-Slots zu einem Preis von je 22100 Gas, daher machen wir es optional.
+
+```solidity
+
+ mapping(uint => uint) public val2key;
+```
+
+Ein [Mapping](https://www.geeksforgeeks.org/solidity/solidity-mappings/) zwischen den Werten und ihren Schlüsseln. Diese Information ist notwendig, um Werte zu kodieren, bevor Sie die Transaktion versenden.
+
+```solidity
+ // An Position n befindet sich der Wert für den Schlüssel n+1, weil wir die Null
+ // als „nicht im Cache“ reservieren müssen.
+ uint[] public key2val;
+```
+
+Wir können ein Array für die Zuordnung von Schlüsseln zu Werten verwenden, da wir die Schlüssel zuweisen und dies der Einfachheit halber sequenziell tun.
+
+```solidity
+ function cacheRead(uint _key) public view returns (uint) {
+ require(_key <= key2val.length, "Lese nicht initialisierten Cache-Eintrag");
+ return key2val[_key-1];
+ } // cacheRead
+```
+
+Lesen Sie einen Wert aus dem Cache.
+
+```solidity
+ // Einen Wert in den Cache schreiben, falls er noch nicht vorhanden ist
+ // Nur öffentlich, damit der Test funktioniert
+ function cacheWrite(uint _value) public returns (uint) {
+ // Wenn der Wert bereits im Cache ist, geben Sie den aktuellen Schlüssel zurück
+ if (val2key[_value] != 0) {
+ return val2key[_value];
+ }
+```
+
+Es hat keinen Sinn, denselben Wert mehr als einmal in den Cache zu legen. Wenn der Wert bereits vorhanden ist, geben Sie einfach den vorhandenen Schlüssel zurück.
+
+```solidity
+ // Da 0xFE ein Sonderfall ist, ist der größte Schlüssel, den der Cache
+ // halten kann, 0x0D gefolgt von 15 0xFFs. Wenn die Cache-Länge bereits so
+ // groß ist, schlägt der Vorgang fehl.
+ // 1 2 3 4 5 6 7 8 9 A B C D E F
+ require(key2val.length+1 < 0x0DFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,
+ "Cache-Überlauf");
+```
+
+Ich glaube nicht, dass wir jemals einen so großen Cache erhalten werden (ca. 1,8\*1037 Einträge, für deren Speicherung etwa 1027 TB erforderlich wären). Ich bin jedoch alt genug, um mich an [„640 KB wären immer genug“](https://quoteinvestigator.com/2011/09/08/640k-enough/) zu erinnern. Dieser Test ist sehr günstig.
+
+```solidity
+ // Den Wert mit dem nächsten Schlüssel schreiben
+ val2key[_value] = key2val.length+1;
+```
+
+Fügen Sie die umgekehrte Suche hinzu (vom Wert zum Schlüssel).
+
+```solidity
+ key2val.push(_value);
+```
+
+Fügen Sie die Vorwärtssuche hinzu (vom Schlüssel zum Wert). Da wir die Werte sequenziell zuweisen, können wir sie einfach nach dem letzten Array-Wert hinzufügen.
+
+```solidity
+ return key2val.length;
+ } // cacheWrite
+```
+
+Gibt die neue Länge von `key2val` zurück, d. h. die Zelle, in der der neue Wert gespeichert ist.
+
+```solidity
+ function _calldataVal(uint startByte, uint length)
+ private pure returns (uint)
+```
+
+Diese Funktion liest einen Wert aus Calldata beliebiger Länge (bis zu 32 Bytes, der Wortgröße).
+
+```solidity
+ {
+ uint _retVal;
+
+ require(length < 0x21,
+ "_calldataVal-Längenlimit beträgt 32 Bytes");
+ require(length + startByte <= msg.data.length,
+ "_calldataVal versucht, über die Calldata-Größe hinaus zu lesen");
+```
+
+Diese Funktion ist intern. Wenn also der Rest des Codes korrekt geschrieben ist, sind diese Tests nicht erforderlich. Sie kosten jedoch nicht viel, also können wir sie auch gleich einbauen.
+
+```solidity
+ assembly {
+ _retVal := calldataload(startByte)
+ }
+```
+
+Dieser Code ist in [Yul](https://docs.soliditylang.org/en/v0.8.16/yul.html). Er liest einen 32-Byte-Wert aus Calldata. Dies funktioniert auch, wenn Calldata vor `startByte+32` aufhört, da nicht initialisierter Speicherplatz in der EVM als Null betrachtet wird.
+
+```solidity
+ _retVal = _retVal >> (256-length*8);
+```
+
+Wir wollen nicht unbedingt einen 32-Byte-Wert. Dadurch werden die überzähligen Bytes entfernt.
+
+```solidity
+ return _retVal;
+ } // _calldataVal
+
+
+ // Einen einzelnen Parameter aus Calldata lesen, beginnend bei _fromByte
+ function _readParam(uint _fromByte) internal
+ returns (uint _nextByte, uint _parameterValue)
+ {
+```
+
+Lesen Sie einen einzelnen Parameter aus Calldata. Beachten Sie, dass wir nicht nur den gelesenen Wert zurückgeben müssen, sondern auch den Ort des nächsten Bytes, da die Parameter von 1 Byte bis zu 33 Bytes lang sein können.
+
+```solidity
+ // Das erste Byte sagt uns, wie der Rest zu interpretieren ist
+ uint8 _firstByte;
+
+ _firstByte = uint8(_calldataVal(_fromByte, 1));
+```
+
+Solidity versucht, die Anzahl der Fehler zu reduzieren, indem es potenziell gefährliche [implizite Typumwandlungen](https://docs.soliditylang.org/en/v0.8.16/types.html#implicit-conversions) verbietet. Ein Downgrade, zum Beispiel von 256 Bit auf 8 Bit, muss explizit sein.
+
+```solidity
+
+ // Den Wert lesen, aber nicht in den Cache schreiben
+ if (_firstByte == uint8(DONT_CACHE))
+ return(_fromByte+33, _calldataVal(_fromByte+1, 32));
+
+ // Den Wert lesen und in den Cache schreiben
+ if (_firstByte == uint8(INTO_CACHE)) {
+ uint _param = _calldataVal(_fromByte+1, 32);
+ cacheWrite(_param);
+ return(_fromByte+33, _param);
+ }
+
+ // Wenn wir hier angekommen sind, bedeutet das, dass wir aus dem Cache lesen müssen
+
+ // Anzahl der zusätzlich zu lesenden Bytes
+ uint8 _extraBytes = _firstByte / 16;
+```
+
+Nehmen Sie das untere [Nibble](https://en.wikipedia.org/wiki/Nibble) und kombinieren Sie es mit den anderen Bytes, um den Wert aus dem Cache zu lesen.
+
+```solidity
+ uint _key = (uint256(_firstByte & 0x0F) << (8*_extraBytes)) +
+ _calldataVal(_fromByte+1, _extraBytes);
+
+ return (_fromByte+_extraBytes+1, cacheRead(_key));
+
+ } // _readParam
+
+
+ // n Parameter lesen (Funktionen wissen, wie viele Parameter sie erwarten)
+ function _readParams(uint _paramNum) internal returns (uint[] memory) {
+```
+
+Wir könnten die Anzahl der Parameter, die wir haben, aus Calldata selbst entnehmen, aber die Funktionen, die uns aufrufen, wissen, wie viele Parameter sie erwarten. Es ist einfacher, wenn sie es uns sagen.
+
+```solidity
+ // Die Parameter, die wir lesen
+ uint[] memory params = new uint[](_paramNum);
+
+ // Die Parameter beginnen bei Byte 4, davor steht die Funktionssignatur
+ uint _atByte = 4;
+
+ for(uint i=0; i<_paramNum; i++) {
+ (_atByte, params[i]) = _readParam(_atByte);
+ }
+```
+
+Lesen Sie die Parameter, bis Sie die benötigte Anzahl haben. Wenn wir das Ende von Calldata überschreiten, wird `_readParams` den Aufruf rückgängig machen.
+
+```solidity
+
+ return(params);
+ } // readParams
+
+ // Zum Testen von _readParams, das Lesen von vier Parametern testen
+ function fourParam() public
+ returns (uint256,uint256,uint256,uint256)
+ {
+ uint[] memory params;
+ params = _readParams(4);
+ return (params[0], params[1], params[2], params[3]);
+ } // fourParam
+```
+
+Ein großer Vorteil von Foundry ist, dass Tests in Solidity geschrieben werden können ([siehe Testen des Caches unten](#testing-the-cache)). Dies macht Unit-Tests viel einfacher. Dies ist eine Funktion, die vier Parameter liest und sie zurückgibt, damit der Test überprüfen kann, ob sie korrekt waren.
+
+```solidity
+ // Einen Wert abrufen, Bytes zurückgeben, die ihn kodieren (wenn möglich unter Verwendung des Caches)
+ function encodeVal(uint _val) public view returns(bytes memory) {
+```
+
+`encodeVal` ist eine Funktion, die Off-Chain-Code aufruft, um Calldata zu erstellen, die den Cache nutzen. Sie empfängt einen einzelnen Wert und gibt die Bytes zurück, die ihn kodieren. Diese Funktion ist eine `view`, erfordert also keine Transaktion und kostet bei externem Aufruf kein Gas.
+
+```solidity
+ uint _key = val2key[_val];
+
+ // Der Wert ist noch nicht im Cache, fügen Sie ihn hinzu
+ if (_key == 0)
+ return bytes.concat(INTO_CACHE, bytes32(_val));
+```
+
+In der [EVM](/entwickler/docs/evm/) wird davon ausgegangen, dass jeder nicht initialisierte Speicher Null ist. Wenn wir also nach dem Schlüssel für einen nicht vorhandenen Wert suchen, erhalten wir eine Null. In diesem Fall sind die Bytes, die ihn kodieren, `INTO_CACHE` (damit er beim nächsten Mal zwischengespeichert wird), gefolgt von dem tatsächlichen Wert.
+
+```solidity
+ // Wenn der Schlüssel <0x10 ist, geben Sie ihn als einzelnes Byte zurück
+ if (_key < 0x10)
+ return bytes.concat(bytes1(uint8(_key)));
+```
+
+Einzelne Bytes sind am einfachsten. Wir verwenden einfach [`bytes.concat`](https://docs.soliditylang.org/en/v0.8.16/types.html#the-functions-bytes-concat-and-string-concat), um einen `bytes`-Typ in ein Byte-Array zu verwandeln, das eine beliebige Länge haben kann. Trotz des Namens funktioniert es auch mit nur einem Argument einwandfrei.
+
+```solidity
+ // Zwei-Byte-Wert, kodiert als 0x1vvv
+ if (_key < 0x1000)
+ return bytes.concat(bytes2(uint16(_key) | 0x1000));
+```
+
+Wenn wir einen Schlüssel haben, der kleiner als 163 ist, können wir ihn in zwei Bytes ausdrücken. Wir konvertieren zuerst `_key`, einen 256-Bit-Wert, in einen 16-Bit-Wert und verwenden ein logisches Oder, um die Anzahl der zusätzlichen Bytes zum ersten Byte hinzuzufügen. Dann wandeln wir es einfach in einen `bytes2`-Wert um, der in `bytes` umgewandelt werden kann.
+
+```solidity
+ // Es gibt wahrscheinlich eine clevere Möglichkeit, die folgenden Zeilen als Schleife auszuführen,
+ // aber es ist eine View-Funktion, also optimiere ich für die Zeit des Programmierers und
+ // die Einfachheit.
+
+ if (_key < 16*256**2)
+ return bytes.concat(bytes3(uint24(_key) | (0x2 * 16 * 256**2)));
+ if (_key < 16*256**3)
+ return bytes.concat(bytes4(uint32(_key) | (0x3 * 16 * 256**3)));
+ .
+ .
+ .
+ if (_key < 16*256**14)
+ return bytes.concat(bytes15(uint120(_key) | (0xE * 16 * 256**14)));
+ if (_key < 16*256**15)
+ return bytes.concat(bytes16(uint128(_key) | (0xF * 16 * 256**15)));
+```
+
+Die anderen Werte (3 Bytes, 4 Bytes usw.) werden auf die gleiche Weise behandelt, nur mit unterschiedlichen Feldgrößen.
+
+```solidity
+ // Wenn wir hier ankommen, ist etwas falsch.
+ revert("Fehler in encodeVal, sollte nicht passieren");
+```
+
+Wenn wir hier ankommen, bedeutet das, dass wir einen Schlüssel erhalten haben, der nicht kleiner als 16\*25615 ist. Aber `cacheWrite` begrenzt die Schlüssel, sodass wir nicht einmal bis zu 14\*25616 kommen (was ein erstes Byte von 0xFE hätte, also wie `DONT_CACHE` aussehen würde). Aber es kostet uns nicht viel, einen Test hinzuzufügen, für den Fall, dass ein zukünftiger Programmierer einen Fehler einbaut.
+
+```solidity
+ } // encodeVal
+
+} // Cache
+```
+
+### Testen des Caches {#testing-the-cache}
+
+Einer der Vorteile von Foundry ist, dass [Sie Tests in Solidity schreiben können](https://getfoundry.sh/forge/tests/overview/), was das Schreiben von Unit-Tests erleichtert. Die Tests für die `Cache`-Klasse sind [hier](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/test/Cache.t.sol). Da der Testcode repetitiv ist, wie es bei Tests oft der Fall ist, werden in diesem Artikel nur die interessanten Teile erklärt.
+
+```solidity
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import "forge-std/Test.sol";
+
+
+// Need to run `forge test -vv` for the console.
+import "forge-std/console.sol";
+```
+
+Dies ist nur eine Boilerplate, die notwendig ist, um das Testpaket und `console.log` zu verwenden.
+
+```solidity
+import "src/Cache.sol";
+```
+
+Wir müssen den Vertrag kennen, den wir testen.
+
+```solidity
+contract CacheTest is Test {
+ Cache cache;
+
+ function setUp() public {
+ cache = new Cache();
+ }
+```
+
+Die `setUp`-Funktion wird vor jedem Test aufgerufen. In diesem Fall erstellen wir einfach einen neuen Cache, damit sich unsere Tests nicht gegenseitig beeinflussen.
+
+```solidity
+ function testCaching() public {
+```
+
+Tests sind Funktionen, deren Namen mit `test` beginnen. Diese Funktion überprüft die grundlegende Cache-Funktionalität, das Schreiben von Werten und das erneute Lesen.
+
+```solidity
+ for(uint i=1; i<5000; i++) {
+ cache.cacheWrite(i*i);
+ }
+
+ for(uint i=1; i<5000; i++) {
+ assertEq(cache.cacheRead(i), i*i);
+```
+
+So führen Sie das eigentliche Testen mit [`assert...`-Funktionen](https://getfoundry.sh/reference/forge-std/std-assertions/) durch. In diesem Fall prüfen wir, ob der Wert, den wir geschrieben haben, auch der ist, den wir lesen. Wir können das Ergebnis von `cache.cacheWrite` verwerfen, da wir wissen, dass Cache-Schlüssel linear vergeben werden.
+
+```solidity
+ }
+ } // testCaching
+
+
+ // Cache the same value multiple times, ensure that the key stays
+ // the same
+ function testRepeatCaching() public {
+ for(uint i=1; i<100; i++) {
+ uint _key1 = cache.cacheWrite(i);
+ uint _key2 = cache.cacheWrite(i);
+ assertEq(_key1, _key2);
+ }
+```
+
+Zuerst schreiben wir jeden Wert zweimal in den Cache und stellen sicher, dass die Schlüssel identisch sind (was bedeutet, dass der zweite Schreibvorgang nicht wirklich stattgefunden hat).
+
+```solidity
+ for(uint i=1; i<100; i+=3) {
+ uint _key = cache.cacheWrite(i);
+ assertEq(_key, i);
+ }
+ } // testRepeatCaching
+```
+
+Theoretisch könnte es einen Fehler geben, der sich nicht auf aufeinanderfolgende Cache-Schreibvorgänge auswirkt. Hier führen wir also einige Schreibvorgänge durch, die nicht aufeinanderfolgen, und sehen, dass die Werte immer noch nicht neu geschrieben werden.
+
+```solidity
+ // Read a uint from a memory buffer (to make sure we get back the parameters
+ // we sent out)
+ function toUint256(bytes memory _bytes, uint256 _start) internal pure
+ returns (uint256)
+```
+
+Liest ein 256-Bit-Wort aus einem `bytes memory`-Puffer. Mit dieser Hilfsfunktion können wir überprüfen, ob wir die richtigen Ergebnisse erhalten, wenn wir einen Funktionsaufruf ausführen, der den Cache verwendet.
+
+```solidity
+ {
+ require(_bytes.length >= _start + 32, "toUint256_outOfBounds");
+ uint256 tempUint;
+
+ assembly {
+ tempUint := mload(add(add(_bytes, 0x20), _start))
+ }
+```
+
+Yul unterstützt keine Datenstrukturen jenseits von `uint256`. Wenn Sie also auf eine komplexere Datenstruktur wie den Speicherpuffer `_bytes` verweisen, erhalten Sie die Adresse dieser Struktur. Solidity speichert `bytes memory`-Werte als 32-Byte-Wort, das die Länge enthält, gefolgt von den eigentlichen Bytes. Um also Byte-Nummer `_start` zu erhalten, müssen wir `_bytes+32+_start` berechnen.
+
+```solidity
+
+ return tempUint;
+ } // toUint256
+
+ // Function signature for fourParams(), courtesy of
+ // https://www.4byte.directory/signatures/?bytes4_signature=0x3edc1e6d
+ bytes4 constant FOUR_PARAMS = 0x3edc1e6d;
+
+ // Just some constant values to see we're getting the correct values back
+ uint256 constant VAL_A = 0xDEAD60A7;
+ uint256 constant VAL_B = 0xBEEF;
+ uint256 constant VAL_C = 0x600D;
+ uint256 constant VAL_D = 0x600D60A7;
+```
+
+Einige Konstanten, die wir für Tests benötigen.
+
+```solidity
+ function testReadParam() public {
+```
+
+Rufen Sie `fourParams()` auf, eine Funktion, die `readParams` verwendet, um zu testen, ob wir Parameter korrekt lesen können.
+
+```solidity
+ address _cacheAddr = address(cache);
+ bool _success;
+ bytes memory _callInput;
+ bytes memory _callOutput;
+```
+
+Wir können den normalen ABI-Mechanismus nicht verwenden, um eine Funktion über den Cache aufzurufen, daher müssen wir den Low-Level-Mechanismus [`.call()`](https://docs.soliditylang.org/en/v0.8.16/types.html#members-of-addresses) verwenden. Dieser Mechanismus verwendet `bytes memory` als Eingabe und gibt diese (sowie einen booleschen Wert) als Ausgabe zurück.
+
+```solidity
+ // Erster Aufruf, der Cache ist leer
+ _callInput = bytes.concat(
+ FOUR_PARAMS,
+```
+
+Es ist nützlich, wenn derselbe Vertrag sowohl zwischengespeicherte Funktionen (für Aufrufe direkt aus Transaktionen) als auch nicht zwischengespeicherte Funktionen (für Aufrufe von anderen Smart Contracts) unterstützt. Dazu müssen wir uns weiterhin auf den Solidity-Mechanismus verlassen, um die richtige Funktion aufzurufen, anstatt alles in [eine `fallback`-Funktion](https://docs.soliditylang.org/en/v0.8.16/contracts.html#fallback-function) zu packen. Dies macht die Zusammensetzbarkeit wesentlich einfacher. Ein einzelnes Byte würde in den meisten Fällen ausreichen, um die Funktion zu identifizieren, sodass wir drei Bytes (16\*3=48 Gas) verschwenden. Als ich das schrieb, kosteten diese 48 Gas jedoch 0,07 Cent, was ein angemessener Preis für einfacheren, weniger fehleranfälligen Code ist.
+
+```solidity
+ // Erster Wert, zum Cache hinzufügen
+ cache.INTO_CACHE(),
+ bytes32(VAL_A),
+```
+
+Der erste Wert: Eine Markierung, die besagt, dass es sich um einen vollständigen Wert handelt, der in den Cache geschrieben werden muss, gefolgt von den 32 Bytes des Wertes. Die anderen drei Werte sind ähnlich, mit der Ausnahme, dass `VAL_B` nicht in den Cache geschrieben wird und `VAL_C` sowohl der dritte als auch der vierte Parameter ist.
+
+```solidity
+ .
+ .
+ .
+ );
+ (_success, _callOutput) = _cacheAddr.call(_callInput);
+```
+
+Hier rufen wir den `Cache`-Vertrag auf.
+
+```solidity
+ assertEq(_success, true);
+```
+
+Wir erwarten, dass der Anruf erfolgreich ist.
+
+```solidity
+ assertEq(cache.cacheRead(1), VAL_A);
+ assertEq(cache.cacheRead(2), VAL_C);
+```
+
+Wir beginnen mit einem leeren Cache und fügen dann `VAL_A` gefolgt von `VAL_C` hinzu. Wir erwarten, dass der erste den Schlüssel 1 und der zweite den Schlüssel 2 hat.
+
+```
+ assertEq(toUint256(_callOutput,0), VAL_A);
+ assertEq(toUint256(_callOutput,32), VAL_B);
+ assertEq(toUint256(_callOutput,64), VAL_C);
+ assertEq(toUint256(_callOutput,96), VAL_C);
+```
+
+Die Ausgabe sind die vier Parameter. Hier überprüfen wir, ob es richtig ist.
+
+```solidity
+ // Zweiter Aufruf, wir können den Cache verwenden
+ _callInput = bytes.concat(
+ FOUR_PARAMS,
+
+ // Erster Wert im Cache
+ bytes1(0x01),
+```
+
+Cache-Schlüssel unter 16 sind nur ein Byte lang.
+
+```solidity
+ // Zweiter Wert, nicht zum Cache hinzufügen
+ cache.DONT_CACHE(),
+ bytes32(VAL_B),
+
+ // Dritter und vierter Wert, gleicher Wert
+ bytes1(0x02),
+ bytes1(0x02)
+ );
+ .
+ .
+ .
+ } // testReadParam
+```
+
+Die Tests nach dem Aufruf sind identisch mit denen nach dem ersten Aufruf.
+
+```solidity
+ function testEncodeVal() public {
+```
+
+Diese Funktion ist ähnlich wie `testReadParam`, nur dass wir die Parameter nicht explizit schreiben, sondern `encodeVal()` verwenden.
+
+```solidity
+ .
+ .
+ .
+ _callInput = bytes.concat(
+ FOUR_PARAMS,
+ cache.encodeVal(VAL_A),
+ cache.encodeVal(VAL_B),
+ cache.encodeVal(VAL_C),
+ cache.encodeVal(VAL_D)
+ );
+ .
+ .
+ .
+ assertEq(_callInput.length, 4+1*4);
+ } // testEncodeVal
+```
+
+Der einzige zusätzliche Test in `testEncodeVal()` besteht darin, zu überprüfen, ob die Länge von `_callInput` korrekt ist. Für den ersten Aufruf ist es 4+33\*4. Beim zweiten, bei dem jeder Wert bereits im Cache ist, ist es 4+1\*4.
+
+```solidity
+ // Testen Sie encodeVal, wenn der Schlüssel mehr als ein einzelnes Byte hat
+ // Maximal drei Bytes, da das Füllen des Caches auf vier Bytes zu lange dauert.
+ function testEncodeValBig() public {
+ // Legen Sie eine Reihe von Werten in den Cache.
+ // Um die Dinge einfach zu halten, verwenden Sie den Schlüssel n für den Wert n.
+ for(uint i=1; i<0x1FFF; i++) {
+ cache.cacheWrite(i);
+ }
+```
+
+Die obige Funktion `testEncodeVal` schreibt nur vier Werte in den Cache, so dass [der Teil der Funktion, der sich mit Multi-Byte-Werten befasst](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/src/Cache.sol#L144-L171), nicht überprüft wird. Aber dieser Code ist kompliziert und fehleranfällig.
+
+Der erste Teil dieser Funktion ist eine Schleife, die alle Werte von 1 bis 0x1FFF in der richtigen Reihenfolge in den Cache schreibt, damit wir diese Werte kodieren können und wissen, wohin sie gehen.
+
+```solidity
+ .
+ .
+ .
+
+ _callInput = bytes.concat(
+ FOUR_PARAMS,
+ cache.encodeVal(0x000F), // Ein Byte 0x0F
+ cache.encodeVal(0x0010), // Zwei Bytes 0x1010
+ cache.encodeVal(0x0100), // Zwei Bytes 0x1100
+ cache.encodeVal(0x1000) // Drei Bytes 0x201000
+ );
+```
+
+Testen Sie Ein-Byte-, Zwei-Byte- und Drei-Byte-Werte. Wir testen nicht darüber hinaus, da es zu lange dauern würde, genügend Stack-Einträge zu schreiben (mindestens 0x10000000, etwa eine Viertelmilliarde).
+
+```solidity
+ .
+ .
+ .
+ .
+ } // testEncodeValBig
+
+
+ // Test, was bei einem zu kleinen Puffer zu einem Revert führt
+ function testShortCalldata() public {
+```
+
+Testen Sie, was im anormalen Fall passiert, wenn nicht genügend Parameter vorhanden sind.
+
+```solidity
+ .
+ .
+ .
+ (_success, _callOutput) = _cacheAddr.call(_callInput);
+ assertEq(_success, false);
+ } // testShortCalldata
+```
+
+Da es zurückgesetzt wird, sollte das Ergebnis, das wir erhalten, `false` sein.
+
+```
+ // Aufruf mit nicht vorhandenen Cache-Schlüsseln
+ function testNoCacheKey() public {
+ .
+ .
+ .
+ _callInput = bytes.concat(
+ FOUR_PARAMS,
+
+ // Erster Wert, zum Cache hinzufügen
+ cache.INTO_CACHE(),
+ bytes32(VAL_A),
+
+ // Zweiter Wert
+ bytes1(0x0F),
+ bytes2(0x1234),
+ bytes11(0xA10102030405060708090A)
+ );
+```
+
+Diese Funktion erhält vier vollkommen legitime Parameter, nur dass der Cache leer ist und es keine Werte zum Lesen gibt.
+
+```solidity
+ .
+ .
+ .
+ // Test, ob bei einem übermäßig langen Puffer alles funktioniert
+ function testLongCalldata() public {
+ address _cacheAddr = address(cache);
+ bool _success;
+ bytes memory _callInput;
+ bytes memory _callOutput;
+
+ // Erster Aufruf, der Cache ist leer
+ _callInput = bytes.concat(
+ FOUR_PARAMS,
+
+ // Erster Wert, zum Cache hinzufügen
+ cache.INTO_CACHE(), bytes32(VAL_A),
+
+ // Zweiter Wert, zum Cache hinzufügen
+ cache.INTO_CACHE(), bytes32(VAL_B),
+
+ // Dritter Wert, zum Cache hinzufügen
+ cache.INTO_CACHE(), bytes32(VAL_C),
+
+ // Vierter Wert, zum Cache hinzufügen
+ cache.INTO_CACHE(), bytes32(VAL_D),
+
+ // Und ein weiterer Wert für „Viel Glück“
+ bytes4(0x31112233)
+ );
+```
+
+Diese Funktion sendet fünf Werte. Wir wissen, dass der fünfte Wert ignoriert wird, weil er kein gültiger Cache-Eintrag ist, was zu einer Zurückweisung geführt hätte, wenn er nicht enthalten gewesen wäre.
+
+```solidity
+ (_success, _callOutput) = _cacheAddr.call(_callInput);
+ assertEq(_success, true);
+ .
+ .
+ .
+ } // testLongCalldata
+
+} // CacheTest
+
+```
+
+## Eine Beispielanwendung {#a-sample-app}
+
+Tests in Solidity zu schreiben ist schön und gut, aber am Ende muss eine Dapp in der Lage sein, Anfragen von außerhalb der Kette zu verarbeiten, um nützlich zu sein. Dieser Artikel zeigt, wie man Caching in einer Dapp mit `WORM` verwendet, was für „Write Once, Read Many“ steht. Wenn ein Schlüssel noch nicht geschrieben ist, können Sie einen Wert darauf schreiben. Wenn der Schlüssel bereits geschrieben ist, erhalten Sie einen Revert.
+
+### Der Vertrag {#the-contract}
+
+[Dies ist der Vertrag](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/src/WORM.sol). Es wiederholt größtenteils, was wir bereits mit `Cache` und `CacheTest` gemacht haben, also behandeln wir nur die Teile, die interessant sind.
+
+```solidity
+import "./Cache.sol";
+
+contract WORM is Cache {
+```
+
+Der einfachste Weg, `Cache` zu verwenden, ist, es in unserem eigenen Vertrag zu erben.
+
+```solidity
+ function writeEntryCached() external {
+ uint[] memory params = _readParams(2);
+ writeEntry(params[0], params[1]);
+ } // writeEntryCached
+```
+
+Diese Funktion ist ähnlich wie `fourParam` in `CacheTest` oben. Da wir die ABI-Spezifikationen nicht befolgen, ist es am besten, keine Parameter in der Funktion zu deklarieren.
+
+```solidity
+ // Machen Sie es einfacher, uns anzurufen
+ // Funktionssignatur für writeEntryCached(), mit freundlicher Genehmigung von
+ // https://www.4byte.directory/signatures/?bytes4_signature=0xe4e4f2d3
+ bytes4 constant public WRITE_ENTRY_CACHED = 0xe4e4f2d3;
+```
+
+Der externe Code, der `writeEntryCached` aufruft, muss die Calldata manuell erstellen, anstatt `worm.writeEntryCached` zu verwenden, da wir die ABI-Spezifikationen nicht befolgen. Dieser konstante Wert erleichtert das Schreiben.
+
+Beachten Sie, dass wir `WRITE_ENTRY_CACHED` zwar als Zustandsvariable definieren, zum externen Lesen jedoch die Getter-Funktion `worm.WRITE_ENTRY_CACHED()` verwendet werden muss.
+
+```solidity
+ function readEntry(uint key) public view
+ returns (uint _value, address _writtenBy, uint _writtenAtBlock)
+```
+
+Die Lesefunktion ist eine `View`-Funktion, erfordert also keine Transaktion und kostet kein Gas. Daher gibt es keinen Vorteil, den Cache für den Parameter zu verwenden. Bei Ansichtsfunktionen ist es am besten, den einfacheren Standardmechanismus zu verwenden.
+
+### Der Test-Code {#the-testing-code}
+
+[Dies ist der Test-Code für den Vertrag](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/test/WORM.t.sol). Nochmals, lassen Sie uns nur das Interessante betrachten.
+
+```solidity
+ function testWReadWrite() public {
+ worm.writeEntry(0xDEAD, 0x60A7);
+
+ vm.expectRevert(bytes("Eintrag bereits geschrieben"));
+ worm.writeEntry(0xDEAD, 0xBEEF);
+```
+
+[Dies (`vm.expectRevert`)](https://book.getfoundry.sh/cheatcodes/expect-revert#expectrevert) ist, wie wir in einem Foundry-Test angeben, dass der nächste Aufruf fehlschlagen sollte, und der gemeldete Grund für einen Fehler. Dies gilt, wenn wir die Syntax `. verwenden()` anstatt die Calldata zu erstellen und den Vertrag über die Low-Level-Schnittstelle aufzurufen (`.call()` usw.).
+
+```solidity
+ function testReadWriteCached() public {
+ uint cacheGoat = worm.cacheWrite(0x60A7);
+```
+
+Hier verwenden wir die Tatsache, dass `cacheWrite` den Cache-Schlüssel zurückgibt. Dies ist nichts, was wir in der Produktion erwarten würden, da `cacheWrite` den Zustand ändert und daher nur während einer Transaktion aufgerufen werden kann. Transaktionen haben keine Rückgabewerte. Wenn sie Ergebnisse haben, sollen diese als Ereignisse ausgegeben werden. Der Rückgabewert von `cacheWrite` ist also nur von On-Chain-Code aus zugänglich, und On-Chain-Code benötigt kein Parameter-Caching.
+
+```solidity
+ (_success,) = address(worm).call(_callInput);
+```
+
+So teilen wir Solidity mit, dass `.call()` zwar zwei Rückgabewerte hat, wir aber nur am ersten interessiert sind.
+
+```solidity
+ (_success,) = address(worm).call(_callInput);
+ assertEq(_success, false);
+```
+
+Da wir die Low-Level-Funktion `.call()` verwenden, können wir `vm.expectRevert()` nicht verwenden und müssen uns den booleschen Erfolgswert ansehen, den wir vom Aufruf erhalten.
+
+```solidity
+ event EntryWritten(uint indexed key, uint indexed value);
+
+ .
+ .
+ .
+
+ _callInput = bytes.concat(
+ worm.WRITE_ENTRY_CACHED(), worm.encodeVal(a), worm.encodeVal(b));
+ vm.expectEmit(true, true, false, false);
+ emit EntryWritten(a, b);
+ (_success,) = address(worm).call(_callInput);
+```
+
+So überprüfen wir, ob der Code in Foundry [ein Ereignis korrekt ausgibt](https://getfoundry.sh/reference/cheatcodes/expect-emit/).
+
+### Der Client {#the-client}
+
+Was man mit Solidity-Tests nicht bekommt, ist JavaScript-Code, den man kopieren und in die eigene Anwendung einfügen kann. Um diesen Code zu schreiben, habe ich WORM im [Optimism Goerli](https://community.optimism.io/docs/useful-tools/networks/#optimism-goerli), dem neuen Testnet von [Optimism](https://www.optimism.io/), bereitgestellt. Es befindet sich an der Adresse [`0xd34335b1d818cee54e3323d3246bd31d94e6a78a`](https://goerli-optimism.etherscan.io/address/0xd34335b1d818cee54e3323d3246bd31d94e6a78a).
+
+[Sie können den JavaScript-Code für den Client hier sehen](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/javascript/index.js). So verwenden Sie es:
+
+1. Klonen Sie das Git-Repository:
+
+ ```sh
+ git clone https://github.com/qbzzt/20220915-all-you-can-cache.git
+ ```
+
+2. Installieren Sie die erforderlichen Pakete:
+
+ ```sh
+ cd javascript
+ yarn
+ ```
+
+3. Kopieren Sie die Konfigurationsdatei:
+
+ ```sh
+ cp .env.example .env
+ ```
+
+4. Bearbeiten Sie `.env` für Ihre Konfiguration:
+
+ | Parameter | Wert |
+ | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+ | MNEMONIC | Die Mnemonik für ein Konto, das genug ETH hat, um eine Transaktion zu bezahlen. [Hier können Sie kostenlose ETH für das Optimism Goerli-Netzwerk erhalten](https://optimismfaucet.xyz/). |
+ | OPTIMISM_GOERLI_URL | URL zu Optimism Goerli. Der öffentliche Endpunkt `https://goerli.optimism.io` ist ratenbegrenzt, aber für das, was wir hier brauchen, ausreichend. |
+
+5. Führen Sie `index.js` aus.
+
+ ```sh
+ node index.js
+ ```
+
+ Diese Beispielanwendung schreibt zunächst einen Eintrag in WORM und zeigt die Calldata und einen Link zur Transaktion auf Etherscan an. Dann liest es diesen Eintrag zurück und zeigt den verwendeten Schlüssel und die Werte im Eintrag an (Wert, Blocknummer und Autor).
+
+Der größte Teil des Clients ist normales Dapp-JavaScript. Auch hier gehen wir nur die interessanten Teile durch.
+
+```javascript
+.
+.
+.
+const main = async () => {
+ const func = await worm.WRITE_ENTRY_CACHED()
+
+ // Jedes Mal einen neuen Schlüssel benötigen
+ const key = await worm.encodeVal(Number(new Date()))
+```
+
+Ein bestimmter Slot kann nur einmal beschrieben werden, daher verwenden wir den Zeitstempel, um sicherzustellen, dass wir keine Slots wiederverwenden.
+
+```javascript
+const val = await worm.encodeVal("0x600D")
+
+// Einen Eintrag schreiben
+const calldata = func + key.slice(2) + val.slice(2)
+```
+
+Ethers erwartet, dass die Aufrufdaten (call data) eine Hex-Zeichenfolge sind, also `0x` gefolgt von einer geraden Anzahl hexadezimaler Ziffern. Da `key` und `val` beide mit `0x` beginnen, müssen wir diese Header entfernen.
+
+```javascript
+const tx = await worm.populateTransaction.writeEntryCached()
+tx.data = calldata
+
+sentTx = await wallet.sendTransaction(tx)
+```
+
+Wie beim Solidity-Testcode können wir eine zwischengespeicherte Funktion nicht normal aufrufen. Stattdessen müssen wir einen Mechanismus auf niedrigerer Ebene verwenden.
+
+```javascript
+ .
+ .
+ .
+ // Lesen des gerade geschriebenen Eintrags
+ const realKey = '0x' + key.slice(4) // das FF-Flag entfernen
+ const entryRead = await worm.readEntry(realKey)
+ .
+ .
+ .
+```
+
+Zum Lesen von Einträgen können wir den normalen Mechanismus verwenden. Es ist nicht erforderlich, Parameter-Caching mit `view`-Funktionen zu verwenden.
+
+## Fazit {#conclusion}
+
+Der Code in diesem Artikel ist ein Proof of Concept, dessen Zweck es ist, die Idee leicht verständlich zu machen. Für ein produktionsreifes System sollten Sie möglicherweise einige zusätzliche Funktionen implementieren:
+
+- Behandeln Sie Werte, die nicht `uint256` sind. Zum Beispiel Zeichenketten.
+- Anstelle eines globalen Caches könnten Sie eine Zuordnung zwischen Benutzern und Caches haben. Verschiedene Benutzer verwenden unterschiedliche Werte.
+- Werte, die für Adressen verwendet werden, unterscheiden sich von denen, die für andere Zwecke verwendet werden. Es könnte sinnvoll sein, einen separaten Cache nur für Adressen zu haben.
+- Derzeit basieren die Cache-Schlüssel auf einem „First come, smallest key“-Algorithmus. Die ersten sechzehn Werte können als einzelnes Byte gesendet werden. Die nächsten 4080 Werte können als zwei Bytes gesendet werden. Die nächste Million Werte sind drei Bytes usw. Ein Produktionssystem sollte Nutzungszähler für Cache-Einträge führen und diese so neu organisieren, dass die sechzehn _häufigsten_ Werte ein Byte, die nächsten 4080 häufigsten Werte zwei Bytes usw. sind.
+
+ Dies ist jedoch eine potenziell gefährliche Operation. Stellen Sie sich die folgende Abfolge von Ereignissen vor:
+
+ 1. Noam Naive ruft `encodeVal` auf, um die Adresse zu kodieren, an die er Token senden möchte. Diese Adresse ist eine der ersten, die in der Anwendung verwendet wird, daher ist der kodierte Wert 0x06. Dies ist eine `view`-Funktion, keine Transaktion, also ist es zwischen Noam und dem von ihm verwendeten Knoten, und niemand sonst weiß davon.
+
+ 2. Owen Owner führt die Neuanordnung des Caches durch. Sehr wenige Leute verwenden diese Adresse tatsächlich, daher ist sie jetzt als 0x201122 kodiert. Ein anderer Wert, 1018, wird 0x06 zugewiesen.
+
+ 3. Noam Naive sendet seine Token an 0x06. Sie gehen an die Adresse `0x0000000000000000000000000de0b6b3a7640000`, und da niemand den privaten Schlüssel für diese Adresse kennt, bleiben sie dort einfach stecken. Noam ist _nicht glücklich_.
+
+ Es gibt Möglichkeiten, dieses Problem und das damit zusammenhängende Problem von Transaktionen, die sich während der Neuanordnung des Caches im Mempool befinden, zu lösen, aber Sie müssen sich dessen bewusst sein.
+
+Ich habe hier Caching mit Optimism demonstriert, weil ich ein Optimism-Mitarbeiter bin und dies das Rollup ist, das ich am besten kenne. Aber es sollte mit jedem Rollup funktionieren, das minimale Kosten für die interne Verarbeitung verlangt, sodass im Vergleich dazu das Schreiben der Transaktionsdaten auf L1 der Hauptaufwand ist.
+
+[Hier finden Sie mehr von meiner Arbeit](https://cryptodocguy.pro/).
+
diff --git a/public/content/translations/de/developers/tutorials/app-plasma/index.md b/public/content/translations/de/developers/tutorials/app-plasma/index.md
new file mode 100644
index 00000000000..df5ca6104a5
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/app-plasma/index.md
@@ -0,0 +1,1261 @@
+---
+title: Schreiben Sie ein App-spezifisches Plasma, das die Privatsphäre wahrt
+description: In diesem Tutorial bauen wir eine halbgeheime Bank für Einlagen. Die Bank ist eine zentralisierte Komponente; sie kennt das Guthaben jedes Benutzers. Diese Informationen werden jedoch nicht onchain gespeichert. Stattdessen veröffentlicht die Bank einen Hash des Zustands. Jedes Mal, wenn eine Transaktion stattfindet, veröffentlicht die Bank den neuen Hash, zusammen mit einem Zero-Knowledge-Proof, dass sie eine signierte Transaktion hat, die den Hash-Zustand in den neuen ändert. Nach der Lektüre dieses Tutorials werden Sie nicht nur verstehen, wie man Zero-Knowledge-Proofs verwendet, sondern auch, warum man sie verwendet und wie man dies sicher tut.
+author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+tags:
+ [
+ "Zero-Knowledge",
+ "Server",
+ "Off-Chain",
+ "Privatsphäre"
+ ]
+skill: advanced
+lang: de
+published: 2025-10-15
+---
+
+## Einführung {#introduction}
+
+Im Gegensatz zu [Rollups](/developers/docs/scaling/zk-rollups/) nutzen [Plasmas](/developers/docs/scaling/plasma) das Ethereum-Mainnet für die Integrität, aber nicht für die Verfügbarkeit. In diesem Artikel schreiben wir eine Anwendung, die sich wie ein Plasma verhält, wobei Ethereum die Integrität (keine unbefugten Änderungen), aber nicht die Verfügbarkeit (eine zentralisierte Komponente kann ausfallen und das gesamte System lahmlegen) garantiert.
+
+Die Anwendung, die wir hier schreiben, ist eine Bank, die die Privatsphäre wahrt. Verschiedene Adressen haben Konten mit Guthaben, und sie können Geld (ETH) an andere Konten senden. Die Bank veröffentlicht Hashes des Zustands (Konten und deren Guthaben) und Transaktionen, hält aber die tatsächlichen Guthaben offchain, wo sie privat bleiben können.
+
+## Design {#design}
+
+Dies ist kein produktionsreifes System, sondern ein Lehrmittel. Als solches ist es mit mehreren vereinfachenden Annahmen geschrieben.
+
+- Fester Konten-Pool. Es gibt eine bestimmte Anzahl von Konten, und jedes Konto gehört zu einer vorbestimmten Adresse. Dies sorgt für ein viel einfacheres System, da es schwierig ist, Datenstrukturen variabler Größe in Zero-Knowledge-Proofs zu handhaben. Für ein produktionsreifes System können wir die [Merkle-Root](/developers/tutorials/merkle-proofs-for-offline-data-integrity/) als Zustands-Hash verwenden und Merkle-Proofs für die erforderlichen Guthaben bereitstellen.
+
+- Arbeitsspeicher. Auf einem Produktionssystem müssen wir alle Kontoguthaben auf die Festplatte schreiben, um sie im Falle eines Neustarts zu erhalten. Hier ist es in Ordnung, wenn die Informationen einfach verloren gehen.
+
+- Nur Überweisungen. Ein Produktionssystem würde eine Möglichkeit erfordern, Vermögenswerte bei der Bank einzuzahlen und abzuheben. Aber der Zweck hier ist nur, das Konzept zu veranschaulichen, daher ist diese Bank auf Überweisungen beschränkt.
+
+### Zero-Knowledge-Proofs {#zero-knowledge-proofs}
+
+Auf einer fundamentalen Ebene zeigt ein Zero-Knowledge-Proof, dass der Beweisführer einige Daten, _Datenprivat_, kennt, sodass eine Beziehung _Beziehung_ zwischen einigen öffentlichen Daten, _Datenöffentlich_, und _Datenprivat_ besteht. Der Verifizierer kennt _Beziehung_ und _Datenöffentlich_.
+
+Um die Privatsphäre zu wahren, müssen die Zustände und die Transaktionen privat sein. Aber um die Integrität zu gewährleisten, muss der [kryptographische Hash](https://de.wikipedia.org/wiki/Kryptographische_Hashfunktion) der Zustände öffentlich sein. Um den Leuten, die Transaktionen einreichen, zu beweisen, dass diese Transaktionen wirklich stattgefunden haben, müssen wir auch Transaktions-Hashes veröffentlichen.
+
+In den meisten Fällen sind _Datenprivat_ die Eingabe für das Zero-Knowledge-Proof-Programm und _Datenöffentlich_ die Ausgabe.
+
+Diese Felder in _Datenprivat_:
+
+- _Zustandn_, der alte Zustand
+- _Zustandn+1_, der neue Zustand
+- _Transaktion_, eine Transaktion, die den alten Zustand in den neuen ändert. Diese Transaktion muss diese Felder enthalten:
+ - _Zieladresse_, die die Überweisung empfängt
+ - _Betrag_, der überwiesen wird
+ - _Nonce_, um sicherzustellen, dass jede Transaktion nur einmal verarbeitet werden kann.
+ Die Quelladresse muss nicht in der Transaktion enthalten sein, da sie aus der Signatur wiederhergestellt werden kann.
+- _Signatur_, eine Signatur, die zur Durchführung der Transaktion berechtigt ist. In unserem Fall ist die einzige Adresse, die zur Durchführung einer Transaktion berechtigt ist, die Quelladresse. Da unser Zero-Knowledge-System so funktioniert, wie es funktioniert, benötigen wir zusätzlich zur Ethereum-Signatur auch den öffentlichen Schlüssel des Kontos.
+
+Dies sind die Felder in _Datenöffentlich_:
+
+- _Hash(Zustandn)_, der Hash des alten Zustands
+- _Hash(Zustandn+1)_, der Hash des neuen Zustands
+- _Hash(Transaktion)_, der Hash der Transaktion, der den Zustand von _Zustandn_ zu _Zustandn+1_ ändert.
+
+Die Beziehung überprüft mehrere Bedingungen:
+
+- Die öffentlichen Hashes sind tatsächlich die korrekten Hashes für die privaten Felder.
+- Die Transaktion, angewendet auf den alten Zustand, ergibt den neuen Zustand.
+- Die Signatur stammt von der Quelladresse der Transaktion.
+
+Aufgrund der Eigenschaften von kryptographischen Hash-Funktionen ist der Beweis dieser Bedingungen ausreichend, um die Integrität zu gewährleisten.
+
+### Datenstrukturen {#data-structures}
+
+Die primäre Datenstruktur ist der Zustand, der vom Server gehalten wird. Für jedes Konto verfolgt der Server das Kontoguthaben und eine [Nonce](https://de.wikipedia.org/wiki/Nonce), die verwendet wird, um [Replay-Angriffe](https://de.wikipedia.org/wiki/Replay-Angriff) zu verhindern.
+
+### Komponenten {#components}
+
+Dieses System erfordert zwei Komponenten:
+
+- Der _Server_, der Transaktionen empfängt, verarbeitet und Hashes zusammen mit den Zero-Knowledge-Proofs in der Chain postet.
+- Ein _Smart Contract_, der die Hashes speichert und die Zero-Knowledge-Proofs verifiziert, um sicherzustellen, dass die Zustandsübergänge legitim sind.
+
+### Daten- und Kontrollfluss {#flows}
+
+Dies sind die Wege, auf denen die verschiedenen Komponenten kommunizieren, um von einem Konto auf ein anderes zu überweisen.
+
+1. Ein Webbrowser übermittelt eine signierte Transaktion, die eine Überweisung vom Konto des Unterzeichners auf ein anderes Konto anfordert.
+
+2. Der Server überprüft, ob die Transaktion gültig ist:
+
+ - Der Unterzeichner hat ein Konto bei der Bank mit ausreichendem Guthaben.
+ - Der Empfänger hat ein Konto bei der Bank.
+
+3. Der Server berechnet den neuen Zustand, indem er den überwiesenen Betrag vom Guthaben des Unterzeichners abzieht und zum Guthaben des Empfängers addiert.
+
+4. Der Server berechnet einen Zero-Knowledge-Proof, dass die Zustandsänderung gültig ist.
+
+5. Der Server übermittelt eine Transaktion an Ethereum, die Folgendes enthält:
+
+ - Der neue Zustands-Hash
+ - Der Transaktions-Hash (damit der Absender der Transaktion weiß, dass sie verarbeitet wurde)
+ - Der Zero-Knowledge-Proof, der beweist, dass der Übergang zum neuen Zustand gültig ist
+
+6. Der Smart Contract verifiziert den Zero-Knowledge-Proof.
+
+7. Wenn der Zero-Knowledge-Proof erfolgreich ist, führt der Smart Contract die folgenden Aktionen aus:
+ - Aktualisieren des aktuellen Zustands-Hashes auf den neuen Zustands-Hash
+ - Ausgabe eines Log-Eintrags mit dem neuen Zustands-Hash und dem Transaktions-Hash
+
+### Werkzeuge {#tools}
+
+Für den clientseitigen Code werden wir [Vite](https://vite.dev/), [React](https://react.dev/), [Viem](https://viem.sh/) und [Wagmi](https://wagmi.sh/) verwenden. Dies sind branchenübliche Werkzeuge; wenn Sie mit ihnen nicht vertraut sind, können Sie [dieses Tutorial](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/) verwenden.
+
+Der Großteil des Servers ist in JavaScript mit [Node](https://nodejs.org/en) geschrieben. Der Zero-Knowledge-Teil ist in [Noir](https://noir-lang.org/) geschrieben. Wir benötigen die Version `1.0.0-beta.10`, also führen Sie nach der [Installation von Noir gemäß den Anweisungen](https://noir-lang.org/docs/getting_started/quick_start) Folgendes aus:
+
+```
+noirup -v 1.0.0-beta.10
+```
+
+Die Blockchain, die wir verwenden, ist `anvil`, eine lokale Test-Blockchain, die Teil von [Foundry](https://getfoundry.sh/introduction/installation) ist.
+
+## Implementierung {#implementation}
+
+Da es sich um ein komplexes System handelt, werden wir es in Etappen implementieren.
+
+### Stufe 1 – Manuelles Zero-Knowledge {#stage-1}
+
+Für die erste Stufe signieren wir eine Transaktion im Browser und geben dann die Informationen manuell an den Zero-Knowledge-Proof weiter. Der Zero-Knowledge-Code erwartet diese Informationen in `server/noir/Prover.toml` (dokumentiert [hier](https://noir-lang.org/docs/getting_started/project_breakdown#provertoml-1)).
+
+So sehen Sie es in Aktion:
+
+1. Stellen Sie sicher, dass Sie [Node](https://nodejs.org/en/download) und [Noir](https://noir-lang.org/install) installiert haben. Installieren Sie sie vorzugsweise auf einem UNIX-System wie macOS, Linux oder [WSL](https://learn.microsoft.com/de-de/windows/wsl/install).
+
+2. Laden Sie den Code für Stufe 1 herunter und starten Sie den Webserver, um den Client-Code bereitzustellen.
+
+ ```sh
+ git clone https://github.com/qbzzt/250911-zk-bank.git -b 01-manual-zk
+ cd 250911-zk-bank
+ cd client
+ npm install
+ npm run dev
+ ```
+
+ Der Grund, warum Sie hier einen Webserver benötigen, ist, dass viele Wallets (wie MetaMask) zur Verhinderung bestimmter Betrugsarten keine Dateien akzeptieren, die direkt von der Festplatte bereitgestellt werden.
+
+3. Öffnen Sie einen Browser mit einer Wallet.
+
+4. Geben Sie in der Wallet eine neue Passphrase ein. Beachten Sie, dass dies Ihre bestehende Passphrase löscht, also _stellen Sie sicher, dass Sie ein Backup haben_.
+
+ Die Passphrase lautet `test test test test test test test test test test test junk`, die Standard-Test-Passphrase für Anvil.
+
+5. Navigieren Sie zum [clientseitigen Code](http://localhost:5173/).
+
+6. Verbinden Sie sich mit der Wallet und wählen Sie Ihr Zielkonto und den Betrag aus.
+
+7. Klicken Sie auf **Sign** und signieren Sie die Transaktion.
+
+8. Unter der Überschrift **Prover.toml** finden Sie einen Text. Ersetzen Sie `server/noir/Prover.toml` durch diesen Text.
+
+9. Führen Sie den Zero-Knowledge-Proof aus.
+
+ ```sh
+ cd ../server/noir
+ nargo execute
+ ```
+
+ Die Ausgabe sollte ähnlich sein wie
+
+ ```
+ ori@CryptoDocGuy:~/noir/250911-zk-bank/server/noir$ nargo execute
+
+ [zkBank] Circuit witness successfully solved
+ [zkBank] Witness saved to target/zkBank.gz
+ [zkBank] Circuit output: (0x199aa62af8c1d562a6ec96e66347bf3240ab2afb5d022c895e6bf6a5e617167b, 0x0cfc0a67cb7308e4e9b254026b54204e34f6c8b041be207e64c5db77d95dd82d, 0x450cf9da6e180d6159290554ae3d8787, 0x6d8bc5a15b9037e52fb59b6b98722a85)
+ ```
+
+10. Vergleichen Sie die letzten beiden Werte mit dem Hash, den Sie im Webbrowser sehen, um zu prüfen, ob die Nachricht korrekt gehasht wurde.
+
+#### `server/noir/Prover.toml` {#server-noir-prover-toml}
+
+[Diese Datei](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/Prover.toml) zeigt das von Noir erwartete Informationsformat.
+
+```toml
+message="send 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 500 finney (milliEth) 0 "
+```
+
+Die Nachricht ist im Textformat, was es für den Benutzer leicht verständlich macht (was beim Signieren notwendig ist) und für den Noir-Code leicht zu parsen ist. Der Betrag wird in Finneys angegeben, um einerseits Teilüberweisungen zu ermöglichen und andererseits leicht lesbar zu sein. Die letzte Zahl ist die [Nonce](https://de.wikipedia.org/wiki/Nonce).
+
+Die Zeichenkette ist 100 Zeichen lang. Zero-Knowledge-Proofs können nicht gut mit Daten variabler Größe umgehen, daher ist es oft notwendig, Daten aufzufüllen.
+
+```toml
+pubKeyX=["0x83",...,"0x75"]
+pubKeyY=["0x35",...,"0xa5"]
+signature=["0xb1",...,"0x0d"]
+```
+
+Diese drei Parameter sind Byte-Arrays fester Größe.
+
+```toml
+[[accounts]]
+address="0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
+balance=100_000
+nonce=0
+
+[[accounts]]
+address="0x70997970C51812dc3A010C7d01b50e0d17dc79C8"
+balance=100_000
+nonce=0
+```
+
+Dies ist die Art, ein Array von Strukturen zu spezifizieren. Für jeden Eintrag geben wir die Adresse, das Guthaben (in milliETH, auch bekannt als [Finney](https://cryptovalleyjournal.com/glossary/finney/)) und den nächsten Nonce-Wert an.
+
+#### `client/src/Transfer.tsx` {#client-src-transfer-tsx}
+
+[Diese Datei](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/client/src/Transfer.tsx) implementiert die clientseitige Verarbeitung und generiert die `server/noir/Prover.toml`-Datei (diejenige, die die Zero-Knowledge-Parameter enthält).
+
+Hier ist die Erklärung der interessanteren Teile.
+
+```tsx
+export default attrs => {
+```
+
+Diese Funktion erstellt die `Transfer`-React-Komponente, die andere Dateien importieren können.
+
+```tsx
+ const accounts = [
+ "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+ "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
+ "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
+ "0x90F79bf6EB2c4f870365E785982E1f101E93b906",
+ "0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65",
+ ]
+```
+
+Dies sind die Kontoadressen, die durch die Passphrase `test ...` erstellt werden. test junk\` Passphrase. Wenn Sie Ihre eigenen Adressen verwenden möchten, ändern Sie einfach diese Definition.
+
+```tsx
+ const account = useAccount()
+ const wallet = createWalletClient({
+ transport: custom(window.ethereum!)
+ })
+```
+
+Diese [Wagmi-Hooks](https://wagmi.sh/react/api/hooks) ermöglichen uns den Zugriff auf die [viem](https://viem.sh/)-Bibliothek und die Wallet.
+
+```tsx
+ const message = `send ${toAccount} ${ethAmount*1000} finney (milliEth) ${nonce}`.padEnd(100, " ")
+```
+
+Dies ist die mit Leerzeichen aufgefüllte Nachricht. Jedes Mal, wenn sich eine der `useState`-Variablen (https://react.dev/reference/react/useState) ändert, wird die Komponente neu gezeichnet und die `message` wird aktualisiert.
+
+```tsx
+ const sign = async () => {
+```
+
+Diese Funktion wird aufgerufen, wenn der Benutzer auf die Schaltfläche **Sign** klickt. Die Nachricht wird automatisch aktualisiert, aber die Signatur erfordert die Genehmigung des Benutzers in der Wallet, und wir möchten nicht danach fragen, es sei denn, es ist notwendig.
+
+```tsx
+ const signature = await wallet.signMessage({
+ account: fromAccount,
+ message,
+ })
+```
+
+Bitten Sie die Wallet, [die Nachricht zu signieren](https://viem.sh/docs/accounts/local/signMessage).
+
+```tsx
+ const hash = hashMessage(message)
+```
+
+Holen Sie sich den Nachrichten-Hash. Es ist hilfreich, ihn dem Benutzer für das Debugging (des Noir-Codes) zur Verfügung zu stellen.
+
+```tsx
+ const pubKey = await recoverPublicKey({
+ hash,
+ signature
+ })
+```
+
+[Holen Sie sich den öffentlichen Schlüssel](https://viem.sh/docs/utilities/recoverPublicKey). Dies ist für die [Noir `ecrecover`](https://github.com/colinnielsen/ecrecover-noir)-Funktion erforderlich.
+
+```tsx
+ setSignature(signature)
+ setHash(hash)
+ setPubKey(pubKey)
+```
+
+Setzen Sie die Zustandvariablen. Dadurch wird die Komponente neu gezeichnet (nachdem die `sign`-Funktion beendet ist) und dem Benutzer die aktualisierten Werte angezeigt.
+
+```tsx
+ let proverToml = `
+```
+
+Der Text für `Prover.toml`.
+
+```tsx
+message="${message}"
+
+pubKeyX=${hexToArray(pubKey.slice(4,4+2*32))}
+pubKeyY=${hexToArray(pubKey.slice(4+2*32))}
+```
+
+Viem stellt uns den öffentlichen Schlüssel als 65-Byte-Hexadezimalzeichenkette zur Verfügung. Das erste Byte ist `0x04`, ein Versionsmarker. Darauf folgen 32 Bytes für das `x` des öffentlichen Schlüssels und dann 32 Bytes für das `y` des öffentlichen Schlüssels.
+
+Noir erwartet jedoch, diese Informationen als zwei Byte-Arrays zu erhalten, eines für `x` und eines für `y`. Es ist einfacher, dies hier auf dem Client zu parsen als als Teil des Zero-Knowledge-Proofs.
+
+Beachten Sie, dass dies im Allgemeinen eine gute Praxis bei Zero-Knowledge ist. Code innerhalb eines Zero-Knowledge-Proofs ist teuer, daher sollte jede Verarbeitung, die außerhalb des Zero-Knowledge-Proofs durchgeführt werden kann, auch außerhalb des Zero-Knowledge-Proofs durchgeführt werden.
+
+```tsx
+signature=${hexToArray(signature.slice(2,-2))}
+```
+
+Die Signatur wird ebenfalls als eine 65-Byte lange Hexadezimal-Zeichenkette bereitgestellt. Das letzte Byte ist jedoch nur notwendig, um den öffentlichen Schlüssel wiederherzustellen. Da der öffentliche Schlüssel bereits dem Noir-Code zur Verfügung gestellt wird, benötigen wir ihn nicht zur Überprüfung der Signatur, und der Noir-Code erfordert ihn nicht.
+
+```tsx
+${accounts.map(accountInProverToml).reduce((a,b) => a+b, "")}
+`
+```
+
+Stellen Sie die Konten bereit.
+
+```tsx
+ setProverToml(proverToml)
+ }
+
+ return (
+ <>
+ Transfer
+```
+
+Dies ist das HTML (genauer gesagt, [JSX](https://react.dev/learn/writing-markup-with-jsx)) Format der Komponente.
+
+#### `server/noir/src/main.nr` {#server-noir-src-main-nr}
+
+[Diese Datei](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/src/main.nr) ist der eigentliche Zero-Knowledge-Code.
+
+```
+use std::hash::pedersen_hash;
+```
+
+[Pedersen-Hash](https://rya-sge.github.io/access-denied/2024/05/07/pedersen-hash-function/) wird mit der [Noir-Standardbibliothek](https://noir-lang.org/docs/noir/standard_library/cryptographic_primitives/hashes#pedersen_hash) bereitgestellt. Zero-Knowledge-Proofs verwenden häufig diese Hash-Funktion. Es ist viel einfacher, sie in [arithmetischen Schaltungen](https://rareskills.io/post/arithmetic-circuit) im Vergleich zu den Standard-Hash-Funktionen zu berechnen.
+
+```
+use keccak256::keccak256;
+use dep::ecrecover;
+```
+
+Diese beiden Funktionen sind externe Bibliotheken, die in [`Nargo.toml`](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/Nargo.toml) definiert sind. Sie sind genau das, wofür sie benannt sind: eine Funktion, die den [Keccak256-Hash](https://emn178.github.io/online-tools/keccak_256.html) berechnet, und eine Funktion, die Ethereum-Signaturen verifiziert und die Ethereum-Adresse des Unterzeichners wiederherstellt.
+
+```
+global ACCOUNT_NUMBER : u32 = 5;
+```
+
+Noir ist von [Rust](https://www.rust-lang.org/) inspiriert. Variablen sind standardmäßig Konstanten. Auf diese Weise definieren wir globale Konfigurationskonstanten. Insbesondere ist `ACCOUNT_NUMBER` die Anzahl der Konten, die wir speichern.
+
+Datentypen mit dem Namen `u` sind diese Anzahl von Bits, ohne Vorzeichen. Die einzigen unterstützten Typen sind `u8`, `u16`, `u32`, `u64` und `u128`.
+
+```
+global FLAT_ACCOUNT_FIELDS : u32 = 2;
+```
+
+Diese Variable wird für den Pedersen-Hash der Konten verwendet, wie unten erklärt.
+
+```
+global MESSAGE_LENGTH : u32 = 100;
+```
+
+Wie oben erklärt, ist die Nachrichtenlänge fest. Sie wird hier angegeben.
+
+```
+global ASCII_MESSAGE_LENGTH : [u8; 3] = [0x31, 0x30, 0x30];
+global HASH_BUFFER_SIZE : u32 = 26+3+MESSAGE_LENGTH;
+```
+
+[EIP-191-Signaturen](https://eips.ethereum.org/EIPS/eip-191) erfordern einen Puffer mit einem 26-Byte-Präfix, gefolgt von der Nachrichtenlänge in ASCII und schließlich der Nachricht selbst.
+
+```
+struct Account {
+ balance: u128,
+ address: Field,
+ nonce: u32,
+}
+```
+
+Die Informationen, die wir über ein Konto speichern. [`Field`](https://noir-lang.org/docs/noir/concepts/data_types/fields) ist eine Zahl, typischerweise bis zu 253 Bits, die direkt in der [arithmetischen Schaltung](https://rareskills.io/post/arithmetic-circuit) verwendet werden kann, die den Zero-Knowledge-Proof implementiert. Hier verwenden wir das `Field`, um eine 160-Bit-Ethereum-Adresse zu speichern.
+
+```
+struct TransferTxn {
+ from: Field,
+ to: Field,
+ amount: u128,
+ nonce: u32
+}
+```
+
+Die Informationen, die wir für eine Überweisungstransaktion speichern.
+
+```
+fn flatten_account(account: Account) -> [Field; FLAT_ACCOUNT_FIELDS] {
+```
+
+Eine Funktionsdefinition. Der Parameter ist eine `Account`-Information. Das Ergebnis ist ein Array von `Field`-Variablen, dessen Länge `FLAT_ACCOUNT_FIELDS` ist.
+
+```
+ let flat = [
+ account.address,
+ ((account.balance << 32) + account.nonce.into()).into(),
+ ];
+```
+
+Der erste Wert im Array ist die Kontoadresse. Der zweite Wert enthält sowohl das Guthaben als auch die Nonce. Die `.into()`-Aufrufe ändern eine Zahl in den Datentyp, den sie haben muss. `account.nonce` ist ein `u32`-Wert, aber um ihn zu `account.balance << 32`, einem `u128`-Wert, hinzuzufügen, muss er ein `u128` sein. Das ist das erste `.into()`. Der zweite wandelt das `u128`-Ergebnis in ein `Field` um, damit es in das Array passt.
+
+```
+ flat
+}
+```
+
+In Noir können Funktionen nur am Ende einen Wert zurückgeben (es gibt keine vorzeitige Rückgabe). Um den Rückgabewert anzugeben, werten Sie ihn kurz vor der schließenden Klammer der Funktion aus.
+
+```
+fn flatten_accounts(accounts: [Account; ACCOUNT_NUMBER]) -> [Field; FLAT_ACCOUNT_FIELDS*ACCOUNT_NUMBER] {
+```
+
+Diese Funktion wandelt das Konten-Array in ein `Field`-Array um, das als Eingabe für einen Pedersen-Hash verwendet werden kann.
+
+```
+ let mut flat: [Field; FLAT_ACCOUNT_FIELDS*ACCOUNT_NUMBER] = [0; FLAT_ACCOUNT_FIELDS*ACCOUNT_NUMBER];
+```
+
+So geben Sie eine veränderliche Variable an, d. h. _keine_ Konstante. Variablen in Noir müssen immer einen Wert haben, also initialisieren wir diese Variable mit Nullen.
+
+```
+ for i in 0..ACCOUNT_NUMBER {
+```
+
+Dies ist eine `for`-Schleife. Beachten Sie, dass die Grenzen Konstanten sind. Noir-Schleifen müssen ihre Grenzen zur Kompilierzeit kennen. Der Grund dafür ist, dass arithmetische Schaltungen keine Flusskontrolle unterstützen. Bei der Verarbeitung einer `for`-Schleife fügt der Compiler den Code einfach mehrmals ein, einmal für jede Iteration.
+
+```
+ let fields = flatten_account(accounts[i]);
+ for j in 0..FLAT_ACCOUNT_FIELDS {
+ flat[i*FLAT_ACCOUNT_FIELDS + j] = fields[j];
+ }
+ }
+
+ flat
+}
+
+fn hash_accounts(accounts: [Account; ACCOUNT_NUMBER]) -> Field {
+ pedersen_hash(flatten_accounts(accounts))
+}
+```
+
+Schließlich sind wir bei der Funktion angelangt, die das Konten-Array hasht.
+
+```
+fn find_account(accounts: [Account; ACCOUNT_NUMBER], address: Field) -> u32 {
+ let mut account : u32 = ACCOUNT_NUMBER;
+
+ for i in 0..ACCOUNT_NUMBER {
+ if accounts[i].address == address {
+ account = i;
+ }
+ }
+```
+
+Diese Funktion findet das Konto mit einer bestimmten Adresse. Diese Funktion wäre in Standardcode furchtbar ineffizient, da sie über alle Konten iteriert, auch nachdem sie die Adresse gefunden hat.
+
+Bei Zero-Knowledge-Proofs gibt es jedoch keine Flusskontrolle. Wenn wir jemals eine Bedingung prüfen müssen, müssen wir sie jedes Mal prüfen.
+
+Etwas Ähnliches geschieht mit `if`-Anweisungen. Die `if`-Anweisung in der obigen Schleife wird in diese mathematischen Aussagen übersetzt.
+
+_bedingungergebnis = accounts[i].address == address_ // eins, wenn sie gleich sind, sonst null
+
+_kontoneu = bedingungergebnis\*i + (1-bedingungergebnis)\*kontoalt_
+
+```rust
+ assert (account < ACCOUNT_NUMBER, f"{address} hat kein Konto");
+
+ account
+}
+```
+
+Die [`assert`](https://noir-lang.org/docs/dev/noir/concepts/assert)-Funktion führt zum Absturz des Zero-Knowledge-Proofs, wenn die Behauptung falsch ist. In diesem Fall, wenn wir kein Konto mit der relevanten Adresse finden können. Um die Adresse zu melden, verwenden wir einen [Format-String](https://noir-lang.org/docs/noir/concepts/data_types/strings#format-strings).
+
+```rust
+fn apply_transfer_txn(accounts: [Account; ACCOUNT_NUMBER], txn: TransferTxn) -> [Account; ACCOUNT_NUMBER] {
+```
+
+Diese Funktion wendet eine Überweisungstransaktion an und gibt das neue Kontenarray zurück.
+
+```rust
+ let from = find_account(accounts, txn.from);
+ let to = find_account(accounts, txn.to);
+
+ let (txnFrom, txnAmount, txnNonce, accountNonce) =
+ (txn.from, txn.amount, txn.nonce, accounts[from].nonce);
+```
+
+Wir können in Noir nicht auf Strukturelemente innerhalb eines Format-Strings zugreifen, also erstellen wir eine nutzbare Kopie.
+
+```rust
+ assert (accounts[from].balance >= txn.amount,
+ f"{txnFrom} hat keine {txnAmount} Finney");
+
+ assert (accounts[from].nonce == txn.nonce,
+ f"Transaktion hat Nonce {txnNonce}, aber das Konto wird voraussichtlich {accountNonce} verwenden");
+```
+
+Dies sind zwei Bedingungen, die eine Transaktion ungültig machen könnten.
+
+```rust
+ let mut newAccounts = accounts;
+
+ newAccounts[from].balance -= txn.amount;
+ newAccounts[from].nonce += 1;
+ newAccounts[to].balance += txn.amount;
+
+ newAccounts
+}
+```
+
+Erstellen Sie das neue Konten-Array und geben Sie es dann zurück.
+
+```rust
+fn readAddress(messageBytes: [u8; MESSAGE_LENGTH]) -> Field
+```
+
+Diese Funktion liest die Adresse aus der Nachricht.
+
+```rust
+{
+ let mut result : Field = 0;
+
+ for i in 7..47 {
+```
+
+Die Adresse ist immer 20 Byte (auch bekannt als 40 Hexadezimalziffern) lang und beginnt bei Zeichen #7.
+
+```rust
+ result *= 0x10;
+ if messageBytes[i] >= 48 & messageBytes[i] <= 57 { // 0-9
+ result += (messageBytes[i]-48).into();
+ }
+ if messageBytes[i] >= 65 & messageBytes[i] <= 70 { // A-F
+ result += (messageBytes[i]-65+10).into()
+ }
+ if messageBytes[i] >= 97 & messageBytes[i] <= 102 { // a-f
+ result += (messageBytes[i]-97+10).into()
+ }
+ }
+
+ result
+}
+
+fn readAmountAndNonce(messageBytes: [u8; MESSAGE_LENGTH]) -> (u128, u32)
+```
+
+Lesen Sie den Betrag und die Nonce aus der Nachricht.
+
+```rust
+{
+ let mut amount : u128 = 0;
+ let mut nonce: u32 = 0;
+ let mut stillReadingAmount: bool = true;
+ let mut lookingForNonce: bool = false;
+ let mut stillReadingNonce: bool = false;
+```
+
+In der Nachricht ist die erste Zahl nach der Adresse der Betrag in Finney (auch bekannt als Tausendstel eines ETH), der überwiesen werden soll. Die zweite Zahl ist die Nonce. Jeder Text dazwischen wird ignoriert.
+
+```rust
+ for i in 48..MESSAGE_LENGTH {
+ if messageBytes[i] >= 48 & messageBytes[i] <= 57 { // 0-9
+ let digit = (messageBytes[i]-48);
+
+ if stillReadingAmount {
+ amount = amount*10 + digit.into();
+ }
+
+ if lookingForNonce { // We just found it
+ stillReadingNonce = true;
+ lookingForNonce = false;
+ }
+
+ if stillReadingNonce {
+ nonce = nonce*10 + digit.into();
+ }
+ } else {
+ if stillReadingAmount {
+ stillReadingAmount = false;
+ lookingForNonce = true;
+ }
+ if stillReadingNonce {
+ stillReadingNonce = false;
+ }
+ }
+ }
+
+ (amount, nonce)
+}
+```
+
+Die Rückgabe eines [Tupels](https://noir-lang.org/docs/noir/concepts/data_types/tuples) ist die Noir-Methode, um mehrere Werte aus einer Funktion zurückzugeben.
+
+```rust
+fn readTransferTxn(message: str) -> TransferTxn
+{
+ let mut txn: TransferTxn = TransferTxn { from: 0, to: 0, amount:0, nonce:0 };
+ let messageBytes = message.as_bytes();
+
+ txn.to = readAddress(messageBytes);
+ let (amount, nonce) = readAmountAndNonce(messageBytes);
+ txn.amount = amount;
+ txn.nonce = nonce;
+
+ txn
+}
+```
+
+Diese Funktion konvertiert die Nachricht in Bytes und dann die Beträge in eine `TransferTxn`.
+
+```rust
+// Das Äquivalent zu Viems hashMessage
+// https://viem.sh/docs/utilities/hashMessage#hashmessage
+fn hashMessage(message: str) -> [u8;32] {
+```
+
+Wir konnten den Pedersen-Hash für die Konten verwenden, da sie nur innerhalb des Zero-Knowledge-Proofs gehasht werden. In diesem Code müssen wir jedoch die Signatur der Nachricht überprüfen, die vom Browser generiert wird. Dafür müssen wir dem Ethereum-Signaturformat in [EIP 191](https://eips.ethereum.org/EIPS/eip-191) folgen. Das bedeutet, wir müssen einen kombinierten Puffer mit einem Standardpräfix, der Nachrichtenlänge in ASCII und der Nachricht selbst erstellen und den Ethereum-Standard Keccak256 verwenden, um ihn zu hashen.
+
+```rust
+ // ASCII-Präfix
+ let prefix_bytes = [
+ 0x19, // \x19
+ 0x45, // 'E'
+ 0x74, // 't'
+ 0x68, // 'h'
+ 0x65, // 'e'
+ 0x72, // 'r'
+ 0x65, // 'e'
+ 0x75, // 'u'
+ 0x6D, // 'm'
+ 0x20, // ' '
+ 0x53, // 'S'
+ 0x69, // 'i'
+ 0x67, // 'g'
+ 0x6E, // 'n'
+ 0x65, // 'e'
+ 0x64, // 'd'
+ 0x20, // ' '
+ 0x4D, // 'M'
+ 0x65, // 'e'
+ 0x73, // 's'
+ 0x73, // 's'
+ 0x61, // 'a'
+ 0x67, // 'g'
+ 0x65, // 'e'
+ 0x3A, // ':'
+ 0x0A // '\n'
+ ];
+```
+
+Um Fälle zu vermeiden, in denen eine Anwendung den Benutzer bittet, eine Nachricht zu signieren, die als Transaktion oder für einen anderen Zweck verwendet werden kann, gibt EIP 191 an, dass alle signierten Nachrichten mit dem Zeichen 0x19 (kein gültiges ASCII-Zeichen) beginnen, gefolgt von `Ethereum Signed Message:` und einem Zeilenumbruch.
+
+```rust
+ let mut buffer: [u8; HASH_BUFFER_SIZE] = [0u8; HASH_BUFFER_SIZE];
+ for i in 0..26 {
+ buffer[i] = prefix_bytes[i];
+ }
+
+ let messageBytes : [u8; MESSAGE_LENGTH] = message.as_bytes();
+
+ if MESSAGE_LENGTH <= 9 {
+ for i in 0..1 {
+ buffer[i+26] = ASCII_MESSAGE_LENGTH[i];
+ }
+
+ for i in 0..MESSAGE_LENGTH {
+ buffer[i+26+1] = messageBytes[i];
+ }
+ }
+
+ if MESSAGE_LENGTH >= 10 & MESSAGE_LENGTH <= 99 {
+ for i in 0..2 {
+ buffer[i+26] = ASCII_MESSAGE_LENGTH[i];
+ }
+
+ for i in 0..MESSAGE_LENGTH {
+ buffer[i+26+2] = messageBytes[i];
+ }
+ }
+
+ if MESSAGE_LENGTH >= 100 {
+ for i in 0..3 {
+ buffer[i+26] = ASCII_MESSAGE_LENGTH[i];
+ }
+
+ for i in 0..MESSAGE_LENGTH {
+ buffer[i+26+3] = messageBytes[i];
+ }
+ }
+
+ assert(MESSAGE_LENGTH < 1000, "Nachrichten, deren Länge drei Ziffern überschreitet, werden nicht unterstützt");
+```
+
+Handhaben Sie Nachrichtenlängen bis zu 999 und brechen Sie ab, wenn sie größer ist. Ich habe diesen Code hinzugefügt, obwohl die Nachrichtenlänge eine Konstante ist, weil es die Änderung erleichtert. Auf einem Produktionssystem würden Sie wahrscheinlich einfach davon ausgehen, dass `MESSAGE_LENGTH` sich aus Leistungsgründen nicht ändert.
+
+```rust
+ keccak256::keccak256(buffer, HASH_BUFFER_SIZE)
+}
+```
+
+Verwenden Sie die Ethereum-Standardfunktion `keccak256`.
+
+```rust
+fn signatureToAddressAndHash(
+ message: str,
+ pubKeyX: [u8; 32],
+ pubKeyY: [u8; 32],
+ signature: [u8; 64]
+ ) -> (Field, Field, Field) // Adresse, erste 16 Bytes des Hash, letzte 16 Bytes des Hash
+{
+```
+
+Diese Funktion verifiziert die Signatur, was den Nachrichten-Hash erfordert. Es liefert uns dann die Adresse, die sie signiert hat, und den Nachrichten-Hash. Der Nachrichten-Hash wird in zwei `Field`-Werten geliefert, da diese im Rest des Programms einfacher zu verwenden sind als ein Byte-Array.
+
+Wir müssen zwei `Field`-Werte verwenden, da Feldberechnungen [modulo](https://de.wikipedia.org/wiki/Modular_arithmetic) einer großen Zahl durchgeführt werden, aber diese Zahl ist typischerweise kleiner als 256 Bits (andernfalls wäre es schwierig, diese Berechnungen in der EVM durchzuführen).
+
+```rust
+ let hash = hashMessage(message);
+
+ let mut (hash1, hash2) = (0,0);
+
+ for i in 0..16 {
+ hash1 = hash1*256 + hash[31-i].into();
+ hash2 = hash2*256 + hash[15-i].into();
+ }
+```
+
+Spezifizieren Sie `hash1` und `hash2` als veränderliche Variablen und schreiben Sie den Hash Byte für Byte hinein.
+
+```rust
+ (
+ ecrecover::ecrecover(pubKeyX, pubKeyY, signature, hash),
+```
+
+Dies ist ähnlich wie [Soliditiys `ecrecover`](https://docs.soliditylang.org/en/v0.8.30/cheatsheet.html#mathematical-and-cryptographic-functions), mit zwei wichtigen Unterschieden:
+
+- Wenn die Signatur nicht gültig ist, schlägt der Aufruf ein `assert` fehl und das Programm wird abgebrochen.
+- Obwohl der öffentliche Schlüssel aus der Signatur und dem Hash wiederhergestellt werden kann, handelt es sich um eine Verarbeitung, die extern erfolgen kann und daher nicht innerhalb des Zero-Knowledge-Proofs durchgeführt werden sollte. Wenn jemand versucht, uns hier zu betrügen, wird die Signaturüberprüfung fehlschlagen.
+
+```rust
+ hash1,
+ hash2
+ )
+}
+
+fn main(
+ accounts: [Account; ACCOUNT_NUMBER],
+ message: str,
+ pubKeyX: [u8; 32],
+ pubKeyY: [u8; 32],
+ signature: [u8; 64],
+ ) -> pub (
+ Field, // Hash des alten Konten-Arrays
+ Field, // Hash des neuen Konten-Arrays
+ Field, // Erste 16 Bytes des Nachrichten-Hashs
+ Field, // Letzte 16 Bytes des Nachrichten-Hashs
+ )
+```
+
+Schließlich erreichen wir die `main`-Funktion. Wir müssen beweisen, dass wir eine Transaktion haben, die den Hash der Konten gültig vom alten Wert auf den neuen ändert. Wir müssen auch beweisen, dass sie diesen spezifischen Transaktions-Hash hat, damit die Person, die sie gesendet hat, weiß, dass ihre Transaktion verarbeitet wurde.
+
+```rust
+{
+ let mut txn = readTransferTxn(message);
+```
+
+Wir brauchen `txn`, um veränderbar zu sein, weil wir die Von-Adresse nicht aus der Nachricht, sondern aus der Signatur lesen.
+
+```rust
+ let (fromAddress, txnHash1, txnHash2) = signatureToAddressAndHash(
+ message,
+ pubKeyX,
+ pubKeyY,
+ signature);
+
+ txn.from = fromAddress;
+
+ let newAccounts = apply_transfer_txn(accounts, txn);
+
+ (
+ hash_accounts(accounts),
+ hash_accounts(newAccounts),
+ txnHash1,
+ txnHash2
+ )
+}
+```
+
+### Stufe 2 – Hinzufügen eines Servers {#stage-2}
+
+In der zweiten Stufe fügen wir einen Server hinzu, der Überweisungstransaktionen vom Browser empfängt und implementiert.
+
+So sehen Sie es in Aktion:
+
+1. Stoppen Sie Vite, wenn es läuft.
+
+2. Laden Sie den Branch mit dem Server herunter und stellen Sie sicher, dass Sie alle erforderlichen Module haben.
+
+ ```sh
+ git checkout 02-add-server
+ cd client
+ npm install
+ cd ../server
+ npm install
+ ```
+
+ Es ist nicht notwendig, den Noir-Code zu kompilieren, es ist derselbe Code, den Sie für Stufe 1 verwendet haben.
+
+3. Starten Sie den Server.
+
+ ```sh
+ npm run start
+ ```
+
+4. Führen Sie Vite in einem separaten Kommandozeilenfenster aus, um den Browser-Code bereitzustellen.
+
+ ```sh
+ cd client
+ npm run dev
+ ```
+
+5. Navigieren Sie zum Client-Code unter [http://localhost:5173](http://localhost:5173)
+
+6. Bevor Sie eine Transaktion ausgeben können, müssen Sie die Nonce sowie den Betrag kennen, den Sie senden können. Um diese Informationen zu erhalten, klicken Sie auf **Kontodaten aktualisieren** und signieren Sie die Nachricht.
+
+ Wir haben hier ein Dilemma. Einerseits wollen wir keine Nachricht signieren, die wiederverwendet werden kann (ein [Replay-Angriff](https://de.wikipedia.org/wiki/Replay-Angriff)), weshalb wir überhaupt eine Nonce wollen. Allerdings haben wir noch keine Nonce. Die Lösung besteht darin, eine Nonce zu wählen, die nur einmal verwendet werden kann und die wir bereits auf beiden Seiten haben, wie z. B. die aktuelle Zeit.
+
+ Das Problem bei dieser Lösung ist, dass die Zeit möglicherweise nicht perfekt synchronisiert ist. Stattdessen signieren wir einen Wert, der sich jede Minute ändert. Dies bedeutet, dass unser Verwundbarkeitsfenster für Replay-Angriffe höchstens eine Minute beträgt. In Anbetracht der Tatsache, dass die signierte Anfrage in der Produktion durch TLS geschützt wird und dass die andere Seite des Tunnels – der Server – das Guthaben und die Nonce bereits offenlegen kann (er muss sie kennen, um zu funktionieren), ist dies ein akzeptables Risiko.
+
+7. Sobald der Browser das Guthaben und die Nonce zurückerhält, zeigt er das Überweisungsformular an. Wählen Sie die Zieladresse und den Betrag aus und klicken Sie auf **Überweisen**. Signieren Sie diese Anfrage.
+
+8. Um die Überweisung zu sehen, **aktualisieren Sie die Kontodaten** oder schauen Sie in das Fenster, in dem Sie den Server ausführen. Der Server protokolliert den Zustand bei jeder Änderung.
+
+ ```
+ ori@CryptoDocGuy:~/x/250911-zk-bank/server$ npm run start
+
+ > server@1.0.0 start
+ > node --experimental-json-modules index.mjs
+
+ Listening on port 3000
+ Txn send 0x90F79bf6EB2c4f870365E785982E1f101E93b906 36000 finney (milliEth) 0 processed
+ New state:
+ 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 has 64000 (1)
+ 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 has 100000 (0)
+ 0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC has 100000 (0)
+ 0x90F79bf6EB2c4f870365E785982E1f101E93b906 has 136000 (0)
+ 0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65 has 100000 (0)
+ Txn send 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 7200 finney (milliEth) 1 processed
+ New state:
+ 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 has 56800 (2)
+ 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 has 107200 (0)
+ 0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC has 100000 (0)
+ 0x90F79bf6EB2c4f870365E785982E1f101E93b906 has 136000 (0)
+ 0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65 has 100000 (0)
+ Txn send 0x90F79bf6EB2c4f870365E785982E1f101E93b906 3000 finney (milliEth) 2 processed
+ New state:
+ 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 has 53800 (3)
+ 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 has 107200 (0)
+ 0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC has 100000 (0)
+ 0x90F79bf6EB2c4f870365E785982E1f101E93b906 has 139000 (0)
+ 0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65 has 100000 (0)
+ ```
+
+#### `server/index.mjs` {#server-index-mjs-1}
+
+[Diese Datei](https://github.com/qbzzt/250911-zk-bank/blob/02-add-server/server/index.mjs) enthält den Serverprozess und interagiert mit dem Noir-Code unter [`main.nr`](https://github.com/qbzzt/250911-zk-bank/blob/02-add-server/server/noir/src/main.nr). Hier ist eine Erklärung der interessanten Teile.
+
+```js
+import { Noir } from '@noir-lang/noir_js'
+```
+
+Die [noir.js](https://www.npmjs.com/package/@noir-lang/noir_js)-Bibliothek dient als Schnittstelle zwischen JavaScript-Code und Noir-Code.
+
+```js
+const circuit = JSON.parse(await fs.readFile("./noir/target/zkBank.json"))
+const noir = new Noir(circuit)
+```
+
+Laden Sie die arithmetische Schaltung – das kompilierte Noir-Programm, das wir in der vorherigen Stufe erstellt haben – und bereiten Sie sich auf ihre Ausführung vor.
+
+```js
+// Wir stellen Kontoinformationen nur als Antwort auf eine signierte Anfrage zur Verfügung
+const accountInformation = async signature => {
+ const fromAddress = await recoverAddress({
+ hash: hashMessage("Get account data " + Math.floor((new Date().getTime())/60000)),
+ signature
+ })
+```
+
+Um Kontoinformationen bereitzustellen, benötigen wir nur die Signatur. Der Grund dafür ist, dass wir bereits wissen, was die Nachricht sein wird, und daher auch den Nachrichten-Hash.
+
+```js
+const processMessage = async (message, signature) => {
+```
+
+Verarbeiten Sie eine Nachricht und führen Sie die darin kodierte Transaktion aus.
+
+```js
+ // Holen Sie sich den öffentlichen Schlüssel
+ const pubKey = await recoverPublicKey({
+ hash,
+ signature
+ })
+```
+
+Jetzt, da wir JavaScript auf dem Server ausführen, können wir den öffentlichen Schlüssel dort anstatt auf dem Client abrufen.
+
+```js
+ let noirResult
+ try {
+ noirResult = await noir.execute({
+ message,
+ signature: signature.slice(2,-2).match(/.{2}/g).map(x => `0x${x}`),
+ pubKeyX,
+ pubKeyY,
+ accounts: Accounts
+ })
+```
+
+`noir.execute` führt das Noir-Programm aus. Die Parameter entsprechen denen, die in [`Prover.toml`](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/Prover.toml) angegeben sind. Beachten Sie, dass lange Werte als Array von Hexadezimal-Strings (`["0x60", "0xA7"]`) und nicht als einzelner Hexadezimalwert (`0x60A7`) angegeben werden, wie es Viem tut.
+
+```js
+ } catch (err) {
+ console.log(`Noir error: ${err}`)
+ throw Error("Invalid transaction, not processed")
+ }
+```
+
+Wenn ein Fehler auftritt, fangen Sie ihn ab und leiten Sie eine vereinfachte Version an den Client weiter.
+
+```js
+ Accounts[fromAccountNumber].nonce++
+ Accounts[fromAccountNumber].balance -= amount
+ Accounts[toAccountNumber].balance += amount
+```
+
+Führen Sie die Transaktion aus. Wir haben dies bereits im Noir-Code getan, aber es ist einfacher, es hier erneut zu tun, als das Ergebnis von dort zu extrahieren.
+
+```js
+let Accounts = [
+ {
+ address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+ balance: 5000,
+ nonce: 0,
+ },
+```
+
+Die ursprüngliche `Accounts`-Struktur.
+
+### Stufe 3 – Ethereum Smart Contracts {#stage-3}
+
+1. Stoppen Sie die Server- und Client-Prozesse.
+
+2. Laden Sie den Branch mit den Smart Contracts herunter und stellen Sie sicher, dass Sie alle erforderlichen Module haben.
+
+ ```sh
+ git checkout 03-smart-contracts
+ cd client
+ npm install
+ cd ../server
+ npm install
+ ```
+
+3. Führen Sie `anvil` in einem separaten Kommandozeilenfenster aus.
+
+4. Generieren Sie den Verifizierungsschlüssel und den Solidity-Verifizierer und kopieren Sie dann den Verifizierer-Code in das Solidity-Projekt.
+
+ ```sh
+ cd noir
+ bb write_vk -b ./target/zkBank.json -o ./target --oracle_hash keccak
+ bb write_solidity_verifier -k ./target/vk -o ./target/Verifier.sol
+ cp target/Verifier.sol ../../smart-contracts/src
+ ```
+
+5. Gehen Sie zu den Smart Contracts und setzen Sie die Umgebungsvariablen, um die `anvil` Blockchain zu verwenden.
+
+ ```sh
+ cd ../../smart-contracts
+ export ETH_RPC_URL=http://localhost:8545
+ ETH_PRIVATE_KEY=ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
+ ```
+
+6. Stellen Sie `Verifier.sol` bereit und speichern Sie die Adresse in einer Umgebungsvariable.
+
+ ```sh
+ VERIFIER_ADDRESS=`forge create src/Verifier.sol:HonkVerifier --private-key $ETH_PRIVATE_KEY --optimize --broadcast | awk '/Deployed to:/ {print $3}'`
+ echo $VERIFIER_ADDRESS
+ ```
+
+7. Stellen Sie den `ZkBank`-Vertrag bereit.
+
+ ```sh
+ ZKBANK_ADDRESS=`forge create ZkBank --private-key $ETH_PRIVATE_KEY --broadcast --constructor-args $VERIFIER_ADDRESS 0x199aa62af8c1d562a6ec96e66347bf3240ab2afb5d022c895e6bf6a5e617167b | awk '/Deployed to:/ {print $3}'`
+ echo $ZKBANK_ADDRESS
+ ```
+
+ Der Wert `0x199..67b` ist der Pederson-Hash des Anfangszustands von `Accounts`. Wenn Sie diesen Anfangszustand in `server/index.mjs` ändern, können Sie eine Transaktion ausführen, um den vom Zero-Knowledge-Proof gemeldeten Anfangs-Hash zu sehen.
+
+8. Starten Sie den Server.
+
+ ```sh
+ cd ../server
+ npm run start
+ ```
+
+9. Führen Sie den Client in einem anderen Befehlszeilenfenster aus.
+
+ ```sh
+ cd client
+ npm run dev
+ ```
+
+10. Führen Sie einige Transaktionen aus.
+
+11. Um zu überprüfen, dass der Zustand onchain geändert wurde, starten Sie den Serverprozess neu. Beachten Sie, dass `ZkBank` keine Transaktionen mehr akzeptiert, da der ursprüngliche Hash-Wert in den Transaktionen vom onchain gespeicherten Hash-Wert abweicht.
+
+ Dies ist die Art von Fehler, die erwartet wird.
+
+ ```
+ ori@CryptoDocGuy:~/x/250911-zk-bank/server$ npm run start
+
+ > server@1.0.0 start
+ > node --experimental-json-modules index.mjs
+
+ Listening on port 3000
+ Verification error: ContractFunctionExecutionError: The contract function "processTransaction" reverted with the following reason:
+ Wrong old state hash
+
+ Contract Call:
+ address: 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512
+ function: processTransaction(bytes _proof, bytes32[] _publicInputs)
+ args: (0x0000000000000000000000000000000000000000000000042ab5d6d1986846cf00000000000000000000000000000000000000000000000b75c020998797da7800000000000000000000000000000000000000000000000
+ ```
+
+#### `server/index.mjs` {#server-index-mjs-2}
+
+Die Änderungen in dieser Datei beziehen sich hauptsächlich auf die Erstellung des tatsächlichen Beweises und dessen Einreichung onchain.
+
+```js
+import { exec } from 'child_process'
+import util from 'util'
+
+const execPromise = util.promisify(exec)
+```
+
+Wir müssen [das Barretenberg-Paket](https://github.com/AztecProtocol/aztec-packages/tree/next/barretenberg) verwenden, um den tatsächlichen Beweis zu erstellen, der onchain gesendet werden soll. Wir können dieses Paket entweder über die Befehlszeilenschnittstelle (`bb`) oder über die [JavaScript-Bibliothek `bb.js`](https://www.npmjs.com/package/@aztec/bb.js) verwenden. Die JavaScript-Bibliothek ist viel langsamer als nativer Code, daher verwenden wir hier [`exec`](https://nodejs.org/api/child_process.html#child_processexeccommand-options-callback), um die Befehlszeile zu nutzen.
+
+Beachten Sie, dass, wenn Sie sich für die Verwendung von `bb.js` entscheiden, Sie eine Version verwenden müssen, die mit der von Ihnen verwendeten Noir-Version kompatibel ist. Zum Zeitpunkt der Erstellung dieses Artikels verwendet die aktuelle Noir-Version (1.0.0-beta.11) `bb.js` Version 0.87.
+
+```js
+const zkBankAddress = process.env.ZKBANK_ADDRESS || "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512"
+```
+
+Die Adresse hier ist diejenige, die Sie erhalten, wenn Sie mit einem sauberen `anvil` beginnen und den obigen Anweisungen folgen.
+
+```js
+const walletClient = createWalletClient({
+ chain: anvil,
+ transport: http(),
+ account: privateKeyToAccount("0x2a871d0798f97d79848a013d4936a73bf4cc922c825d33c1cf7073dff6d409c6")
+})
+```
+
+Dieser private Schlüssel ist einer der standardmäßigen, vorfinanzierten Konten in `anvil`.
+
+```js
+const generateProof = async (witness, fileID) => {
+```
+
+Generieren Sie einen Beweis mit der ausführbaren Datei `bb`.
+
+```js
+ const fname = `witness-${fileID}.gz`
+ await fs.writeFile(fname, witness)
+```
+
+Schreiben Sie den Witness in eine Datei.
+
+```js
+ await execPromise(`bb prove -b ./noir/target/zkBank.json -w ${fname} -o ${fileID} --oracle_hash keccak --output_format fields`)
+```
+
+Erstellen Sie tatsächlich den Beweis. Dieser Schritt erstellt auch eine Datei mit den öffentlichen Variablen, aber die brauchen wir nicht. Diese Variablen haben wir bereits von `noir.execute` erhalten.
+
+```js
+ const proof = "0x" + JSON.parse(await fs.readFile(`./${fileID}/proof_fields.json`)).reduce((a,b) => a+b, "").replace(/0x/g, "")
+```
+
+Der Beweis ist ein JSON-Array von `Field`-Werten, die jeweils als Hexadezimalwert dargestellt werden. Wir müssen es jedoch in der Transaktion als einen einzigen `bytes`-Wert senden, den Viem durch eine große Hexadezimalzeichenkette darstellt. Hier ändern wir das Format, indem wir alle Werte verketten, alle `0x` entfernen und dann am Ende eines hinzufügen.
+
+```js
+ await execPromise(`rm -r ${fname} ${fileID}`)
+
+ return proof
+}
+```
+
+Aufräumen und den Beweis zurückgeben.
+
+```js
+const processMessage = async (message, signature) => {
+ .
+ .
+ .
+
+ const publicFields = noirResult.returnValue.map(x=>'0x' + x.slice(2).padStart(64, "0"))
+```
+
+Die öffentlichen Felder müssen ein Array von 32-Byte-Werten sein. Da wir jedoch den Transaktions-Hash zwischen zwei `Field`-Werten aufteilen mussten, erscheint er als 16-Byte-Wert. Hier fügen wir Nullen hinzu, damit Viem versteht, dass es sich tatsächlich um 32 Bytes handelt.
+
+```js
+ const proof = await generateProof(noirResult.witness, `${fromAddress}-${nonce}`)
+```
+
+Jede Adresse verwendet jede Nonce nur einmal, sodass wir eine Kombination aus `fromAddress` und `nonce` als eindeutigen Bezeichner für die Witness-Datei und das Ausgabeverzeichnis verwenden können.
+
+```js
+ try {
+ await zkBank.write.processTransaction([
+ proof, publicFields])
+ } catch (err) {
+ console.log(`Verification error: ${err}`)
+ throw Error("Can't verify the transaction onchain")
+ }
+ .
+ .
+ .
+}
+```
+
+Senden Sie die Transaktion an die Chain.
+
+#### `smart-contracts/src/ZkBank.sol` {#smart-contracts-src-zkbank-sol}
+
+Dies ist der Onchain-Code, der die Transaktion empfängt.
+
+```solidity
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.21;
+
+import {HonkVerifier} from "./Verifier.sol";
+
+contract ZkBank {
+ HonkVerifier immutable myVerifier;
+ bytes32 currentStateHash;
+
+ constructor(address _verifierAddress, bytes32 _initialStateHash) {
+ currentStateHash = _initialStateHash;
+ myVerifier = HonkVerifier(_verifierAddress);
+ }
+```
+
+Der Onchain-Code muss zwei Variablen nachverfolgen: den Verifizierer (ein separater Vertrag, der von `nargo` erstellt wird) und den aktuellen Zustands-Hash.
+
+```solidity
+ event TransactionProcessed(
+ bytes32 indexed transactionHash,
+ bytes32 oldStateHash,
+ bytes32 newStateHash
+ );
+```
+
+Jedes Mal, wenn sich der Zustand ändert, geben wir ein `TransactionProcessed`-Ereignis aus.
+
+```solidity
+ function processTransaction(
+ bytes calldata _proof,
+ bytes32[] calldata _publicFields
+ ) public {
+```
+
+Diese Funktion verarbeitet Transaktionen. Sie erhält den Beweis (als `bytes`) und die öffentlichen Eingaben (als `bytes32`-Array) in dem Format, das der Verifizierer benötigt (um die Onchain-Verarbeitung und damit die Gas-Kosten zu minimieren).
+
+```solidity
+ require(_publicInputs[0] == currentStateHash,
+ "Falscher alter Zustands-Hash");
+```
+
+Der Zero-Knowledge-Proof muss beweisen, dass die Transaktion von unserem aktuellen Hash zu einem neuen wechselt.
+
+```solidity
+ myVerifier.verify(_proof, _publicFields);
+```
+
+Rufen Sie den Verifizierer-Vertrag auf, um den Zero-Knowledge-Proof zu verifizieren. Dieser Schritt macht die Transaktion rückgängig, wenn der Zero-Knowledge-Proof falsch ist.
+
+```solidity
+ currentStateHash = _publicFields[1];
+
+ emit TransactionProcessed(
+ _publicFields[2]<<128 | _publicFields[3],
+ _publicFields[0],
+ _publicFields[1]
+ );
+ }
+}
+```
+
+Wenn alles stimmt, aktualisieren Sie den Zustands-Hash auf den neuen Wert und geben Sie ein `TransactionProcessed`-Ereignis aus.
+
+## Missbrauch durch die zentralisierte Komponente {#abuses}
+
+Informationssicherheit besteht aus drei Attributen:
+
+- _Vertraulichkeit_: Benutzer können keine Informationen lesen, für deren Lektüre sie nicht autorisiert sind.
+- _Integrität_: Informationen können nur von autorisierten Benutzern auf autorisierte Weise geändert werden.
+- _Verfügbarkeit_: Autorisierte Benutzer können das System verwenden.
+
+Auf diesem System wird die Integrität durch Zero-Knowledge-Proofs gewährleistet. Verfügbarkeit ist viel schwerer zu garantieren, und Vertraulichkeit ist unmöglich, da die Bank das Guthaben jedes Kontos und alle Transaktionen kennen muss. Es gibt keine Möglichkeit, eine Entität, die über Informationen verfügt, daran zu hindern, diese Informationen weiterzugeben.
+
+Es könnte möglich sein, eine wirklich vertrauliche Bank mit [Stealth-Adressen](https://vitalik.eth.limo/general/2023/01/20/stealth.html) zu erstellen, aber das liegt außerhalb des Rahmens dieses Artikels.
+
+### Falsche Informationen {#false-info}
+
+Eine Möglichkeit, wie der Server die Integrität verletzen kann, ist die Bereitstellung falscher Informationen, wenn [Daten angefordert werden](https://github.com/qbzzt/250911-zk-bank/blob/03-smart-contracts/server/index.mjs#L278-L291).
+
+Um dies zu lösen, können wir ein zweites Noir-Programm schreiben, das die Konten als private Eingabe und die Adresse, für die Informationen angefordert werden, als öffentliche Eingabe erhält. Die Ausgabe sind das Guthaben und die Nonce dieser Adresse sowie der Hash der Konten.
+
+Natürlich kann dieser Beweis nicht onchain verifiziert werden, da wir keine Nonces und Guthaben onchain veröffentlichen wollen. Er kann jedoch vom Client-Code, der im Browser ausgeführt wird, verifiziert werden.
+
+### Erzwungene Transaktionen {#forced-txns}
+
+Der übliche Mechanismus zur Gewährleistung der Verfügbarkeit und zur Verhinderung von Zensur auf L2s sind [erzwungene Transaktionen](https://docs.optimism.io/stack/transactions/forced-transaction). Aber erzwungene Transaktionen lassen sich nicht mit Zero-Knowledge-Proofs kombinieren. Der Server ist die einzige Instanz, die Transaktionen überprüfen kann.
+
+Wir können `smart-contracts/src/ZkBank.sol` so ändern, dass er erzwungene Transaktionen akzeptiert und den Server daran hindert, den Zustand zu ändern, bis sie verarbeitet sind. Dies eröffnet uns jedoch einen einfachen Denial-of-Service-Angriff. Was ist, wenn eine erzwungene Transaktion ungültig ist und daher unmöglich zu verarbeiten ist?
+
+Die Lösung ist ein Zero-Knowledge-Proof, dass eine erzwungene Transaktion ungültig ist. Dies gibt dem Server drei Optionen:
+
+- Verarbeiten Sie die erzwungene Transaktion und stellen Sie einen Zero-Knowledge-Proof bereit, dass sie verarbeitet wurde und den neuen Zustands-Hash.
+- Lehnen Sie die erzwungene Transaktion ab und legen Sie dem Vertrag einen Zero-Knowledge-Proof vor, dass die Transaktion ungültig ist (unbekannte Adresse, falsche Nonce oder unzureichendes Guthaben).
+- Ignorieren Sie die erzwungene Transaktion. Es gibt keine Möglichkeit, den Server zu zwingen, die Transaktion tatsächlich zu verarbeiten, aber es bedeutet, dass das gesamte System nicht verfügbar ist.
+
+#### Verfügbarkeitsanleihen {#avail-bonds}
+
+In einer realen Implementierung gäbe es wahrscheinlich eine Art Profitmotiv, den Server am Laufen zu halten. Wir können diesen Anreiz verstärken, indem der Server eine Verfügbarkeitsanleihe hinterlegt, die jeder verbrennen kann, wenn eine erzwungene Transaktion nicht innerhalb eines bestimmten Zeitraums verarbeitet wird.
+
+### Schlechter Noir-Code {#bad-noir-code}
+
+Normalerweise, um das Vertrauen der Leute in einen Smart Contract zu gewinnen, laden wir den Quellcode auf einen [Block-Explorer](https://eth.blockscout.com/address/0x7D16d2c4e96BCFC8f815E15b771aC847EcbDB48b?tab=contract) hoch. Im Falle von Zero-Knowledge-Proofs ist das jedoch unzureichend.
+
+`Verifier.sol` enthält den Verifizierungsschlüssel, der eine Funktion des Noir-Programms ist. Dieser Schlüssel sagt uns jedoch nicht, was das Noir-Programm war. Um tatsächlich eine vertrauenswürdige Lösung zu haben, müssen Sie das Noir-Programm (und die Version, die es erstellt hat) hochladen. Andernfalls könnten die Zero-Knowledge-Proofs ein anderes Programm widerspiegeln, eines mit einer Hintertür.
+
+Bis Block-Explorer es uns ermöglichen, Noir-Programme hochzuladen und zu verifizieren, sollten Sie es selbst tun (vorzugsweise auf [IPFS](/developers/tutorials/ipfs-decentralized-ui/)). Dann können versierte Benutzer den Quellcode herunterladen, selbst kompilieren, `Verifier.sol` erstellen und überprüfen, ob er mit dem auf der Chain identisch ist.
+
+## Fazit {#conclusion}
+
+Plasma-Anwendungen erfordern eine zentralisierte Komponente als Informationsspeicher. Dies eröffnet potenzielle Schwachstellen, ermöglicht es uns aber im Gegenzug, die Privatsphäre auf eine Weise zu wahren, die auf der Blockchain selbst nicht verfügbar ist. Mit Zero-Knowledge-Proofs können wir die Integrität gewährleisten und es möglicherweise wirtschaftlich vorteilhaft machen, dass der Betreiber der zentralisierten Komponente die Verfügbarkeit aufrechterhält.
+
+[Hier finden Sie mehr von meiner Arbeit](https://cryptodocguy.pro/).
+
+## Anerkennungen {#acknowledgements}
+
+- Josh Crites hat einen Entwurf dieses Artikels gelesen und mir bei einem kniffligen Noir-Problem geholfen.
+
+Alle verbleibenden Fehler liegen in meiner Verantwortung.
diff --git a/public/content/translations/de/developers/tutorials/calling-a-smart-contract-from-javascript/index.md b/public/content/translations/de/developers/tutorials/calling-a-smart-contract-from-javascript/index.md
index 80de3796183..e676e0a61f6 100644
--- a/public/content/translations/de/developers/tutorials/calling-a-smart-contract-from-javascript/index.md
+++ b/public/content/translations/de/developers/tutorials/calling-a-smart-contract-from-javascript/index.md
@@ -1,15 +1,11 @@
---
-title: Smart Contract aus JavaScript aufrufen
-description: So rufen Sie am Beispiel eines Dai-Tokens eine Smart-Contract-Funktion von JavaScript aus auf
+title: Aufruf eines Smart Contracts aus JavaScript
+description: Wie Sie eine Smart-Contract-Funktion aus JavaScript am Beispiel eines Dai-Tokens aufrufen
author: jdourlens
-tags:
- - "Transaktionen"
- - "Frontend"
- - "JavaScript"
- - "web3.js"
+tags: [ "Transaktionen", "Frontend", "JavaScript", "web3.js" ]
skill: beginner
lang: de
-published: 2020-04-19
+published: 19.04.2020
source: EthereumDev
sourceUrl: https://ethereumdev.io/calling-a-smart-contract-from-javascript/
address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
@@ -23,7 +19,7 @@ Für dieses Beispiel wird ein DAI-Token verwendet. Zu Testzwecken werden wir die
ganache-cli -f https://mainnet.infura.io/v3/[YOUR INFURA KEY] -d -i 66 1 --unlock 0x4d10ae710Bd8D1C31bd7465c8CBC3add6F279E81
```
-Für die Interaktoin mit einem Smart Contract benötigen wir seine Adresse und ABI:
+Für die Interaktion mit einem Smart Contract benötigen wir seine Adresse und ABI:
```js
const ERC20TransferABI = [
@@ -74,9 +70,9 @@ const ERC20TransferABI = [
const DAI_ADDRESS = "0x6b175474e89094c44da98b954eedeac495271d0f"
```
-Für dieses Projekt haben wir die komplette ERC20 ABI gestrippt, um nur die `balanceOf`- und `transfer`-Funktion zu behalten. Sie können [die komplette ERC20 ABI allerdings hier finden](https://ethereumdev.io/abi-for-erc20-contract-on-ethereum/).
+Für dieses Projekt haben wir die komplette ERC20-ABI auf die Funktionen `balanceOf` und `transfer` reduziert, aber [die vollständige ERC20-ABI finden Sie hier](https://ethereumdev.io/abi-for-erc20-contract-on-ethereum/).
-Anschließend müssen wir unseren Smart Contract starten:
+Anschließend müssen wir unseren Smart Contract instanziieren:
```js
const web3 = new Web3("http://localhost:8545")
@@ -87,7 +83,7 @@ const daiToken = new web3.eth.Contract(ERC20TransferABI, DAI_ADDRESS)
Außerdem richten wir zwei Adressen ein:
- diejenige, die die Übertragung erhält und
-- diejeige, die wir bereits eingerichtet haben, und die die Übertragung senden wird:
+- diejenige, die wir bereits freigeschaltet haben und die sie senden wird:
```js
const senderAddress = "0x4d10ae710Bd8D1C31bd7465c8CBC3add6F279E81"
@@ -98,9 +94,9 @@ Im nächsten Teil rufen wir die Funktion `balanceOf` auf, um die aktuelle Menge
## Aufruf: Wert aus einem Smart Contract lesen {#call-reading-value-from-a-smart-contract}
-Das erste Beispiel ruft eine "konstante" Methode auf und führt deren Smart-Contract-Methode im EVM aus, ohne eine Transaktion zu senden. Hierfür lesen wir den ERC20-Saldo einer Adresse aus. [Lesen Sie unseren Artikel über ERC20-Token](/developers/tutorials/understand-the-erc-20-token-smart-contract/).
+Das erste Beispiel ruft eine „konstante“ Methode auf und führt deren Smart-Contract-Methode in der EVM aus, ohne eine Transaktion zu senden. Hierfür lesen wir den ERC20-Saldo einer Adresse aus. [Lesen Sie unseren Artikel über ERC20-Token](/developers/tutorials/understand-the-erc-20-token-smart-contract/).
-Sie können auf die Methoden eines instanziierten Smart Contracts, für den Sie die ABI bereitgestellt haben, wie folgt zugreifen: `yourContract.methods.methodname`. Durch Verwendung der `Aufruf`-Funktion erhalten Sie das Ergebnis der Ausführung der Funktion.
+Sie können auf die Methoden eines instanziierten Smart Contracts, für die Sie die ABI bereitgestellt haben, wie folgt zugreifen: `yourContract.methods.methodname`. Durch die Verwendung der `call`-Funktion erhalten Sie das Ergebnis der Ausführung der Funktion.
```js
daiToken.methods.balanceOf(senderAddress).call(function (err, res) {
@@ -112,11 +108,11 @@ daiToken.methods.balanceOf(senderAddress).call(function (err, res) {
})
```
-Denken Sie daran, dass DAI ERC20 18 Dezimalstellen hat. Das bedeutet, dass Sie 18 Nullen entfernen müssen, um den richtigen Betrag zu erhalten. uint256 werden als Strings zurückgegeben, da JavaScript keine großen numerischen Werte verarbeiten kann. Wenn Sie nicht sicher sind, [wie Sie mit großen Zahlen in JS umgehen sollen, lesen Sie unser Tutorial über bignumber.js](https://ethereumdev.io/how-to-deal-with-big-numbers-in-javascript/).
+Denken Sie daran, dass DAI ERC20 18 Dezimalstellen hat. Das bedeutet, dass Sie 18 Nullen entfernen müssen, um den richtigen Betrag zu erhalten. uint256 werden als Strings zurückgegeben, da JavaScript keine großen numerischen Werte verarbeiten kann. Wenn Sie sich nicht sicher sind, wie Sie mit großen Zahlen in JS umgehen sollen, [lesen Sie unser Tutorial über bignumber.js](https://ethereumdev.io/how-to-deal-with-big-numbers-in-javascript/).
-## Senden: Senden einer Transaktion an eine Smart-Contract-Funktion {#send-sending-a-transaction-to-a-smart-contract-function}
+## Senden: Eine Transaktion an eine Smart-Contract-Funktion senden {#send-sending-a-transaction-to-a-smart-contract-function}
-Für das zweite Beispiel rufen wir die Transferfunktion des DAI-Smart Contracts auf, um 10 DAI an unsere zweite Adresse zu senden. Die Übertragungsfunktion akzeptiert zwei Parameter: die Empfängeradresse und den Betrag des zu übertragenden Tokens:
+Im zweiten Beispiel rufen wir die Transfer-Funktion des DAI-Smart-Contracts auf, um 10 DAI an unsere zweite Adresse zu senden. Die Übertragungsfunktion akzeptiert zwei Parameter: die Empfängeradresse und den Betrag der zu übertragenden Token:
```js
daiToken.methods
@@ -130,6 +126,6 @@ daiToken.methods
})
```
-Die Aufruffunktion gibt den Hash der Transaktion zurück, der in die Blockchain gemined wird. Bei Ethereum sind Transaktions-Hashes vorhersehbar – so können wir den Hash der Transaktion erhalten, bevor sie ausgeführt wird ([lernen Sie hier, wie Hashes berechnet werden](https://ethereum.stackexchange.com/questions/45648/how-to-calculate-the-assigned-txhash-of-a-transaction)).
+Die Aufruffunktion gibt den Hash der Transaktion zurück, der in die Blockchain gemined wird. Auf Ethereum sind Transaktions-Hashes vorhersagbar – so können wir den Hash der Transaktion erhalten, bevor sie ausgeführt wird ([hier erfahren Sie, wie Hashes berechnet werden](https://ethereum.stackexchange.com/questions/45648/how-to-calculate-the-assigned-txhash-of-a-transaction)).
-Da die Funktion die Transaktion nur an die Blockchain sendet, können wir das Ergebnis erst sehen, wenn es gemined und in die Blockchain aufgenommen wurde. Im nächsten Tutorial werden wir lernen, [wie man auf die Ausführung einer Transaktion auf der Blockchain wartet, indem man ihren Hash kennt](https://ethereumdev.io/waiting-for-a-transaction-to-be-mined-on-ethereum-with-js/).
+Da die Funktion die Transaktion nur an die Blockchain sendet, können wir das Ergebnis erst sehen, wenn es gemined und in die Blockchain aufgenommen wurde. Im nächsten Tutorial lernen wir, [wie man anhand des Hashes einer Transaktion darauf wartet, dass sie auf der Blockchain ausgeführt wird](https://ethereumdev.io/waiting-for-a-transaction-to-be-mined-on-ethereum-with-js/).
diff --git a/public/content/translations/de/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md b/public/content/translations/de/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md
new file mode 100644
index 00000000000..afadddb360d
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md
@@ -0,0 +1,585 @@
+---
+title: "Erstellen einer Benutzeroberfläche für Ihren Vertrag"
+description: Mithilfe moderner Komponenten wie TypeScript, React, Vite und Wagmi werden wir eine moderne, aber minimalistische Benutzeroberfläche durchgehen und lernen, wie man eine Wallet mit der Benutzeroberfläche verbindet, einen Smart Contract aufruft, um Informationen auszulesen, eine Transaktion an einen Smart Contract zu senden und Ereignisse von einem Smart Contract zu überwachen, um Änderungen zu erkennen.
+author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+tags: [ "typescript", "react", "vite", "wagmi", "Frontend" ]
+skill: beginner
+published: 01.11.2023
+lang: de
+sidebarDepth: 3
+---
+
+Sie haben eine Funktion gefunden, die wir im Ethereum-Ökosystem benötigen. Sie haben die Smart Contracts geschrieben, um sie zu implementieren, und vielleicht sogar einen zugehörigen Code, der Offchain ausgeführt wird. Das ist großartig! Leider werden Sie ohne eine Benutzeroberfläche keine Benutzer haben, und als Sie das letzte Mal eine Website geschrieben haben, benutzten die Leute noch Wählmodems und JavaScript war neu.
+
+Dieser Artikel ist für Sie. Ich gehe davon aus, dass Sie programmieren können und vielleicht ein wenig JavaScript und HTML kennen, aber dass Ihre Kenntnisse im Bereich der Benutzeroberflächen eingerostet und veraltet sind. Gemeinsam werden wir eine einfache, moderne Anwendung durchgehen, damit Sie sehen, wie man das heutzutage macht.
+
+## Warum ist das wichtig? {#why-important}
+
+Theoretisch könnten Sie die Leute einfach [Etherscan](https://holesky.etherscan.io/address/0x432d810484add7454ddb3b5311f0ac2e95cecea8#writeContract) oder [Blockscout](https://eth-holesky.blockscout.com/address/0x432d810484AdD7454ddb3b5311f0Ac2E95CeceA8?tab=write_contract) verwenden lassen, um mit Ihren Verträgen zu interagieren. Das wird für die erfahrenen Ethereans großartig sein. Aber wir versuchen, [eine weitere Milliarde Menschen](https://blog.ethereum.org/2021/05/07/ethereum-for-the-next-billion) zu erreichen. Dies wird ohne eine großartige Benutzererfahrung nicht geschehen, und eine benutzerfreundliche Oberfläche ist ein großer Teil davon.
+
+## Greeter-Anwendung {#greeter-app}
+
+Es gibt eine Menge Theorie dahinter, wie eine moderne Benutzeroberfläche funktioniert, und [viele gute Seiten](https://react.dev/learn/thinking-in-react), [die es erklären](https://wagmi.sh/core/getting-started). Anstatt die gute Arbeit dieser Seiten zu wiederholen, gehe ich davon aus, dass Sie es vorziehen, durch praktische Anwendung zu lernen und mit einer Anwendung zu beginnen, mit der Sie herumspielen können. Sie brauchen immer noch die Theorie, um Dinge zu erledigen, und wir werden dazu kommen – wir werden einfach Quelldatei für Quelldatei durchgehen und die Dinge besprechen, wenn wir zu ihnen kommen.
+
+### Installation {#installation}
+
+1. Fügen Sie bei Bedarf [die Holesky-Blockchain](https://chainlist.org/?search=holesky&testnets=true) zu Ihrer Wallet hinzu und [holen Sie sich Test-ETH](https://www.holeskyfaucet.io/).
+
+2. Klonen Sie das GitHub-Repository.
+
+ ```sh
+ git clone https://github.com/qbzzt/20230801-modern-ui.git
+ ```
+
+3. Installieren Sie die erforderlichen Pakete.
+
+ ```sh
+ cd 20230801-modern-ui
+ pnpm install
+ ```
+
+4. Starten Sie die Anwendung.
+
+ ```sh
+ pnpm dev
+ ```
+
+5. Navigieren Sie zu der von der Anwendung angezeigten URL. In den meisten Fällen ist dies [http://localhost:5173/](http://localhost:5173/).
+
+6. Sie können den Quellcode des Vertrags, eine leicht modifizierte Version von Hardhat's Greeter, [auf einem Blockchain-Explorer](https://eth-holesky.blockscout.com/address/0x432d810484AdD7454ddb3b5311f0Ac2E95CeceA8?tab=contract) sehen.
+
+### Dateidurchsicht {#file-walk-through}
+
+#### `index.html` {#index-html}
+
+Diese Datei ist ein Standard-HTML-Boilerplate mit Ausnahme dieser Zeile, die die Skriptdatei importiert.
+
+```html
+
+```
+
+#### `src/main.tsx` {#main-tsx}
+
+Die Dateierweiterung verrät uns, dass es sich bei dieser Datei um eine [React-Komponente](https://www.w3schools.com/react/react_components.asp) handelt, die in [TypeScript](https://www.typescriptlang.org/) geschrieben wurde, einer Erweiterung von JavaScript, die eine [Typüberprüfung](https://en.wikipedia.org/wiki/Type_system#Type_checking) unterstützt. TypeScript wird in JavaScript kompiliert, sodass wir es für die clientseitige Ausführung verwenden können.
+
+```tsx
+import '@rainbow-me/rainbowkit/styles.css'
+import { RainbowKitProvider } from '@rainbow-me/rainbowkit'
+import * as React from 'react'
+import * as ReactDOM from 'react-dom/client'
+import { WagmiConfig } from 'wagmi'
+import { chains, config } from './wagmi'
+```
+
+Importieren Sie den benötigten Bibliotheks-Code.
+
+```tsx
+import { App } from './App'
+```
+
+Importieren Sie die React-Komponente, die die Anwendung implementiert (siehe unten).
+
+```tsx
+ReactDOM.createRoot(document.getElementById('root')!).render(
+```
+
+Erstellen Sie die Root-React-Komponente. Der Parameter für `render` ist [JSX](https://www.w3schools.com/react/react_jsx.asp), eine Erweiterungssprache, die sowohl HTML als auch JavaScript/TypeScript verwendet. Das Ausrufezeichen hier teilt dem TypeScript-Compiler mit: "Auch wenn nicht verifiziert werden kann, dass `document.getElementById('root')` ein gültiger Parameter für `ReactDOM.createRoot` sein wird, keine Sorge – ich als Entwickler garantiere, dass er vorhanden sein wird".
+
+```tsx
+
+```
+
+Die Anwendung befindet sich in [einer `React.StrictMode`-Komponente](https://react.dev/reference/react/StrictMode). Diese Komponente weist die React-Bibliothek an, zusätzliche Debugging-Prüfungen einzufügen, was während der Entwicklung nützlich ist.
+
+```tsx
+
+```
+
+Die Anwendung befindet sich auch in [einer `WagmiConfig`-Komponente](https://wagmi.sh/react/api/WagmiProvider). [Die wagmi (we are going to make it) Bibliothek](https://wagmi.sh/) verbindet die React-UI-Definitionen mit [der viem-Bibliothek](https://viem.sh/) zum Schreiben einer dezentralisierten Ethereum-Anwendung.
+
+```tsx
+
+```
+
+Und schließlich [eine `RainbowKitProvider`-Komponente](https://www.rainbowkit.com/). Diese Komponente kümmert sich um die Anmeldung und die Kommunikation zwischen der Wallet und der Anwendung.
+
+```tsx
+
+
+ ,
+)
+```
+
+Natürlich müssen wir auch die anderen Komponenten schließen.
+
+#### `src/App.tsx` {#app-tsx}
+
+```tsx
+import { ConnectButton } from '@rainbow-me/rainbowkit'
+import { useAccount } from 'wagmi'
+import { Greeter } from './components/Greeter'
+
+export function App() {
+```
+
+Dies ist die Standardmethode zum Erstellen einer React-Komponente – definieren Sie eine Funktion, die jedes Mal aufgerufen wird, wenn sie gerendert werden muss. Diese Funktion hat typischerweise am Anfang etwas TypeScript- oder JavaScript-Code, gefolgt von einer `return`-Anweisung, die den JSX-Code zurückgibt.
+
+```tsx
+ const { isConnected } = useAccount()
+```
+
+Hier verwenden wir [`useAccount`](https://wagmi.sh/react/api/hooks/useAccount), um zu prüfen, ob wir über eine Wallet mit einer Blockchain verbunden sind oder nicht.
+
+Konventionsgemäß sind in React Funktionen, die `use...` heißen, [Hooks](https://www.w3schools.com/react/react_hooks.asp), die eine Art von Daten zurückgeben. Wenn Sie solche Hooks verwenden, erhält Ihre Komponente nicht nur die Daten, sondern wenn sich diese Daten ändern, wird die Komponente mit den aktualisierten Informationen neu gerendert.
+
+```tsx
+ return (
+ <>
+```
+
+Das JSX einer React-Komponente _muss_ eine Komponente zurückgeben. Wenn wir mehrere Komponenten haben und nichts haben, was sie "natürlich" umschließt, verwenden wir eine leere Komponente (`<> ...` \`), um sie zu einer einzigen Komponente zu machen.
+
+```tsx
+ Greeter
+ = (evt) =>
+ setNewGreeting(evt.target.value)
+```
+
+Dies ist der Ereignis-Handler für den Fall, dass sich das Eingabefeld für die neue Begrüßung ändert. Der Typ [`ChangeEventHandler`](https://react-typescript-cheatsheet.netlify.app/docs/basic/getting-started/forms_and_events/) gibt an, dass dies ein Handler für eine Wertänderung eines HTML-Eingabeelements ist. Der Teil `` wird verwendet, da es sich um einen [generischen Typ](https://www.w3schools.com/typescript/typescript_basic_generics.php) handelt.
+
+```tsx
+ const preparedTx = usePrepareContractWrite({
+ address: greeterAddr,
+ abi: greeterABI,
+ functionName: 'setGreeting',
+ args: [ newGreeting ]
+ })
+ const workingTx = useContractWrite(preparedTx.config)
+```
+
+Dies ist der Prozess, um eine Blockchain-Transaktion aus der Client-Perspektive zu übermitteln:
+
+1. Senden Sie die Transaktion an einen Knoten in der Blockchain unter Verwendung von [`eth_estimateGas`](https://docs.alchemy.com/reference/eth-estimategas).
+2. Warten Sie auf eine Antwort vom Knoten.
+3. Wenn die Antwort eingegangen ist, bitten Sie den Benutzer, die Transaktion über die Wallet zu signieren. Dieser Schritt _muss_ erfolgen, nachdem die Antwort des Knotens eingegangen ist, da dem Benutzer die Gaskosten der Transaktion vor dem Signieren angezeigt werden.
+4. Warten Sie auf die Genehmigung durch den Benutzer.
+5. Senden Sie die Transaktion erneut, diesmal mit [`eth_sendRawTransaction`](https://docs.alchemy.com/reference/eth-sendrawtransaction).
+
+Schritt 2 wird wahrscheinlich eine spürbare Zeit in Anspruch nehmen, während der sich die Benutzer fragen würden, ob ihr Befehl wirklich von der Benutzeroberfläche empfangen wurde und warum sie nicht bereits gebeten werden, die Transaktion zu signieren. Das sorgt für eine schlechte Benutzererfahrung (UX).
+
+Die Lösung besteht darin, [Prepare-Hooks](https://wagmi.sh/react/prepare-hooks) zu verwenden. Jedes Mal, wenn sich ein Parameter ändert, senden Sie sofort die `eth_estimateGas`-Anfrage an den Knoten. Wenn der Benutzer dann tatsächlich die Transaktion senden möchte (in diesem Fall durch Drücken von **Gruß aktualisieren**), sind die Gaskosten bekannt und der Benutzer kann die Wallet-Seite sofort sehen.
+
+```tsx
+ return (
+```
+
+Jetzt können wir endlich das eigentliche HTML zur Rückgabe erstellen.
+
+```tsx
+ <>
+ Greeter
+ {
+ !readResults.isError && !readResults.isLoading &&
+
+```
+
+Erstellen Sie eine `ShowGreeting`-Komponente (wird unten erklärt), aber nur, wenn die Begrüßung erfolgreich von der Blockchain gelesen wurde.
+
+```tsx
+
+```
+
+Dies ist das Eingabefeld, in dem der Benutzer eine neue Begrüßung festlegen kann. Jedes Mal, wenn der Benutzer eine Taste drückt, rufen wir `greetingChange` auf, was `setNewGreeting` aufruft. Da `setNewGreeting` aus dem `useState`-Hook stammt, wird die `Greeter`-Komponente erneut gerendert. Dies bedeutet, dass:
+
+- Wir müssen `value` angeben, um den Wert der neuen Begrüßung beizubehalten, da er sich sonst wieder in den Standardwert, den leeren String, zurückverwandeln würde.
+- `usePrepareContractWrite` wird jedes Mal aufgerufen, wenn sich `newGreeting` ändert, was bedeutet, dass es immer das neueste `newGreeting` in der vorbereiteten Transaktion haben wird.
+
+```tsx
+
+```
+
+Wenn kein `workingTx.write` vorhanden ist, warten wir noch auf Informationen, die zum Senden der Grußaktualisierung erforderlich sind, sodass die Schaltfläche deaktiviert ist. Wenn ein `workingTx.write`-Wert vorhanden ist, ist dies die Funktion, die aufgerufen werden muss, um die Transaktion zu senden.
+
+```tsx
+
+ {attrs.name}
+
+ {JSON.stringify(attrs.object, null, 2)}
+```
+
+Die meisten Felder werden mit [`JSON.stringify`](https://www.w3schools.com/js/js_json_stringify.asp) angezeigt.
+
+```tsx
+
+ { funs.length > 0 &&
+ <>
+ Funktionen:
+
+```
+
+Die Ausnahme sind Funktionen, die nicht Teil des [JSON-Standards](https://www.json.org/json-en.html) sind und daher separat angezeigt werden müssen.
+
+```tsx
+ {funs.map((f, i) =>
+```
+
+Innerhalb von JSX wird der Code in `{` geschweiften Klammern `}` als JavaScript interpretiert. Dann wird der Code innerhalb der `(` runden Klammern `)` wieder als JSX interpretiert.
+
+```tsx
+ (- {f}
)
+ )}
+```
+
+React erfordert, dass Tags im [DOM-Baum](https://www.w3schools.com/js/js_htmldom.asp) eindeutige Bezeichner haben. Dies bedeutet, dass untergeordnete Elemente desselben Tags (in diesem Fall [die ungeordnete Liste](https://www.w3schools.com/tags/tag_ul.asp)) unterschiedliche `key`-Attribute benötigen.
+
+```tsx
+
+
+ }
+
+
+}
+```
+
+Beenden Sie die verschiedenen HTML-Tags.
+
+##### Der abschließende `Export` {#the-final-export}
+
+```tsx
+export { Greeter }
+```
+
+Die `Greeter`-Komponente ist diejenige, die wir für die Anwendung exportieren müssen.
+
+#### `src/wagmi.ts` {#wagmi-ts}
+
+Schließlich befinden sich verschiedene Definitionen in Bezug auf WAGMI in `src/wagmi.ts`. Ich werde hier nicht alles erklären, da das meiste davon Boilerplate ist, den Sie wahrscheinlich nicht ändern müssen.
+
+Der Code hier ist nicht genau derselbe wie [auf Github](https://github.com/qbzzt/20230801-modern-ui/blob/main/src/wagmi.ts), da wir später im Artikel eine weitere Chain ([Redstone Holesky](https://redstone.xyz/docs/network-info)) hinzufügen.
+
+```ts
+import { getDefaultWallets } from '@rainbow-me/rainbowkit'
+import { configureChains, createConfig } from 'wagmi'
+import { holesky, sepolia } from 'wagmi/chains'
+```
+
+Importieren Sie die Blockchains, die die Anwendung unterstützt. Sie können die Liste der unterstützten Chains [im Viem-Github](https://github.com/wagmi-dev/viem/tree/main/src/chains/definitions) sehen.
+
+```ts
+import { publicProvider } from 'wagmi/providers/public'
+
+const walletConnectProjectId = 'c96e690bb92b6311e8e9b2a6a22df575'
+```
+
+Um [WalletConnect](https://walletconnect.com/) verwenden zu können, benötigen Sie eine Projekt-ID für Ihre Anwendung. Sie können sie [auf cloud.walletconnect.com](https://cloud.walletconnect.com/sign-in) erhalten.
+
+```ts
+const { chains, publicClient, webSocketPublicClient } = configureChains(
+ [ holesky, sepolia ],
+ [
+ publicProvider(),
+ ],
+)
+
+const { connectors } = getDefaultWallets({
+ appName: 'My wagmi + RainbowKit App',
+ chains,
+ projectId: walletConnectProjectId,
+})
+
+export const config = createConfig({
+ autoConnect: true,
+ connectors,
+ publicClient,
+ webSocketPublicClient,
+})
+
+export { chains }
+```
+
+### Eine weitere Blockchain hinzufügen {#add-blockchain}
+
+Heutzutage gibt es eine Menge [L2-Skalierungslösungen](/layer-2/), und vielleicht möchten Sie einige unterstützen, die Viem noch nicht unterstützt. Dazu ändern Sie `src/wagmi.ts`. Diese Anweisungen erklären, wie man [Redstone Holesky](https://redstone.xyz/docs/network-info) hinzufügt.
+
+1. Importieren Sie den `defineChain`-Typ aus Viem.
+
+ ```ts
+ import { defineChain } from 'viem'
+ ```
+
+2. Fügen Sie die Netzwerkdefinition hinzu.
+
+ ```ts
+ const redstoneHolesky = defineChain({
+ id: 17_001,
+ name: 'Redstone Holesky',
+ network: 'redstone-holesky',
+ nativeCurrency: {
+ decimals: 18,
+ name: 'Ether',
+ symbol: 'ETH',
+ },
+ rpcUrls: {
+ default: {
+ http: ['https://rpc.holesky.redstone.xyz'],
+ webSocket: ['wss://rpc.holesky.redstone.xyz/ws'],
+ },
+ public: {
+ http: ['https://rpc.holesky.redstone.xyz'],
+ webSocket: ['wss://rpc.holesky.redstone.xyz/ws'],
+ },
+ },
+ blockExplorers: {
+ default: { name: 'Explorer', url: 'https://explorer.holesky.redstone.xyz' },
+ },
+ })
+ ```
+
+3. Fügen Sie die neue Chain zum `configureChains`-Aufruf hinzu.
+
+ ```ts
+ const { chains, publicClient, webSocketPublicClient } = configureChains(
+ [ holesky, sepolia, redstoneHolesky ],
+ [ publicProvider(), ],
+ )
+ ```
+
+4. Stellen Sie sicher, dass die Anwendung die Adresse für Ihre Verträge im neuen Netzwerk kennt. In diesem Fall ändern wir `src/components/Greeter.tsx`:
+
+ ```ts
+ const contractAddrs : AddressPerBlockchainType = {
+ // Holesky
+ 17000: '0x432d810484AdD7454ddb3b5311f0Ac2E95CeceA8',
+
+ // Redstone Holesky
+ 17001: '0x4919517f82a1B89a32392E1BF72ec827ba9986D3',
+
+ // Sepolia
+ 11155111: '0x7143d5c190F048C8d19fe325b748b081903E3BF0'
+ }
+ ```
+
+## Fazit {#conclusion}
+
+Natürlich ist es Ihnen egal, ob Sie eine Benutzeroberfläche für `Greeter` bereitstellen. Sie möchten eine Benutzeroberfläche für Ihre eigenen Verträge erstellen. Um Ihre eigene Anwendung zu erstellen, führen Sie diese Schritte aus:
+
+1. Geben Sie an, dass eine Wagmi-Anwendung erstellt werden soll.
+
+ ```sh copy
+ pnpm create wagmi
+ ```
+
+2. Benennen Sie die Anwendung.
+
+3. Wählen Sie das **React**-Framework.
+
+4. Wählen Sie die **Vite**-Variante.
+
+5. Sie können [Rainbow Kit hinzufügen](https://www.rainbowkit.com/docs/installation#manual-setup).
+
+Jetzt können Sie loslegen und Ihre Verträge für die ganze Welt nutzbar machen.
+
+[Hier finden Sie mehr von meiner Arbeit](https://cryptodocguy.pro/).
+
diff --git a/public/content/translations/de/developers/tutorials/deploying-your-first-smart-contract/index.md b/public/content/translations/de/developers/tutorials/deploying-your-first-smart-contract/index.md
new file mode 100644
index 00000000000..02240c82ca7
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/deploying-your-first-smart-contract/index.md
@@ -0,0 +1,101 @@
+---
+title: Deinen ersten Smart Contract bereitstellen
+description: Eine Einführung in die Bereitstellung deines ersten Smart Contracts in einem Ethereum-Testnetzwerk
+author: "jdourlens"
+tags:
+ [
+ "intelligente Verträge",
+ "remix",
+ "solidity",
+ "Bereitstellung"
+ ]
+skill: beginner
+lang: de
+published: 2020-04-03
+source: EthereumDev
+sourceUrl: https://ethereumdev.io/deploying-your-first-smart-contract/
+address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
+---
+
+Ich nehme an, du bist genauso aufgeregt wie wir, deinen ersten [Smart Contract](/developers/docs/smart-contracts/) auf der Ethereum-Blockchain [bereitzustellen](/developers/docs/smart-contracts/deploying/) und mit ihm zu interagieren.
+
+Keine Sorge, da dies unser erster Smart Contract ist, werden wir ihn in einem [lokalen Testnetzwerk](/developers/docs/networks/) bereitstellen, sodass es dich nichts kostet, ihn bereitzustellen und so viel damit zu spielen, wie du möchtest.
+
+## Schreiben unseres Vertrags {#writing-our-contract}
+
+Der erste Schritt ist, [Remix zu besuchen](https://remix.ethereum.org/) und eine neue Datei zu erstellen. Füge im oberen linken Teil der Remix-Benutzeroberfläche eine neue Datei hinzu und gib den gewünschten Dateinamen ein.
+
+
+
+In die neue Datei fügen wir den folgenden Code ein.
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.5.17;
+
+contract Counter {
+
+ // Öffentliche Variable vom Typ vorzeichenlose Ganzzahl, um die Anzahl der Zählvorgänge zu speichern
+ uint256 public count = 0;
+
+ // Funktion, die unseren Zähler erhöht
+ function increment() public {
+ count += 1;
+ }
+
+ // Nicht notwendiger Getter, um den Zählwert zu erhalten
+ function getCount() public view returns (uint256) {
+ return count;
+ }
+
+}
+```
+
+Wenn du mit dem Programmieren vertraut bist, kannst du leicht erraten, was dieses Programm tut. Hier ist eine Erklärung, Zeile für Zeile:
+
+- Zeile 4: Wir definieren einen Vertrag mit dem Namen `Counter`.
+- Zeile 7: Unser Vertrag speichert eine vorzeichenlose Ganzzahl namens `count`, die bei 0 beginnt.
+- Zeile 10: Die erste Funktion ändert den Zustand des Vertrags und erhöht (`increment()`) unsere Variable `count`.
+- Zeile 15: Die zweite Funktion ist nur ein Getter, um den Wert der Variable `count` außerhalb des Smart Contracts auslesen zu können. Beachte, dass dies nicht notwendig ist, da wir unsere `count`-Variable als öffentlich (public) definiert haben, sondern nur als Beispiel dient.
+
+Das ist alles für unseren ersten einfachen Smart Contract. Wie du vielleicht weißt, sieht es aus wie eine Klasse aus OOP-Sprachen (objektorientierte Programmierung) wie Java oder C++. Jetzt ist es an der Zeit, mit unserem Vertrag zu spielen.
+
+## Bereitstellung unseres Vertrags {#deploying-our-contract}
+
+Nachdem wir unseren allerersten Smart Contract geschrieben haben, werden wir ihn nun in der Blockchain bereitstellen, um damit spielen zu können.
+
+[Die Bereitstellung des Smart Contracts in der Blockchain](/developers/docs/smart-contracts/deploying/) ist eigentlich nur das Senden einer Transaktion, die den Code des kompilierten Smart Contracts enthält, ohne einen Empfänger anzugeben.
+
+Zuerst [kompilieren wir den Vertrag](/developers/docs/smart-contracts/compiling/), indem wir auf das Kompilieren-Symbol auf der linken Seite klicken:
+
+
+
+Klicke dann auf die Schaltfläche „Kompilieren“:
+
+
+
+Du kannst die Option „Auto compile“ wählen, damit der Vertrag immer kompiliert wird, wenn du den Inhalt im Texteditor speicherst.
+
+Navigiere dann zum Bildschirm „Deploy and run transactions“:
+
+
+
+Sobald du auf dem Bildschirm „Deploy and run transactions“ bist, überprüfe, ob dein Vertragsname erscheint, und klicke auf „Deploy“. Wie du oben auf der Seite sehen kannst, ist die aktuelle Umgebung „JavaScript VM“. Das bedeutet, dass wir unseren Smart Contract in einer lokalen Test-Blockchain bereitstellen und mit ihm interagieren, um schneller und ohne Gebühren testen zu können.
+
+
+
+Sobald du auf die Schaltfläche „Deploy“ geklickt hast, siehst du deinen Vertrag unten erscheinen. Klicke auf den Pfeil links, um ihn zu erweitern, damit wir den Inhalt unseres Vertrags sehen. Das sind unsere Variable `counter`, unsere Funktion `increment()` und der Getter `getCounter()`.
+
+Wenn du auf die Schaltfläche `count` oder `getCount` klickst, wird der Inhalt der `count`-Variable des Vertrags abgerufen und angezeigt. Da wir die Funktion `increment` noch nicht aufgerufen haben, sollte 0 angezeigt werden.
+
+
+
+Rufen wir nun die Funktion `increment` auf, indem wir auf die Schaltfläche klicken. Du wirst am unteren Rand des Fensters die Protokolle der durchgeführten Transaktionen sehen. Du wirst sehen, dass die Protokolle anders aussehen, wenn du die Schaltfläche zum Abrufen der Daten anstelle der Schaltfläche `increment` drückst. Das liegt daran, dass das Lesen von Daten auf der Blockchain keine Transaktionen (Schreibvorgänge) oder Gebühren erfordert. Denn nur die Änderung des Zustands der Blockchain erfordert eine Transaktion:
+
+
+
+Nachdem du die Schaltfläche `increment` gedrückt hast, die eine Transaktion zum Aufruf unserer `increment()`-Funktion generiert, lesen wir den neu aktualisierten Zustand unseres Smart Contracts, wenn wir wieder auf die Schaltflächen `count` oder `getCount` klicken, wobei die Variable `count` größer als 0 ist.
+
+
+
+Im nächsten Tutorial befassen wir uns damit, [wie du Events zu deinen Smart Contracts hinzufügen kannst](/developers/tutorials/logging-events-smart-contracts/). Die Protokollierung von Events ist eine bequeme Möglichkeit, deinen Smart Contract zu debuggen und zu verstehen, was beim Aufruf einer Funktion passiert.
diff --git a/public/content/translations/de/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md b/public/content/translations/de/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md
new file mode 100644
index 00000000000..334c9252b32
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md
@@ -0,0 +1,372 @@
+---
+title: Wie man eine Dapp auf einem lokalen Multi-Client-Testnet entwickelt und testet
+description: Dieser Leitfaden führt Sie zunächst durch die Instanziierung und Konfiguration eines lokalen Multi-Client-Ethereum-Testnets, bevor Sie das Testnet zur Bereitstellung und zum Testen einer Dapp verwenden.
+author: "Tedi Mitiku"
+tags:
+ [
+ "Clients",
+ "Nodes",
+ "intelligente Verträge",
+ "Komponierbarkeit",
+ "Konsensebene",
+ "Ausführungsebene",
+ "testen"
+ ]
+skill: intermediate
+lang: de
+published: 2023-04-11
+---
+
+## Einführung {#introduction}
+
+Dieser Leitfaden führt Sie durch den Prozess der Instanziierung eines konfigurierbaren lokalen Ethereum-Testnets, der Bereitstellung eines Smart Contracts und der Verwendung des Testnets, um Tests mit Ihrer Dapp durchzuführen. Dieser Leitfaden richtet sich an Dapp-Entwickler, die ihre Dapps lokal mit verschiedenen Netzwerkkonfigurationen entwickeln und testen möchten, bevor sie sie auf einem Live-Testnet oder dem Mainnet bereitstellen.
+
+In diesem Leitfaden werden Sie:
+
+- Ein lokales Ethereum-Testnet mit dem [`eth-network-package`](https://github.com/kurtosis-tech/eth-network-package) unter Verwendung von [Kurtosis](https://www.kurtosis.com/) instanziieren,
+- Ihre Hardhat Dapp-Entwicklungsumgebung mit dem lokalen Testnet verbinden, um eine Dapp zu kompilieren, bereitzustellen und zu testen, und
+- Das lokale Testnet konfigurieren, einschließlich Parametern wie der Anzahl der Nodes und spezifischen EL/CL-Client-Paarungen, um Entwicklungs- und Test-Workflows für verschiedene Netzwerkkonfigurationen zu ermöglichen.
+
+### Was ist Kurtosis? {#what-is-kurtosis}
+
+[Kurtosis](https://www.kurtosis.com/) ist ein zusammensetzbares Build-System, das für die Konfiguration von Multi-Container-Testumgebungen entwickelt wurde. Es ermöglicht Entwicklern insbesondere, reproduzierbare Umgebungen zu erstellen, die eine dynamische Einrichtungslogik erfordern, wie zum Beispiel Blockchain-Testnets.
+
+In diesem Leitfaden startet das Kurtosis-eth-network-package ein lokales Ethereum-Testnet mit Unterstützung für den [`geth`](https://geth.ethereum.org/) Ausführungsebenen-Client (EL) sowie die [`teku`](https://consensys.io/teku), [`lighthouse`](https://lighthouse.sigmaprime.io/) und [`lodestar`](https://lodestar.chainsafe.io/) Konsensebenen-Clients (CL). Dieses Paket dient als eine konfigurierbare und zusammensetzbare Alternative zu Netzwerken in Frameworks wie Hardhat Network, Ganache und Anvil. Kurtosis bietet Entwicklern mehr Kontrolle und Flexibilität über die von ihnen verwendeten Testnets, was ein Hauptgrund dafür ist, dass die [Ethereum Foundation Kurtosis zum Testen des Merge verwendet hat](https://www.kurtosis.com/blog/testing-the-ethereum-merge) und es weiterhin zum Testen von Netzwerk-Upgrades verwendet.
+
+## Einrichten von Kurtosis {#setting-up-kurtosis}
+
+Bevor Sie fortfahren, stellen Sie sicher, dass Sie Folgendes haben:
+
+- [Die Docker-Engine auf Ihrem lokalen Rechner installiert und gestartet](https://docs.kurtosis.com/install/#i-install--start-docker)
+- [Die Kurtosis CLI installiert](https://docs.kurtosis.com/install#ii-install-the-cli) (oder auf die neueste Version aktualisiert, falls Sie die CLI bereits installiert haben)
+- [Node.js](https://nodejs.org/en), [yarn](https://classic.yarnpkg.com/lang/en/docs/install/#mac-stable) und [npx](https://www.npmjs.com/package/npx) installiert (für Ihre Dapp-Umgebung)
+
+## Ein lokales Ethereum-Testnet instanziieren {#instantiate-testnet}
+
+Um ein lokales Ethereum-Testnet zu starten, führen Sie Folgendes aus:
+
+```python
+kurtosis --enclave local-eth-testnet run github.com/kurtosis-tech/eth-network-package
+```
+
+Hinweis: Dieser Befehl benennt Ihr Netzwerk: \"local-eth-testnet\" über das `--enclave`-Flag.
+
+Kurtosis gibt die Schritte aus, die im Hintergrund durchgeführt werden, während es die Anweisungen interpretiert, validiert und ausführt. Am Ende sollten Sie eine Ausgabe sehen, die der folgenden ähnelt:
+
+```python
+INFO[2023-04-04T18:09:44-04:00] ======================================================
+INFO[2023-04-04T18:09:44-04:00] || Created enclave: local-eth-testnet ||
+INFO[2023-04-04T18:09:44-04:00] ======================================================
+Name: local-eth-testnet
+UUID: 39372d756ae8
+Status: RUNNING
+Creation Time: Tue, 04 Apr 2023 18:09:03 EDT
+
+========================================= Files Artifacts =========================================
+UUID Name
+d4085a064230 cl-genesis-data
+1c62cb792e4c el-genesis-data
+bd60489b73a7 genesis-generation-config-cl
+b2e593fe5228 genesis-generation-config-el
+d552a54acf78 geth-prefunded-keys
+5f7e661eb838 prysm-password
+054e7338bb59 validator-keystore-0
+
+========================================== User Services ==========================================
+UUID Name Ports Status
+e20f129ee0c5 cl-client-0-beacon http: 4000/tcp -> RUNNING
+ metrics: 5054/tcp ->
+ tcp-discovery: 9000/tcp -> 127.0.0.1:54263
+ udp-discovery: 9000/udp -> 127.0.0.1:60470
+a8b6c926cdb4 cl-client-0-validator http: 5042/tcp -> 127.0.0.1:54267 RUNNING
+ metrics: 5064/tcp ->
+d7b802f623e8 el-client-0 engine-rpc: 8551/tcp -> 127.0.0.1:54253 RUNNING
+ rpc: 8545/tcp -> 127.0.0.1:54251
+ tcp-discovery: 30303/tcp -> 127.0.0.1:54254
+ udp-discovery: 30303/udp -> 127.0.0.1:53834
+ ws: 8546/tcp -> 127.0.0.1:54252
+514a829c0a84 prelaunch-data-generator-1680646157905431468 STOPPED
+62bd62d0aa7a prelaunch-data-generator-1680646157915424301 STOPPED
+05e9619e0e90 prelaunch-data-generator-1680646157922872635 STOPPED
+
+```
+
+Herzlichen Glückwunsch! Sie haben Kurtosis verwendet, um ein lokales Ethereum-Testnet mit einem CL- (`lighthouse`) und einem EL-Client (`geth`) über Docker zu instanziieren.
+
+### Überprüfung {#review-instantiate-testnet}
+
+In diesem Abschnitt haben Sie einen Befehl ausgeführt, der Kurtosis anwies, das [remote auf GitHub gehostete `eth-network-package`](https://github.com/kurtosis-tech/eth-network-package) zu verwenden, um ein lokales Ethereum-Testnet innerhalb einer Kurtosis [Enclave](https://docs.kurtosis.com/advanced-concepts/enclaves/) zu starten. Innerhalb Ihrer Enklave finden Sie sowohl \"Datei-Artefakte\" als auch \"Benutzerdienste\".
+
+Die [Datei-Artefakte](https://docs.kurtosis.com/advanced-concepts/files-artifacts/) in Ihrer Enklave enthalten alle Daten, die generiert und verwendet werden, um die EL- und CL-Clients zu booten. Die Daten wurden mit dem `prelaunch-data-generator`-Dienst erstellt, der aus diesem [Docker-Image](https://github.com/ethpandaops/ethereum-genesis-generator) gebaut wurde
+
+Benutzerdienste zeigen alle containerisierten Dienste an, die in Ihrer Enklave betrieben werden. Sie werden feststellen, dass ein einzelner Node erstellt wurde, der sowohl einen EL-Client als auch einen CL-Client enthält.
+
+## Verbinden Sie Ihre Dapp-Entwicklungsumgebung mit dem lokalen Ethereum-Testnet {#connect-your-dapp}
+
+### Einrichten der Dapp-Entwicklungsumgebung {#set-up-dapp-env}
+
+Nachdem Sie nun ein laufendes lokales Testnet haben, können Sie Ihre Dapp-Entwicklungsumgebung mit Ihrem lokalen Testnet verbinden. In diesem Leitfaden wird das Hardhat-Framework verwendet, um eine Blackjack-Dapp auf Ihrem lokalen Testnet bereitzustellen.
+
+Um Ihre Dapp-Entwicklungsumgebung einzurichten, klonen Sie das Repository, das unsere Beispiel-Dapp enthält, und installieren Sie dessen Abhängigkeiten. Führen Sie dazu Folgendes aus:
+
+```python
+git clone https://github.com/kurtosis-tech/awesome-kurtosis.git && cd awesome-kurtosis/smart-contract-example && yarn
+```
+
+Der hier verwendete Ordner [smart-contract-example](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/smart-contract-example) enthält das typische Setup für einen Dapp-Entwickler, der das [Hardhat](https://hardhat.org/)-Framework verwendet:
+
+- [`contracts/`](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/smart-contract-example/contracts) enthält einige einfache Smart Contracts für eine Blackjack-Dapp
+- [`scripts/`](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/smart-contract-example/scripts) enthält ein Skript zur Bereitstellung eines Token-Vertrags in Ihrem lokalen Ethereum-Netzwerk
+- [`test/`](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/smart-contract-example/test) enthält einen einfachen .js-Test für Ihren Token-Vertrag, um zu bestätigen, dass für jeden Spieler in unserer Blackjack-Dapp 1000 gemintet wurden
+- [`hardhat.config.ts`](https://github.com/kurtosis-tech/awesome-kurtosis/blob/main/smart-contract-example/hardhat.config.ts) konfiguriert Ihr Hardhat-Setup
+
+### Hardhat für die Verwendung des lokalen Testnets konfigurieren {#configure-hardhat}
+
+Nachdem Ihre Dapp-Entwicklungsumgebung eingerichtet ist, verbinden Sie nun Hardhat, um das mit Kurtosis generierte lokale Ethereum-Testnet zu verwenden. Um dies zu erreichen, ersetzen Sie `<$YOUR_PORT>` in der `localnet`-Struktur in Ihrer `hardhat.config.ts`-Konfigurationsdatei mit dem Port der RPC-URI-Ausgabe eines beliebigen `el-client-`-Dienstes. In diesem Beispielfall wäre der Port `64248`. Ihr Port wird ein anderer sein.
+
+Beispiel in `hardhat.config.ts`:
+
+```js
+localnet: {
+url: 'http://127.0.0.1:<$YOUR_PORT>',// TODO: ERSETZEN SIE $YOUR_PORT DURCH DEN PORT EINER NODE-URI, DIE VOM ETH-NETZWERK-KURTOSIS-PAKET ERZEUGT WURDE
+
+// Dies sind private Schlüssel, die mit vorfinanzierten Testkonten verbunden sind, die vom eth-network-package erstellt wurden
+//
+accounts: [
+ "ef5177cd0b6b21c87db5a0bf35d4084a8a57a9d6a064f86d51ac85f2b873a4e2",
+ "48fcc39ae27a0e8bf0274021ae6ebd8fe4a0e12623d61464c498900b28feb567",
+ "7988b3a148716ff800414935b305436493e1f25237a2a03e5eebc343735e2f31",
+ "b3c409b6b0b3aa5e65ab2dc1930534608239a478106acf6f3d9178e9f9b00b35",
+ "df9bb6de5d3dc59595bcaa676397d837ff49441d211878c024eabda2cd067c9f",
+ "7da08f856b5956d40a72968f93396f6acff17193f013e8053f6fbb6c08c194d6",
+ ],
+},
+```
+
+Sobald Sie Ihre Datei gespeichert haben, ist Ihre Hardhat Dapp-Entwicklungsumgebung mit Ihrem lokalen Ethereum-Testnet verbunden! Sie können überprüfen, ob Ihr Testnet funktioniert, indem Sie Folgendes ausführen:
+
+```python
+npx hardhat balances --network localnet
+```
+
+Die Ausgabe sollte etwa so aussehen:
+
+```python
+0x878705ba3f8Bc32FCf7F4CAa1A35E72AF65CF766 has balance 10000000000000000000000000
+0x4E9A3d9D1cd2A2b2371b8b3F489aE72259886f1A has balance 10000000000000000000000000
+0xdF8466f277964Bb7a0FFD819403302C34DCD530A has balance 10000000000000000000000000
+0x5c613e39Fc0Ad91AfDA24587e6f52192d75FBA50 has balance 10000000000000000000000000
+0x375ae6107f8cC4cF34842B71C6F746a362Ad8EAc has balance 10000000000000000000000000
+0x1F6298457C5d76270325B724Da5d1953923a6B88 has balance 10000000000000000000000000
+```
+
+Dies bestätigt, dass Hardhat Ihr lokales Testnet verwendet und die vom `eth-network-package` erstellten vorfinanzierten Konten erkennt.
+
+### Ihre Dapp lokal bereitstellen und testen {#deploy-and-test-dapp}
+
+Nachdem die Dapp-Entwicklungsumgebung vollständig mit dem lokalen Ethereum-Testnet verbunden ist, können Sie nun Entwicklungs- und Test-Workflows für Ihre Dapp mit dem lokalen Testnet ausführen.
+
+Um den `ChipToken.sol`-Smart-Contract für lokales Prototyping und Entwicklung zu kompilieren und bereitzustellen, führen Sie Folgendes aus:
+
+```python
+npx hardhat compile
+npx hardhat run scripts/deploy.ts --network localnet
+```
+
+Die Ausgabe sollte etwa so aussehen:
+
+```python
+ChipToken deployed to: 0xAb2A01BC351770D09611Ac80f1DE076D56E0487d
+```
+
+Führen Sie nun den `simple.js`-Test für Ihre lokale Dapp aus, um zu bestätigen, dass für jeden Spieler in unserer Blackjack-Dapp 1000 gemintet wurden:
+
+Die Ausgabe sollte etwa so aussehen:
+
+```python
+npx hardhat test --network localnet
+```
+
+Die Ausgabe sollte etwa so aussehen:
+
+```python
+ChipToken
+ mint
+ ✔ sollte 1000 Chips für SPIELER EINS minten
+
+ 1 bestanden (654ms)
+```
+
+### Überprüfung {#review-dapp-workflows}
+
+An diesem Punkt haben Sie nun eine Dapp-Entwicklungsumgebung eingerichtet, sie mit einem von Kurtosis erstellten lokalen Ethereum-Netzwerk verbunden und einen einfachen Test für Ihre Dapp kompiliert, bereitgestellt und ausgeführt.
+
+Lassen Sie uns nun untersuchen, wie Sie das zugrunde liegende Netzwerk für das Testen unserer Dapps unter verschiedenen Netzwerkkonfigurationen konfigurieren können.
+
+## Konfigurieren des lokalen Ethereum-Testnets {#configure-testnet}
+
+### Ändern der Client-Konfigurationen und der Anzahl der Nodes {#configure-client-config-and-num-nodes}
+
+Ihr lokales Ethereum-Testnet kann so konfiguriert werden, dass es verschiedene EL- und CL-Client-Paare sowie eine unterschiedliche Anzahl von Nodes verwendet, je nach Szenario und spezifischer Netzwerkkonfiguration, die Sie entwickeln oder testen möchten. Das bedeutet, dass Sie nach der Einrichtung ein angepasstes lokales Testnet starten und damit dieselben Arbeitsabläufe (Bereitstellung, Tests usw.) ausführen können. unter verschiedenen Netzwerkkonfigurationen, um sicherzustellen, dass alles wie erwartet funktioniert. Um mehr über die anderen Parameter zu erfahren, die Sie ändern können, besuchen Sie diesen Link.
+
+Probieren Sie es aus! Sie können verschiedene Konfigurationsoptionen über eine JSON-Datei an das `eth-network-package` übergeben. Diese Netzwerkparameter-JSON-Datei stellt die spezifischen Konfigurationen bereit, die Kurtosis zum Einrichten des lokalen Ethereum-Netzwerks verwenden wird.
+
+Nehmen Sie die Standardkonfigurationsdatei und bearbeiten Sie sie, um drei Nodes mit unterschiedlichen EL/CL-Paaren zu starten:
+
+- Node 1 mit `geth`/`lighthouse`
+- Node 2 mit `geth`/`lodestar`
+- Node 3 mit `geth`/`teku`
+
+Diese Konfiguration erstellt ein heterogenes Netzwerk von Ethereum-Node-Implementierungen zum Testen Ihrer Dapp. Ihre Konfigurationsdatei sollte jetzt so aussehen:
+
+```yaml
+{
+ "participants":
+ [
+ {
+ "el_client_type": "geth",
+ "el_client_image": "",
+ "el_client_log_level": "",
+ "cl_client_type": "lighthouse",
+ "cl_client_image": "",
+ "cl_client_log_level": "",
+ "beacon_extra_params": [],
+ "el_extra_params": [],
+ "validator_extra_params": [],
+ "builder_network_params": null,
+ },
+ {
+ "el_client_type": "geth",
+ "el_client_image": "",
+ "el_client_log_level": "",
+ "cl_client_type": "lodestar",
+ "cl_client_image": "",
+ "cl_client_log_level": "",
+ "beacon_extra_params": [],
+ "el_extra_params": [],
+ "validator_extra_params": [],
+ "builder_network_params": null,
+ },
+ {
+ "el_client_type": "geth",
+ "el_client_image": "",
+ "el_client_log_level": "",
+ "cl_client_type": "teku",
+ "cl_client_image": "",
+ "cl_client_log_level": "",
+ "beacon_extra_params": [],
+ "el_extra_params": [],
+ "validator_extra_params": [],
+ "builder_network_params": null,
+ },
+ ],
+ "network_params":
+ {
+ "preregistered_validator_keys_mnemonic": "giant issue aisle success illegal bike spike question tent bar rely arctic volcano long crawl hungry vocal artwork sniff fantasy very lucky have athlete",
+ "num_validator_keys_per_node": 64,
+ "network_id": "3151908",
+ "deposit_contract_address": "0x4242424242424242424242424242424242424242",
+ "seconds_per_slot": 12,
+ "genesis_delay": 120,
+ "capella_fork_epoch": 5,
+ },
+}
+```
+
+Jede `participants`-Struktur entspricht einem Node im Netzwerk, sodass 3 `participants`-Strukturen Kurtosis anweisen, 3 Nodes in Ihrem Netzwerk zu starten. Jede `participants`-Struktur ermöglicht es Ihnen, das für diesen spezifischen Node verwendete EL- und CL-Paar anzugeben.
+
+Die `network_params`-Struktur konfiguriert die Netzwerkeinstellungen, die verwendet werden, um die Genesis-Dateien für jeden Node zu erstellen, sowie andere Einstellungen wie die Sekunden pro Slot des Netzwerks.
+
+Speichern Sie Ihre bearbeitete Parameterdatei in einem beliebigen Verzeichnis (im folgenden Beispiel wird sie auf dem Desktop gespeichert) und verwenden Sie sie dann, um Ihr Kurtosis-Paket auszuführen, indem Sie Folgendes ausführen:
+
+```python
+kurtosis clean -a && kurtosis run --enclave local-eth-testnet github.com/kurtosis-tech/eth-network-package "$(cat ~/eth-network-params.json)"
+```
+
+Hinweis: Der Befehl `kurtosis clean -a` wird hier verwendet, um Kurtosis anzuweisen, das alte Testnet und seinen Inhalt zu zerstören, bevor ein neues gestartet wird.
+
+Auch hier wird Kurtosis eine Weile arbeiten und die einzelnen Schritte ausgeben, die stattfinden. Schließlich sollte die Ausgabe etwa so aussehen:
+
+```python
+Starlark-Code erfolgreich ausgeführt. Keine Ausgabe zurückgegeben.
+INFO[2023-04-07T11:43:16-04:00] ==========================================================
+INFO[2023-04-07T11:43:16-04:00] || Created enclave: local-eth-testnet ||
+INFO[2023-04-07T11:43:16-04:00] ==========================================================
+Name: local-eth-testnet
+UUID: bef8c192008e
+Status: RUNNING
+Creation Time: Fri, 07 Apr 2023 11:41:58 EDT
+
+========================================= Files Artifacts =========================================
+UUID Name
+cc495a8e364a cl-genesis-data
+7033fcdb5471 el-genesis-data
+a3aef43fc738 genesis-generation-config-cl
+8e968005fc9d genesis-generation-config-el
+3182cca9d3cd geth-prefunded-keys
+8421166e234f prysm-password
+d9e6e8d44d99 validator-keystore-0
+23f5ba517394 validator-keystore-1
+4d28dea40b5c validator-keystore-2
+
+========================================== User Services ==========================================
+UUID Name Ports Status
+485e6fde55ae cl-client-0-beacon http: 4000/tcp -> http://127.0.0.1:65010 RUNNING
+ metrics: 5054/tcp -> http://127.0.0.1:65011
+ tcp-discovery: 9000/tcp -> 127.0.0.1:65012
+ udp-discovery: 9000/udp -> 127.0.0.1:54455
+73739bd158b2 cl-client-0-validator http: 5042/tcp -> 127.0.0.1:65016 RUNNING
+ metrics: 5064/tcp -> http://127.0.0.1:65017
+1b0a233cd011 cl-client-1-beacon http: 4000/tcp -> 127.0.0.1:65021 RUNNING
+ metrics: 8008/tcp -> 127.0.0.1:65023
+ tcp-discovery: 9000/tcp -> 127.0.0.1:65024
+ udp-discovery: 9000/udp -> 127.0.0.1:56031
+ validator-metrics: 5064/tcp -> 127.0.0.1:65022
+949b8220cd53 cl-client-1-validator http: 4000/tcp -> 127.0.0.1:65028 RUNNING
+ metrics: 8008/tcp -> 127.0.0.1:65030
+ tcp-discovery: 9000/tcp -> 127.0.0.1:65031
+ udp-discovery: 9000/udp -> 127.0.0.1:60784
+ validator-metrics: 5064/tcp -> 127.0.0.1:65029
+c34417bea5fa cl-client-2 http: 4000/tcp -> 127.0.0.1:65037 RUNNING
+ metrics: 8008/tcp -> 127.0.0.1:65035
+ tcp-discovery: 9000/tcp -> 127.0.0.1:65036
+ udp-discovery: 9000/udp -> 127.0.0.1:63581
+e19738e6329d el-client-0 engine-rpc: 8551/tcp -> 127.0.0.1:64986 RUNNING
+ rpc: 8545/tcp -> 127.0.0.1:64988
+ tcp-discovery: 30303/tcp -> 127.0.0.1:64987
+ udp-discovery: 30303/udp -> 127.0.0.1:55706
+ ws: 8546/tcp -> 127.0.0.1:64989
+e904687449d9 el-client-1 engine-rpc: 8551/tcp -> 127.0.0.1:64993 RUNNING
+ rpc: 8545/tcp -> 127.0.0.1:64995
+ tcp-discovery: 30303/tcp -> 127.0.0.1:64994
+ udp-discovery: 30303/udp -> 127.0.0.1:58096
+ ws: 8546/tcp -> 127.0.0.1:64996
+ad6f401126fa el-client-2 engine-rpc: 8551/tcp -> 127.0.0.1:65003 RUNNING
+ rpc: 8545/tcp -> 127.0.0.1:65001
+ tcp-discovery: 30303/tcp -> 127.0.0.1:65000
+ udp-discovery: 30303/udp -> 127.0.0.1:57269
+ ws: 8546/tcp -> 127.0.0.1:65002
+12d04a9dbb69 prelaunch-data-generator-1680882122181135513 STOPPED
+5b45f9c0504b prelaunch-data-generator-1680882122192182847 STOPPED
+3d4aaa75e218 prelaunch-data-generator-1680882122201668972 STOPPED
+```
+
+Herzlichen Glückwunsch! Sie haben Ihr lokales Testnet erfolgreich so konfiguriert, dass es 3 Nodes anstelle von 1 hat. Um dieselben Arbeitsabläufe wie zuvor mit Ihrer Dapp auszuführen (Bereitstellen und Testen), führen Sie dieselben Operationen wie zuvor durch, indem Sie `<$YOUR_PORT>` in der `localnet`-Struktur Ihrer `hardhat.config.ts`-Konfigurationsdatei durch den Port der RPC-URI-Ausgabe eines beliebigen `el-client-`-Dienstes in Ihrem neuen, 3-Node-lokalen Testnet ersetzen.
+
+## Fazit {#conclusion}
+
+Und das war's! Zusammenfassend haben Sie in diesem kurzen Leitfaden:
+
+- Ein lokales Ethereum-Testnet über Docker mit Kurtosis erstellt
+- Ihre lokale Dapp-Entwicklungsumgebung mit dem lokalen Ethereum-Netzwerk verbunden
+- Eine Dapp bereitgestellt und einen einfachen Test darauf im lokalen Ethereum-Netzwerk ausgeführt
+- Das zugrunde liegende Ethereum-Netzwerk so konfiguriert, dass es 3 Nodes hat
+
+Wir würden uns freuen, von Ihnen zu hören, was für Sie gut gelaufen ist, was verbessert werden könnte, oder Ihre Fragen zu beantworten. Zögern Sie nicht, uns über [GitHub](https://github.com/kurtosis-tech/kurtosis/issues/new/choose) oder per [E-Mail](mailto:feedback@kurtosistech.com) zu kontaktieren!
+
+### Weitere Beispiele und Anleitungen {#other-examples-guides}
+
+Wir empfehlen Ihnen, unseren [Quickstart](https://docs.kurtosis.com/quickstart) (wo Sie eine Postgres-Datenbank und eine API darauf aufbauen) und unsere anderen Beispiele in unserem [awesome-kurtosis Repository](https://github.com/kurtosis-tech/awesome-kurtosis) anzusehen, wo Sie einige großartige Beispiele finden, einschließlich Paketen für:
+
+- [Starten desselben lokalen Ethereum-Testnets](https://github.com/kurtosis-tech/eth2-package), aber mit zusätzlichen verbundenen Diensten wie einem Transaktions-Spammer (um Transaktionen zu simulieren), einem Fork-Monitor und einer verbundenen Grafana- und Prometheus-Instanz
+- Durchführen eines [Sub-Networking-Tests](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/ethereum-network-partition-test) gegen dasselbe lokale Ethereum-Netzwerk
diff --git a/public/content/translations/de/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/index.md b/public/content/translations/de/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/index.md
new file mode 100644
index 00000000000..351c5e2f29c
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/index.md
@@ -0,0 +1,144 @@
+---
+title: "Verträge verkleinern, um die Vertragsgrößenbeschränkung zu bekämpfen"
+description: Was kannst du tun, um zu verhindern, dass deine Smart Contracts zu groß werden?
+author: Markus Waas
+lang: de
+tags: [ "solidity", "intelligente Verträge", "Speicher" ]
+skill: intermediate
+published: 2020-06-26
+source: soliditydeveloper.com
+sourceUrl: https://soliditydeveloper.com/max-contract-size
+---
+
+## Warum gibt es ein Limit? {#why-is-there-a-limit}
+
+Am [22. November 2016](https://blog.ethereum.org/2016/11/18/hard-fork-no-4-spurious-dragon/) wurde mit dem Spurious Dragon Hard-Fork [EIP-170](https://eips.ethereum.org/EIPS/eip-170) ein Größenlimit von 24.576 kB für Smart Contracts eingeführt. Für dich als Solidity-Entwickler bedeutet dies: Wenn du deinem Vertrag immer mehr Funktionalität hinzufügst, wirst du irgendwann das Limit erreichen und beim Deployment folgenden Fehler sehen:
+
+`Warning: Contract code size exceeds 24576 bytes (a limit introduced in Spurious Dragon). This contract may not be deployable on Mainnet. Consider enabling the optimizer (with a low "runs" value!), turning off revert strings, or using libraries.`
+
+Dieses Limit wurde eingeführt, um Denial-of-Service-Angriffe (DOS) zu verhindern. Jeder Aufruf eines Vertrags ist in Bezug auf das Gas relativ günstig. Die Auswirkung eines Vertragsaufrufs für Ethereum-Nodes steigt jedoch in Abhängigkeit von der Größe des aufgerufenen Vertragscodes unverhältnismäßig an (Lesen des Codes von der Festplatte, Vorverarbeitung des Codes, Hinzufügen von Daten zum Merkle-Proof). Immer wenn eine Situation vorliegt, in der der Angreifer nur wenige Ressourcen benötigt, um anderen viel Arbeit zu verursachen, besteht die Gefahr von DOS-Angriffen.
+
+Ursprünglich war dies kein so großes Problem, da eine natürliche Begrenzung der Vertragsgröße das Block-Gaslimit ist. Ein Vertrag muss natürlich innerhalb einer Transaktion bereitgestellt werden, die den gesamten Bytecode des Vertrags enthält. Wenn du nur diese eine Transaktion in einen Block aufnimmst, kannst du das gesamte Gas verbrauchen, aber es ist nicht unendlich. Seit dem [London-Upgrade](/ethereum-forks/#london) kann das Block-Gaslimit je nach Netzwerkauslastung zwischen 15 und 30 Millionen Einheiten variieren.
+
+Im Folgenden werden wir uns einige Methoden ansehen, geordnet nach ihrer potenziellen Auswirkung. Stell es dir wie beim Abnehmen vor. Die beste Strategie, um das Zielgewicht zu erreichen (in unserem Fall 24 kB), ist, sich zuerst auf die Methoden mit der größten Wirkung zu konzentrieren. In den meisten Fällen reicht eine Ernährungsumstellung aus, um dieses Ziel zu erreichen, aber manchmal braucht man ein bisschen mehr. Dann könntest du etwas Sport (mittlere Auswirkung) oder sogar Nahrungsergänzungsmittel (geringe Auswirkung) hinzufügen.
+
+## Große Auswirkung {#big-impact}
+
+### Trenne deine Verträge {#separate-your-contracts}
+
+Das sollte immer dein erster Ansatz sein. Wie kannst du den Vertrag in mehrere kleinere aufteilen? Im Allgemeinen zwingt dich das, eine gute Architektur für deine Verträge zu entwickeln. Kleinere Verträge sind aus Sicht der Code-Lesbarkeit immer zu bevorzugen. Stell dir beim Aufteilen von Verträgen folgende Fragen:
+
+- Welche Funktionen gehören zusammen? Jede Gruppe von Funktionen ist möglicherweise in einem eigenen Vertrag am besten aufgehoben.
+- Welche Funktionen erfordern nicht das Lesen des Vertragszustands oder nur einer bestimmten Teilmenge des Zustands?
+- Kannst du Speicher und Funktionalität trennen?
+
+### Bibliotheken {#libraries}
+
+Eine einfache Möglichkeit, den Funktionalitätscode vom Speicher zu trennen, ist die Verwendung einer [Bibliothek](https://solidity.readthedocs.io/en/v0.6.10/contracts.html#libraries). Deklariere die Bibliotheksfunktionen nicht als „internal“, da diese während der Kompilierung direkt [zum Vertrag hinzugefügt](https://ethereum.stackexchange.com/questions/12975/are-internal-functions-in-libraries-not-covered-by-linking) werden. Wenn du aber „public“-Funktionen verwendest, befinden sich diese tatsächlich in einem separaten Bibliotheksvertrag. Erwäge die Verwendung von „[using for](https://solidity.readthedocs.io/en/v0.6.10/contracts.html#using-for)“, um die Nutzung von Bibliotheken komfortabler zu gestalten.
+
+### Proxys {#proxies}
+
+Eine fortgeschrittenere Strategie wäre ein Proxysystem. Bibliotheken verwenden im Hintergrund `DELEGATECALL`, was einfach die Funktion eines anderen Vertrags mit dem Zustand des aufrufenden Vertrags ausführt. In [diesem Blogbeitrag](https://hackernoon.com/how-to-make-smart-contracts-upgradable-2612e771d5a2) erfährst du mehr über Proxysysteme. Sie bieten dir mehr Funktionalität, z. B. ermöglichen sie die Upgradefähigkeit, aber sie fügen auch eine Menge Komplexität hinzu. Ich würde sie nicht nur zur Reduzierung der Vertragsgröße hinzufügen, es sei denn, es ist aus irgendeinem Grund deine einzige Option.
+
+## Mittlere Auswirkung {#medium-impact}
+
+### Funktionen entfernen {#remove-functions}
+
+Das sollte selbsterklärend sein. Funktionen vergrößern einen Vertrag erheblich.
+
+- **External**: Oft fügen wir aus Bequemlichkeitsgründen viele Ansichtsfunktionen hinzu. Das ist völlig in Ordnung, bis du an das Größenlimit stößt. Dann solltest du wirklich darüber nachdenken, alle bis auf die absolut notwendigen zu entfernen.
+- **Internal**: Du kannst auch interne/private Funktionen entfernen und den Code einfach inline einfügen, solange die Funktion nur einmal aufgerufen wird.
+
+### Vermeide zusätzliche Variablen {#avoid-additional-variables}
+
+```solidity
+function get(uint id) returns (address,address) {
+ MyStruct memory myStruct = myStructs[id];
+ return (myStruct.addr1, myStruct.addr2);
+}
+```
+
+```solidity
+function get(uint id) returns (address,address) {
+ return (myStructs[id].addr1, myStructs[id].addr2);
+}
+```
+
+Eine einfache Änderung wie diese macht einen Unterschied von **0,28 kB** aus. Wahrscheinlich findest du viele ähnliche Situationen in deinen Verträgen, und diese können sich wirklich zu erheblichen Mengen summieren.
+
+### Fehlermeldungen kürzen {#shorten-error-message}
+
+Lange „revert“-Meldungen und insbesondere viele verschiedene „revert“-Meldungen können den Vertrag aufblähen. Verwende stattdessen kurze Fehlercodes und dekodiere sie in deinem Vertrag. Eine lange Meldung könnte viel kürzer werden:
+
+```solidity
+require(msg.sender == owner, "Nur der Besitzer dieses Vertrags kann diese Funktion aufrufen");
+```
+
+```solidity
+require(msg.sender == owner, "OW1");
+```
+
+### Verwende benutzerdefinierte Fehler anstelle von Fehlermeldungen
+
+Benutzerdefinierte Fehler wurden in [Solidity 0.8.4](https://blog.soliditylang.org/2021/04/21/custom-errors/) eingeführt. Sie sind eine großartige Möglichkeit, die Größe deiner Verträge zu reduzieren, da sie als Selektoren ABI-kodiert werden (genau wie Funktionen).
+
+```solidity
+error Unauthorized();
+
+if (msg.sender != owner) {
+ revert Unauthorized();
+}
+```
+
+### Ziehe einen niedrigen „run“-Wert im Optimizer in Betracht {#consider-a-low-run-value-in-the-optimizer}
+
+Du kannst auch die Optimizer-Einstellungen ändern. Der Standardwert von 200 bedeutet, dass er versucht, den Bytecode so zu optimieren, als ob eine Funktion 200 Mal aufgerufen würde. Wenn du ihn auf 1 änderst, weist du den Optimizer im Grunde an, für den Fall zu optimieren, dass jede Funktion nur einmal ausgeführt wird. Eine für die einmalige Ausführung optimierte Funktion bedeutet, dass sie für die Bereitstellung selbst optimiert ist. Beachte, dass **dies die [Gaskosten](/developers/docs/gas/) für die Ausführung der Funktionen erhöht**, also möchtest du das vielleicht nicht tun.
+
+## Geringe Auswirkung {#small-impact}
+
+### Vermeide die Übergabe von Structs an Funktionen {#avoid-passing-structs-to-functions}
+
+Wenn du den [ABIEncoderV2](https://solidity.readthedocs.io/en/v0.6.10/layout-of-source-files.html#abiencoderv2) verwendest, kann es helfen, keine Structs an eine Funktion zu übergeben. Anstatt den Parameter als Struct zu übergeben, übergib die erforderlichen Parameter direkt. In diesem Beispiel haben wir weitere **0,1 kB** gespart.
+
+```solidity
+function get(uint id) returns (address,address) {
+ return _get(myStruct);
+}
+
+function _get(MyStruct memory myStruct) private view returns(address,address) {
+ return (myStruct.addr1, myStruct.addr2);
+}
+```
+
+```solidity
+function get(uint id) returns(address,address) {
+ return _get(myStructs[id].addr1, myStructs[id].addr2);
+}
+
+function _get(address addr1, address addr2) private view returns(address,address) {
+ return (addr1, addr2);
+}
+```
+
+### Korrekte Sichtbarkeit für Funktionen und Variablen deklarieren {#declare-correct-visibility-for-functions-and-variables}
+
+- Funktionen oder Variablen, die nur von außen aufgerufen werden? Deklariere sie als `external` anstatt `public`.
+- Funktionen oder Variablen, die nur innerhalb des Vertrags aufgerufen werden? Deklariere sie als `private` oder `internal` anstatt `public`.
+
+### Modifier entfernen {#remove-modifiers}
+
+Modifier können, insbesondere bei intensiver Nutzung, einen erheblichen Einfluss auf die Vertragsgröße haben. Erwäge, sie zu entfernen und stattdessen Funktionen zu verwenden.
+
+```solidity
+modifier checkStuff() {}
+
+function doSomething() checkStuff {}
+```
+
+```solidity
+function checkStuff() private {}
+
+function doSomething() { checkStuff(); }
+```
+
+Diese Tipps sollten dir helfen, die Vertragsgröße erheblich zu reduzieren. Noch einmal, ich kann nicht genug betonen: Konzentriere dich immer auf die Aufteilung von Verträgen, wenn möglich, um die größte Wirkung zu erzielen.
diff --git a/public/content/translations/de/developers/tutorials/eip-1271-smart-contract-signatures/index.md b/public/content/translations/de/developers/tutorials/eip-1271-smart-contract-signatures/index.md
new file mode 100644
index 00000000000..699fe68e374
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/eip-1271-smart-contract-signatures/index.md
@@ -0,0 +1,129 @@
+---
+title: "EIP-1271: Signieren und Verifizieren von Smart-Contract-Signaturen"
+description: Ein Überblick über die Erstellung und Verifizierung von Smart-Contract-Signaturen mit EIP-1271. Wir gehen auch die in Safe (ehemals Gnosis Safe) verwendete EIP-1271-Implementierung durch, um Smart-Contract-Entwicklern ein konkretes Beispiel zu geben, auf dem sie aufbauen können.
+author: Nathan H. Leung
+lang: de
+tags:
+ [
+ "eip-1271",
+ "Smart Contracts",
+ "verifizieren",
+ "Signieren"
+ ]
+skill: intermediate
+published: 2023-01-12
+---
+
+Der [EIP-1271](https://eips.ethereum.org/EIPS/eip-1271)-Standard ermöglicht es Smart Contracts, Signaturen zu verifizieren.
+
+In diesem Tutorial geben wir einen Überblick über digitale Signaturen, den Hintergrund von EIP-1271 und die spezifische Implementierung von EIP-1271, die von [Safe](https://safe.global/) (ehemals Gnosis Safe) verwendet wird. Alles in allem kann dies als Ausgangspunkt für die Implementierung von EIP-1271 in Ihren eigenen Contracts dienen.
+
+## Was ist eine Signatur?
+
+In diesem Kontext ist eine Signatur (genauer gesagt, eine „digitale Signatur“) eine Nachricht plus eine Art Beweis dafür, dass die Nachricht von einer bestimmten Person/einem bestimmten Absender/einer bestimmten Adresse stammt.
+
+Eine digitale Signatur könnte zum Beispiel so aussehen:
+
+1. Nachricht: „Ich möchte mich mit meiner Ethereum-Wallet auf dieser Website anmelden.“
+2. Unterzeichner: Meine Adresse lautet `0x000…`
+3. Beweis: Hier ist ein Beweis dafür, dass ich, `0x000…`, diese gesamte Nachricht tatsächlich erstellt habe (dies ist normalerweise etwas Kryptografisches).
+
+Es ist wichtig zu beachten, dass eine digitale Signatur sowohl eine „Nachricht“ als auch eine „Signatur“ enthält.
+
+Warum? Wenn Sie mir zum Beispiel einen Vertrag zum Unterschreiben geben würden und ich dann die Unterschriftenseite abschneiden und Ihnen nur meine Unterschriften ohne den Rest des Vertrags zurückgeben würde, wäre der Vertrag nicht gültig.
+
+Genauso bedeutet eine digitale Signatur ohne eine zugehörige Nachricht nichts!
+
+## Warum gibt es EIP-1271?
+
+Um eine digitale Signatur für die Verwendung auf Ethereum-basierten Blockchains zu erstellen, benötigen Sie im Allgemeinen einen geheimen privaten Schlüssel, den niemand sonst kennt. Das ist es, was Ihre Signatur zu Ihrer macht (niemand sonst kann dieselbe Signatur ohne Kenntnis des geheimen Schlüssels erstellen).
+
+Ihr Ethereum-Konto (d.h. Ihr extern verwaltetes Konto/EOA) hat einen damit verbundenen privaten Schlüssel, und das ist der private Schlüssel, der normalerweise verwendet wird, wenn eine Website oder eine Dapp Sie um eine Signatur bittet (z. B. für „Mit Ethereum anmelden“).
+
+Eine App kann eine von Ihnen erstellte [Signatur verifizieren](https://www.alchemy.com/docs/how-to-verify-a-message-signature-on-ethereum) und dabei eine Drittanbieter-Bibliothek wie ethers.js verwenden, [ohne Ihren privaten Schlüssel zu kennen](https://en.wikipedia.org/wiki/Public-key_cryptography), und darauf vertrauen, dass _Sie_ derjenige waren, der die Signatur erstellt hat.
+
+> Tatsächlich können digitale EOA-Signaturen, da sie Public-Key-Kryptografie verwenden, **off-chain** generiert und verifiziert werden! So funktioniert die gaslose DAO-Abstimmung — anstatt die Stimmen on-chain abzugeben, können digitale Signaturen mithilfe kryptografischer Bibliotheken off-chain erstellt und verifiziert werden.
+
+Während EOA-Konten einen privaten Schlüssel haben, haben Smart-Contract-Konten keinerlei privaten oder geheimen Schlüssel (daher kann „Mit Ethereum anmelden“ usw. nicht nativ mit Smart-Contract-Konten funktionieren).
+
+Das Problem, das EIP-1271 zu lösen versucht: Wie können wir feststellen, ob eine Smart-Contract-Signatur gültig ist, wenn der Smart Contract kein „Geheimnis“ hat, das er in die Signatur einbauen kann?
+
+## Wie funktioniert EIP-1271?
+
+Smart Contracts haben keine privaten Schlüssel, die zum Signieren von Nachrichten verwendet werden können. Wie können wir also feststellen, ob eine Signatur authentisch ist?
+
+Nun, eine Idee ist, dass wir den Smart Contract einfach _fragen_ können, ob eine Signatur authentisch ist!
+
+EIP-1271 standardisiert die Idee, einen Smart Contract zu „fragen“, ob eine bestimmte Signatur gültig ist.
+
+Ein Contract, der EIP-1271 implementiert, muss eine Funktion namens `isValidSignature` haben, die eine Nachricht und eine Signatur entgegennimmt. Der Contract kann dann eine Validierungslogik ausführen (die Spezifikation schreibt hier nichts Bestimmtes vor) und dann einen Wert zurückgeben, der angibt, ob die Signatur gültig ist oder nicht.
+
+Wenn `isValidSignature` ein gültiges Ergebnis zurückgibt, bedeutet das so viel wie, dass der Contract sagt: „Ja, ich genehmige diese Signatur + Nachricht!“
+
+### Schnittstelle
+
+Hier ist die genaue Schnittstelle in der EIP-1271-Spezifikation (wir werden weiter unten auf den `_hash`-Parameter eingehen, aber stellen Sie ihn sich vorerst als die zu verifizierende Nachricht vor):
+
+```jsx
+pragma solidity ^0.5.0;
+
+contract ERC1271 {
+
+ // bytes4(keccak256("isValidSignature(bytes32,bytes)")
+ bytes4 constant internal MAGICVALUE = 0x1626ba7e;
+
+ /**
+ * @dev Sollte zurückgeben, ob die bereitgestellte Signatur für den bereitgestellten Hash gültig ist
+ * @param _hash Hash der zu signierenden Daten
+ * @param _signature Signatur-Byte-Array, das mit _hash verknüpft ist
+ *
+ * MUSS den magischen Wert bytes4 0x1626ba7e zurückgeben, wenn die Funktion erfolgreich ist.
+ * DARF den Zustand NICHT ändern (Verwendung von STATICCALL für solc < 0.5, view-Modifikator für solc > 0.5)
+ * MUSS externe Aufrufe zulassen
+ */
+ function isValidSignature(
+ bytes32 _hash,
+ bytes memory _signature)
+ public
+ view
+ returns (bytes4 magicValue);
+}
+```
+
+## Beispiel für eine EIP-1271-Implementierung: Safe
+
+Contracts können `isValidSignature` auf viele Arten implementieren — die Spezifikation sagt nicht viel über die genaue Implementierung aus.
+
+Ein bemerkenswerter Contract, der EIP-1271 implementiert, ist Safe (ehemals Gnosis Safe).
+
+Im Code von Safe ist `isValidSignature` [so implementiert](https://github.com/safe-global/safe-contracts/blob/main/contracts/handler/CompatibilityFallbackHandler.sol), dass Signaturen auf [zwei Arten](https://ethereum.stackexchange.com/questions/122635/signing-messages-as-a-gnosis-safe-eip1271-support) erstellt und verifiziert werden können:
+
+1. On-Chain-Nachrichten
+ 1. Erstellung: Ein Safe-Besitzer erstellt eine neue Safe-Transaktion, um eine Nachricht zu „signieren“, und übergibt die Nachricht als Daten in die Transaktion. Sobald genügend Besitzer die Transaktion unterzeichnet haben, um den Multisig-Schwellenwert zu erreichen, wird die Transaktion gesendet und ausgeführt. In der Transaktion gibt es eine Safe-Funktion namens (`signMessage(bytes calldata _data)`), die die Nachricht zu einer Liste „genehmigter“ Nachrichten hinzufügt.
+ 2. Verifizierung: Rufen Sie `isValidSignature` auf dem Safe-Contract auf und übergeben Sie die zu verifizierende Nachricht als Nachrichtenparameter und [einen leeren Wert für den Signaturparameter](https://github.com/safe-global/safe-contracts/blob/main/contracts/handler/CompatibilityFallbackHandler.sol#L32) (d. h. `0x`). Der Safe wird sehen, dass der Signaturparameter leer ist, und anstatt die Signatur kryptografisch zu verifizieren, wird er einfach prüfen, ob sich die Nachricht auf der Liste der „genehmigten“ Nachrichten befindet.
+2. Off-Chain-Nachrichten:
+ 1. Erstellung: Ein Safe-Besitzer erstellt eine Nachricht off-chain und lässt dann andere Safe-Besitzer die Nachricht einzeln signieren, bis genügend Signaturen vorhanden sind, um den Multisig-Genehmigungsschwellenwert zu erreichen.
+ 2. Verifizierung: `isValidSignature` aufrufen. Übergeben Sie im Nachrichtenparameter die zu verifizierende Nachricht. Übergeben Sie im Signaturparameter die einzelnen Signaturen jedes Safe-Besitzers aneinandergereiht. Der Safe prüft, ob genügend Signaturen vorhanden sind, um den Schwellenwert zu erreichen, **und** ob jede Signatur gültig ist. Wenn ja, gibt er einen Wert zurück, der eine erfolgreiche Signaturverifizierung anzeigt.
+
+## Was genau ist der `_hash`-Parameter? Warum nicht die ganze Nachricht übergeben?
+
+Sie haben vielleicht bemerkt, dass die Funktion `isValidSignature` in der [EIP-1271-Schnittstelle](https://eips.ethereum.org/EIPS/eip-1271) nicht die Nachricht selbst, sondern einen `_hash`-Parameter entgegennimmt. Das bedeutet, dass wir anstelle der vollständigen Nachricht beliebiger Länge an `isValidSignature` einen 32-Byte-Hash der Nachricht (im Allgemeinen keccak256) übergeben.
+
+Jedes Byte Calldata — d. h. Funktionsparameterdaten, die an eine Smart-Contract-Funktion übergeben werden — [kostet 16 Gas (4 Gas bei einem Null-Byte)](https://eips.ethereum.org/EIPS/eip-2028), sodass viel Gas gespart werden kann, wenn eine Nachricht lang ist.
+
+### Frühere EIP-1271-Spezifikationen
+
+Es gibt EIP-1271-Spezifikationen, die eine `isValidSignature`-Funktion mit einem ersten Parameter vom Typ `bytes` (beliebige Länge anstelle einer festen Länge von `bytes32`) und dem Parameternamen `message` haben. Dies ist eine [ältere Version](https://github.com/safe-global/safe-contracts/issues/391#issuecomment-1075427206) des EIP-1271-Standards.
+
+## Wie sollte EIP-1271 in meinen eigenen Contracts implementiert werden?
+
+Die Spezifikation ist hier sehr offen. Die Safe-Implementierung hat einige gute Ideen:
+
+- Sie können EOA-Signaturen vom „Besitzer“ des Contracts als gültig betrachten.
+- Sie könnten eine Liste genehmigter Nachrichten speichern und nur diese als gültig betrachten.
+
+Letztendlich liegt es an Ihnen als Contract-Entwickler!
+
+## Zusammenfassung
+
+[EIP-1271](https://eips.ethereum.org/EIPS/eip-1271) ist ein vielseitiger Standard, der es Smart Contracts ermöglicht, Signaturen zu verifizieren. Es öffnet Smart Contracts die Tür, sich mehr wie EOAs zu verhalten – indem es beispielsweise eine Möglichkeit bietet, dass „Mit Ethereum anmelden“ mit Smart Contracts funktioniert – und es kann auf viele Arten implementiert werden (Safe bietet eine nichttriviale und interessante Implementierung, die man in Betracht ziehen sollte).
diff --git a/public/content/translations/de/developers/tutorials/erc-721-vyper-annotated-code/index.md b/public/content/translations/de/developers/tutorials/erc-721-vyper-annotated-code/index.md
new file mode 100644
index 00000000000..d5b05da914f
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/erc-721-vyper-annotated-code/index.md
@@ -0,0 +1,715 @@
+---
+title: "Vyper ERC-721 Vertrags-Komplettlösung"
+description: Ryuya Nakamuras ERC-721-Vertrag und wie er funktioniert
+author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+lang: de
+tags: [ "vyper", "erc-721", "Python" ]
+skill: beginner
+published: 2021-04-01
+---
+
+## Einführung {#introduction}
+
+Der [ERC-721](/developers/docs/standards/tokens/erc-721/)-Standard wird verwendet, um das Eigentum an nicht-fungiblen Token (NFT) zu halten.
+[ERC-20](/developers/docs/standards/tokens/erc-20/)-Token verhalten sich wie ein Rohstoff, da es keinen Unterschied zwischen den einzelnen Token gibt.
+Im Gegensatz dazu sind ERC-721-Token für Vermögenswerte konzipiert, die ähnlich, aber nicht identisch sind, wie zum Beispiel verschiedene Katzen-
+Cartoons
+oder Titel für verschiedene Immobilien.
+
+In diesem Artikel analysieren wir [Ryuya Nakamuras ERC-721-Vertrag](https://github.com/vyperlang/vyper/blob/master/examples/tokens/ERC721.vy).
+Dieser Vertrag ist in [Vyper](https://vyper.readthedocs.io/en/latest/index.html) geschrieben, einer Python-ähnlichen Vertragssprache, die so konzipiert ist, dass es
+schwieriger ist, unsicheren Code zu schreiben, als in Solidity.
+
+## Der Vertrag {#contract}
+
+```python
+# @dev Implementierung des ERC-721-Standards für nicht-fungible Token.
+# @author Ryuya Nakamura (@nrryuya)
+# Modifiziert von: https://github.com/vyperlang/vyper/blob/de74722bf2d8718cca46902be165f9fe0e3641dd/examples/tokens/ERC721.vy
+```
+
+Kommentare in Vyper beginnen, wie in Python, mit einem Hash (`#`) und gehen bis zum Ende der Zeile. Kommentare, die
+`@` enthalten, werden von [NatSpec](https://vyper.readthedocs.io/en/latest/natspec.html) verwendet, um für Menschen lesbare
+Dokumentationen zu erstellen.
+
+```python
+from vyper.interfaces import ERC721
+
+implements: ERC721
+```
+
+Die ERC-721-Schnittstelle ist in die Vyper-Sprache integriert.
+[Die Code-Definition können Sie hier einsehen](https://github.com/vyperlang/vyper/blob/master/vyper/builtin_interfaces/ERC721.py).
+Die Schnittstellendefinition ist in Python und nicht in Vyper geschrieben, da Schnittstellen nicht nur innerhalb der
+Blockchain verwendet werden, sondern auch beim Senden einer Transaktion von einem externen Client an die Blockchain, der in
+Python geschrieben sein kann.
+
+Die erste Zeile importiert die Schnittstelle und die zweite gibt an, dass wir sie hier implementieren.
+
+### Die ERC721Receiver-Schnittstelle {#receiver-interface}
+
+```python
+# Schnittstelle für den von safeTransferFrom() aufgerufenen Vertrag
+interface ERC721Receiver:
+ def onERC721Received(
+```
+
+ERC-721 unterstützt zwei Arten von Übertragungen:
+
+- `transferFrom`, bei dem der Absender eine beliebige Zieladresse angeben kann und die Verantwortung
+ für die Übertragung beim Absender liegt. Das bedeutet, dass Sie an eine ungültige Adresse übertragen können. In diesem Fall
+ ist der NFT für immer verloren.
+- `safeTransferFrom`, das prüft, ob die Zieladresse ein Vertrag ist. Wenn ja, fragt der ERC-721-Vertrag
+ den empfangenden Vertrag, ob er den NFT empfangen möchte.
+
+Um `safeTransferFrom`-Anfragen zu beantworten, muss ein empfangender Vertrag `ERC721Receiver` implementieren.
+
+```python
+ _operator: address,
+ _from: address,
+```
+
+Die `_from`-Adresse ist der aktuelle Eigentümer des Tokens. Die `_operator`-Adresse ist diejenige, die
+die Übertragung angefordert hat (diese beiden können aufgrund von Freigaben unterschiedlich sein).
+
+```python
+ _tokenId: uint256,
+```
+
+ERC-721-Token-IDs sind 256 Bit lang. Typischerweise werden sie durch Hashing einer Beschreibung von dem erstellt, was
+der Token darstellt.
+
+```python
+ _data: Bytes[1024]
+```
+
+Die Anfrage kann bis zu 1024 Bytes an Benutzerdaten enthalten.
+
+```python
+ ) -> bytes32: view
+```
+
+Um zu verhindern, dass ein Vertrag versehentlich eine Übertragung akzeptiert, ist der Rückgabewert kein boolescher Wert,
+sondern 256 Bit mit einem bestimmten Wert.
+
+Diese Funktion ist eine `view`, was bedeutet, dass sie den Zustand der Blockchain lesen, aber nicht verändern kann.
+
+### Ereignisse {#events}
+
+[Ereignisse](https://media.consensys.net/technical-introduction-to-events-and-logs-in-ethereum-a074d65dd61e)
+werden ausgelöst, um Benutzer und Server außerhalb der Blockchain über Ereignisse zu informieren. Beachten Sie, dass der Inhalt von Ereignissen
+für Verträge auf der Blockchain nicht verfügbar ist.
+
+```python
+# @dev Wird ausgelöst, wenn sich der Besitz eines NFTs durch einen beliebigen Mechanismus ändert. Dieses Ereignis wird ausgelöst, wenn NFTs
+# erstellt (`from` == 0) und zerstört (`to` == 0) werden. Ausnahme: während der Vertragserstellung kann eine beliebige
+# Anzahl von NFTs erstellt und zugewiesen werden, ohne dass ein Transfer ausgelöst wird. Zum Zeitpunkt einer
+# Übertragung wird die genehmigte Adresse für diesen NFT (falls vorhanden) auf keine zurückgesetzt.
+# @param _from Absender des NFT (wenn die Adresse eine Null-Adresse ist, bedeutet das die Erstellung eines Tokens).
+# @param _to Empfänger des NFT (wenn die Adresse eine Null-Adresse ist, bedeutet das die Zerstörung des Tokens).
+# @param _tokenId Der NFT, der übertragen wurde.
+event Transfer:
+ sender: indexed(address)
+ receiver: indexed(address)
+ tokenId: indexed(uint256)
+```
+
+Dies ist ähnlich wie beim ERC-20-Transfer-Ereignis, außer dass wir eine `tokenId` anstelle eines Betrags melden.
+Niemand besitzt die Adresse Null, daher verwenden wir sie konventionsgemäß, um die Erstellung und Zerstörung von Token zu melden.
+
+```python
+# @dev Dies wird ausgelöst, wenn die genehmigte Adresse für einen NFT geändert oder erneut bestätigt wird. Die Null-
+# Adresse zeigt an, dass es keine genehmigte Adresse gibt. Wenn ein Transfer-Ereignis ausgelöst wird, zeigt dies auch an
+# , dass die genehmigte Adresse für diesen NFT (falls vorhanden) auf keine zurückgesetzt wird.
+# @param _owner Eigentümer des NFT.
+# @param _approved Adresse, die wir genehmigen.
+# @param _tokenId NFT, den wir genehmigen.
+event Approval:
+ owner: indexed(address)
+ approved: indexed(address)
+ tokenId: indexed(uint256)
+```
+
+Eine ERC-721-Genehmigung ist ähnlich wie eine ERC-20-Freigabe. Eine bestimmte Adresse darf einen bestimmten
+Token übertragen. Dies gibt Verträgen einen Mechanismus, um zu reagieren, wenn sie einen Token annehmen. Verträge können nicht
+auf Ereignisse lauschen, wenn Sie also nur den Token an sie übertragen, „wissen“ sie nichts davon. Auf diese Weise reicht der
+Eigentümer zunächst eine Genehmigung ein und sendet dann eine Anfrage an den Vertrag: „Ich habe Ihnen die Genehmigung erteilt, den Token
+X zu übertragen, bitte tun Sie ...“.
+
+Dies ist eine Designentscheidung, um den ERC-721-Standard dem ERC-20-Standard ähnlich zu machen. Da
+ERC-721-Token nicht fungibel sind, kann ein Vertrag auch erkennen, dass er einen bestimmten Token erhalten hat, indem er sich den Besitz des Tokens
+ansieht.
+
+```python
+# @dev Dies wird ausgelöst, wenn ein Betreiber für einen Eigentümer aktiviert oder deaktiviert wird. Der Betreiber kann alle NFTs des Eigentümers verwalten.
+#
+# @param _owner Eigentümer des NFT.
+# @param _operator Adresse, für die wir Betreiberrechte festlegen.
+# @param _approved Status der Betreiberrechte (true, wenn Betreiberrechte erteilt werden, und false, wenn sie
+# widerrufen werden).
+event ApprovalForAll:
+ owner: indexed(address)
+ operator: indexed(address)
+ approved: bool
+```
+
+Manchmal ist es nützlich, einen _Betreiber_ zu haben, der alle Token eines Kontos von einem bestimmten Typ verwalten kann (diejenigen, die von
+einem bestimmten Vertrag verwaltet werden), ähnlich wie eine Vollmacht. Zum Beispiel könnte ich einem Vertrag eine solche Vollmacht erteilen, der prüft, ob
+ich ihn sechs Monate lang nicht kontaktiert habe, und wenn ja, mein Vermögen an meine Erben verteilt (wenn einer von ihnen danach fragt, können Verträge
+nichts tun, ohne durch eine Transaktion aufgerufen zu werden). Bei ERC-20 können wir einem Erbvertrag einfach eine hohe Freigabe erteilen,
+aber das funktioniert bei ERC-721 nicht, da die Token nicht fungibel sind. Dies ist das Äquivalent.
+
+Der `approved`-Wert teilt uns mit, ob das Ereignis eine Genehmigung oder den Widerruf einer Genehmigung betrifft.
+
+### Zustandsvariablen {#state-vars}
+
+Diese Variablen enthalten den aktuellen Zustand der Token: welche verfügbar sind und wem sie gehören. Die meisten davon
+sind `HashMap`-Objekte, [unidirektionale Zuordnungen, die zwischen zwei Typen bestehen](https://vyper.readthedocs.io/en/latest/types.html#mappings).
+
+```python
+# @dev Zuordnung von der NFT-ID zur Adresse, der sie gehört.
+idToOwner: HashMap[uint256, address]
+
+# @dev Zuordnung von der NFT-ID zur genehmigten Adresse.
+idToApprovals: HashMap[uint256, address]
+```
+
+Benutzer- und Vertragsidentitäten in Ethereum werden durch 160-Bit-Adressen dargestellt. Diese beiden Variablen bilden
+Token-IDs auf ihre Eigentümer und diejenigen ab, die für ihre Übertragung genehmigt sind (maximal einer für jeden). In Ethereum
+sind nicht initialisierte Daten immer null. Wenn es also keinen Eigentümer oder genehmigten Überträger gibt, ist der Wert für diesen Token
+null.
+
+```python
+# @dev Zuordnung von der Eigentümeradresse zur Anzahl seiner Token.
+ownerToNFTokenCount: HashMap[address, uint256]
+```
+
+Diese Variable enthält die Anzahl der Token für jeden Eigentümer. Es gibt keine Zuordnung von Eigentümern zu Token, daher
+ist der einzige Weg, die Token zu identifizieren, die einem bestimmten Eigentümer gehören, der Blick zurück in die Ereignishistorie der Blockchain,
+um die entsprechenden `Transfer`-Ereignisse zu sehen. Wir können diese Variable verwenden, um zu wissen, wann wir alle NFTs haben und nicht
+noch weiter in die Vergangenheit blicken müssen.
+
+Beachten Sie, dass dieser Algorithmus nur für Benutzeroberflächen und externe Server funktioniert. Code, der auf der Blockchain
+selbst läuft, kann vergangene Ereignisse nicht lesen.
+
+```python
+# @dev Zuordnung von der Eigentümeradresse zur Zuordnung von Betreiberadressen.
+ownerToOperators: HashMap[address, HashMap[address, bool]]
+```
+
+Ein Konto kann mehr als einen Betreiber haben. Eine einfache `HashMap` reicht nicht aus, um
+sie zu verfolgen, da jeder Schlüssel zu einem einzigen Wert führt. Stattdessen können Sie
+`HashMap[address, bool]` als Wert verwenden. Standardmäßig ist der Wert für jede Adresse `False`, was bedeutet, dass sie
+kein Betreiber ist. Sie können die Werte bei Bedarf auf `True` setzen.
+
+```python
+# @dev Adresse des Minters, der einen Token prägen kann
+minter: address
+```
+
+Neue Token müssen irgendwie erstellt werden. In diesem Vertrag gibt es eine einzige Entität, die dazu berechtigt ist, der
+`minter`. Dies ist zum Beispiel für ein Spiel wahrscheinlich ausreichend. Für andere Zwecke könnte es notwendig sein,
+eine kompliziertere Geschäftslogik zu erstellen.
+
+```python
+# @dev Zuordnung der Schnittstellen-ID zu bool, ob sie unterstützt wird oder nicht
+supportedInterfaces: HashMap[bytes32, bool]
+
+# @dev ERC165-Schnittstellen-ID von ERC165
+ERC165_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000001ffc9a7
+
+# @dev ERC165-Schnittstellen-ID von ERC721
+ERC721_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000080ac58cd
+```
+
+[ERC-165](https://eips.ethereum.org/EIPS/eip-165) spezifiziert einen Mechanismus für einen Vertrag, um offenzulegen, wie Anwendungen
+mit ihm kommunizieren können und welchen ERCs er entspricht. In diesem Fall entspricht der Vertrag ERC-165 und ERC-721.
+
+### Funktionen {#functions}
+
+Dies sind die Funktionen, die ERC-721 tatsächlich implementieren.
+
+#### Konstruktor {#constructor}
+
+```python
+@external
+def __init__():
+```
+
+In Vyper, wie in Python, heißt die Konstruktorfunktion `__init__`.
+
+```python
+ """
+ @dev Vertragskonstruktor.
+ """
+```
+
+In Python und in Vyper können Sie auch einen Kommentar erstellen, indem Sie eine mehrzeilige Zeichenfolge (die mit `"""` beginnt und endet
+) angeben und sie in keiner Weise verwenden. Diese Kommentare können auch
+[NatSpec](https://vyper.readthedocs.io/en/latest/natspec.html) enthalten.
+
+```python
+ self.supportedInterfaces[ERC165_INTERFACE_ID] = True
+ self.supportedInterfaces[ERC721_INTERFACE_ID] = True
+ self.minter = msg.sender
+```
+
+Um auf Zustandsvariablen zuzugreifen, verwenden Sie \`self.\`\` (wiederum, wie in Python).
+
+#### View-Funktionen {#views}
+
+Dies sind Funktionen, die den Zustand der Blockchain nicht verändern und daher
+kostenlos ausgeführt werden können, wenn sie extern aufgerufen werden. Wenn die View-Funktionen von einem Vertrag aufgerufen werden, müssen sie dennoch auf
+jedem Node ausgeführt werden und kosten daher Gas.
+
+```python
+@view
+@external
+```
+
+Diese Schlüsselwörter vor einer Funktionsdefinition, die mit einem At-Zeichen (`@`) beginnen, werden als _Dekorationen_ bezeichnet. Sie
+geben die Umstände an, unter denen eine Funktion aufgerufen werden kann.
+
+- `@view` gibt an, dass diese Funktion eine `view` ist.
+- `@external` gibt an, dass diese spezielle Funktion durch Transaktionen und von anderen Verträgen aufgerufen werden kann.
+
+```python
+def supportsInterface(_interfaceID: bytes32) -> bool:
+```
+
+Im Gegensatz zu Python ist Vyper eine [statisch typisierte Sprache](https://wikipedia.org/wiki/Type_system#Static_type_checking).
+Sie können keine Variable oder einen Funktionsparameter deklarieren, ohne den [Datentyp](https://vyper.readthedocs.io/en/latest/types.html) anzugeben. In diesem Fall ist der Eingabeparameter `bytes32`, ein 256-Bit-Wert
+(256 Bit ist die native Wortgröße der [Ethereum Virtual Machine](/developers/docs/evm/)). Die Ausgabe ist ein boolescher
+Wert. Konventionsgemäß beginnen die Namen von Funktionsparametern mit einem Unterstrich (`_`).
+
+```python
+ """
+ @dev Die Schnittstellenidentifikation ist in ERC-165 spezifiziert.
+ @param _interfaceID ID der Schnittstelle
+ """
+ return self.supportedInterfaces[_interfaceID]
+```
+
+Gibt den Wert aus der `self.supportedInterfaces`-HashMap zurück, der im Konstruktor (`__init__`) gesetzt wird.
+
+```python
+### VIEW-FUNKTIONEN ###
+```
+
+Dies sind die View-Funktionen, die Informationen über die Token für Benutzer und andere Verträge verfügbar machen.
+
+```python
+@view
+@external
+def balanceOf(_owner: address) -> uint256:
+ """
+ @dev Gibt die Anzahl der NFTs zurück, die `_owner` besitzt.
+ Löst einen Fehler aus, wenn `_owner` die Null-Adresse ist. NFTs, die der Null-Adresse zugewiesen sind, werden als ungültig betrachtet.
+ @param _owner Adresse, für die das Guthaben abgefragt werden soll.
+ """
+ assert _owner != ZERO_ADDRESS
+```
+
+Diese Zeile [stellt sicher](https://vyper.readthedocs.io/en/latest/statements.html#assert), dass `_owner` nicht
+Null ist. Wenn doch, gibt es einen Fehler und die Operation wird rückgängig gemacht.
+
+```python
+ return self.ownerToNFTokenCount[_owner]
+
+@view
+@external
+def ownerOf(_tokenId: uint256) -> address:
+ """
+ @dev Gibt die Adresse des Besitzers des NFT zurück.
+ Löst einen Fehler aus, wenn `_tokenId` kein gültiger NFT ist.
+ @param _tokenId Der Bezeichner für einen NFT.
+ """
+ owner: address = self.idToOwner[_tokenId]
+ # Löst einen Fehler aus, wenn `_tokenId` kein gültiger NFT ist
+ assert owner != ZERO_ADDRESS
+ return owner
+```
+
+In der Ethereum Virtual Machine (EVM) ist jeder Speicher, in dem kein Wert gespeichert ist, null.
+Wenn es keinen Token bei `_tokenId` gibt, dann ist der Wert von `self.idToOwner[_tokenId]` null. In diesem
+Fall wird die Funktion zurückgesetzt.
+
+```python
+@view
+@external
+def getApproved(_tokenId: uint256) -> address:
+ """
+ @dev Holt die genehmigte Adresse für einen einzelnen NFT.
+ Löst einen Fehler aus, wenn `_tokenId` kein gültiger NFT ist.
+ @param _tokenId ID des NFT, dessen Genehmigung abgefragt werden soll.
+ """
+ # Löst einen Fehler aus, wenn `_tokenId` kein gültiger NFT ist
+ assert self.idToOwner[_tokenId] != ZERO_ADDRESS
+ return self.idToApprovals[_tokenId]
+```
+
+Beachten Sie, dass `getApproved` null zurückgeben _kann_. Wenn der Token gültig ist, gibt er `self.idToApprovals[_tokenId]` zurück.
+Wenn es keinen Genehmiger gibt, ist dieser Wert null.
+
+```python
+@view
+@external
+def isApprovedForAll(_owner: address, _operator: address) -> bool:
+ """
+ @dev Prüft, ob `_operator` ein zugelassener Betreiber für `_owner` ist.
+ @param _owner Die Adresse, der die NFTs gehören.
+ @param _operator Die Adresse, die im Namen des Eigentümers handelt.
+ """
+ return (self.ownerToOperators[_owner])[_operator]
+```
+
+Diese Funktion prüft, ob `_operator` berechtigt ist, alle Token von `_owner` in diesem Vertrag zu verwalten.
+Da es mehrere Operatoren geben kann, ist dies eine zweistufige HashMap.
+
+#### Transfer-Hilfsfunktionen {#transfer-helpers}
+
+Diese Funktionen implementieren Operationen, die Teil der Übertragung oder Verwaltung von Token sind.
+
+```python
+
+### HILFSFUNKTIONEN FÜR DIE ÜBERTRAGUNG ###
+
+@view
+@internal
+```
+
+Diese Dekoration, `@internal`, bedeutet, dass die Funktion nur von anderen Funktionen innerhalb desselben
+Vertrags aus zugänglich ist. Konventionsgemäß beginnen diese Funktionsnamen ebenfalls mit einem Unterstrich (`_`).
+
+```python
+def _isApprovedOrOwner(_spender: address, _tokenId: uint256) -> bool:
+ """
+ @dev Gibt zurück, ob der angegebene Spender eine gegebene Token-ID übertragen kann
+ @param spender Adresse des abzufragenden Spenders
+ @param tokenId uint256 ID des zu übertragenden Tokens
+ @return bool, ob der msg.sender für die angegebene Token-ID genehmigt ist,
+ ein Betreiber des Eigentümers oder der Eigentümer des Tokens ist
+ """
+ owner: address = self.idToOwner[_tokenId]
+ spenderIsOwner: bool = owner == _spender
+ spenderIsApproved: bool = _spender == self.idToApprovals[_tokenId]
+ spenderIsApprovedForAll: bool = (self.ownerToOperators[owner])[_spender]
+ return (spenderIsOwner or spenderIsApproved) or spenderIsApprovedForAll
+```
+
+Es gibt drei Möglichkeiten, wie eine Adresse zur Übertragung eines Tokens berechtigt sein kann:
+
+1. Die Adresse ist der Eigentümer des Tokens
+2. Die Adresse ist für die Ausgabe dieses Tokens zugelassen
+3. Die Adresse ist ein Operator für den Eigentümer des Tokens
+
+Die obige Funktion kann eine `view` sein, da sie den Zustand nicht ändert. Um die Betriebskosten zu senken, sollte jede
+Funktion, die eine `view` sein _kann_, auch eine `view` _sein_.
+
+```python
+@internal
+def _addTokenTo(_to: address, _tokenId: uint256):
+ """
+ @dev Einen NFT zu einer bestimmten Adresse hinzufügen
+ Löst einen Fehler aus, wenn `_tokenId` jemandem gehört.
+ """
+ # Löst einen Fehler aus, wenn `_tokenId` jemandem gehört
+ assert self.idToOwner[_tokenId] == ZERO_ADDRESS
+ # Den Besitzer wechseln
+ self.idToOwner[_tokenId] = _to
+ # Zählverfolgung ändern
+ self.ownerToNFTokenCount[_to] += 1
+
+
+@internal
+def _removeTokenFrom(_from: address, _tokenId: uint256):
+ """
+ @dev Entfernen eines NFT von einer bestimmten Adresse
+ Löst einen Fehler aus, wenn `_from` nicht der aktuelle Besitzer ist.
+ """
+ # Löst einen Fehler aus, wenn `_from` nicht der aktuelle Besitzer ist
+ assert self.idToOwner[_tokenId] == _from
+ # Den Besitzer wechseln
+ self.idToOwner[_tokenId] = ZERO_ADDRESS
+ # Zählverfolgung ändern
+ self.ownerToNFTokenCount[_from] -= 1
+```
+
+Wenn es ein Problem mit einer Übertragung gibt, machen wir den Aufruf rückgängig.
+
+```python
+@internal
+def _clearApproval(_owner: address, _tokenId: uint256):
+ """
+ @dev Löschen einer Genehmigung für eine bestimmte Adresse
+ Löst einen Fehler aus, wenn `_owner` nicht der aktuelle Besitzer ist.
+ """
+ # Löst einen Fehler aus, wenn `_owner` nicht der aktuelle Besitzer ist
+ assert self.idToOwner[_tokenId] == _owner
+ if self.idToApprovals[_tokenId] != ZERO_ADDRESS:
+ # Genehmigungen zurücksetzen
+ self.idToApprovals[_tokenId] = ZERO_ADDRESS
+```
+
+Ändern Sie den Wert nur, wenn es nötig ist. Zustandsvariablen leben im Speicher. Das Schreiben in den Speicher ist
+eine der teuersten Operationen, die die EVM (Ethereum Virtual Machine) durchführt (in Bezug auf
+[Gas](/developers/docs/gas/)). Daher ist es eine gute Idee, dies zu minimieren, denn selbst das Schreiben des
+vorhandenen Wertes hat hohe Kosten.
+
+```python
+@internal
+def _transferFrom(_from: address, _to: address, _tokenId: uint256, _sender: address):
+ """
+ @dev Führt die Übertragung eines NFT aus.
+ Löst eine Ausnahme aus, es sei denn, `msg.sender` ist der aktuelle Eigentümer, ein autorisierter Betreiber oder die genehmigte
+ Adresse für diesen NFT. (HINWEIS: `msg.sender` ist in einer privaten Funktion nicht erlaubt, also `_sender` übergeben.)
+ Löst eine Ausnahme aus, wenn `_to` die Null-Adresse ist.
+ Löst eine Ausnahme aus, wenn `_from` nicht der aktuelle Eigentümer ist.
+ Löst eine Ausnahme aus, wenn `_tokenId` kein gültiger NFT ist.
+ """
+```
+
+Wir haben diese interne Funktion, weil es zwei Möglichkeiten gibt, Token zu übertragen (regulär und sicher), aber
+wir wollen nur eine einzige Stelle im Code, an der wir dies tun, um die Prüfung zu erleichtern.
+
+```python
+ # Anforderungen prüfen
+ assert self._isApprovedOrOwner(_sender, _tokenId)
+ # Löst einen Fehler aus, wenn `_to` die Null-Adresse ist
+ assert _to != ZERO_ADDRESS
+ # Genehmigung löschen. Löst einen Fehler aus, wenn `_from` nicht der aktuelle Besitzer ist
+ self._clearApproval(_from, _tokenId)
+ # NFT entfernen. Löst einen Fehler aus, wenn `_tokenId` kein gültiger NFT ist
+ self._removeTokenFrom(_from, _tokenId)
+ # NFT hinzufügen
+ self._addTokenTo(_to, _tokenId)
+ # Die Übertragung protokollieren
+ log Transfer(_from, _to, _tokenId)
+```
+
+Um ein Ereignis in Vyper auszulösen, verwenden Sie eine `log`-Anweisung ([siehe hier für weitere Details](https://vyper.readthedocs.io/en/latest/event-logging.html#event-logging)).
+
+#### Transfer-Funktionen {#transfer-funs}
+
+```python
+
+### TRANSFER-FUNKTIONEN ###
+
+@external
+def transferFrom(_from: address, _to: address, _tokenId: uint256):
+ """
+ @dev Löst einen Fehler aus, es sei denn `msg.sender` ist der aktuelle Eigentümer, ein autorisierter Betreiber oder die genehmigte
+ Adresse für diesen NFT.
+ Löst einen Fehler aus, wenn `_from` nicht der aktuelle Eigentümer ist.
+ Löst einen Fehler aus, wenn `_to` die Null-Adresse ist.
+ Löst einen Fehler aus, wenn `_tokenId` kein gültiger NFT ist.
+ @notice Der Aufrufer ist dafür verantwortlich zu bestätigen, dass `_to` in der Lage ist, NFTs zu empfangen, andernfalls
+ können sie dauerhaft verloren gehen.
+ @param _from Der aktuelle Eigentümer des NFT.
+ @param _to Der neue Eigentümer.
+ @param _tokenId Der zu übertragende NFT.
+ """
+ self._transferFrom(_from, _to, _tokenId, msg.sender)
+```
+
+Mit dieser Funktion können Sie an eine beliebige Adresse übertragen. Sofern die Adresse nicht einem Benutzer oder einem Vertrag gehört, der
+weiß, wie man Token überträgt, wird jeder Token, den Sie übertragen, an dieser Adresse hängen bleiben und unbrauchbar sein.
+
+```python
+@external
+def safeTransferFrom(
+ _from: address,
+ _to: address,
+ _tokenId: uint256,
+ _data: Bytes[1024]=b""
+ ):
+ """
+ @dev Überträgt das Eigentum an einem NFT von einer Adresse an eine andere.
+ Löst eine Ausnahme aus, es sei denn `msg.sender` ist der aktuelle Eigentümer, ein autorisierter Betreiber oder die
+ genehmigte Adresse für diesen NFT.
+ Löst eine Ausnahme aus, wenn `_from` nicht der aktuelle Eigentümer ist.
+ Löst eine Ausnahme aus, wenn `_to` die Null-Adresse ist.
+ Löst eine Ausnahme aus, wenn `_tokenId` kein gültiger NFT ist.
+ Wenn `_to` ein Smart Contract ist, ruft es `onERC721Received` auf `_to` auf und löst einen Fehler aus, wenn
+ der Rückgabewert nicht `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` ist.
+ HINWEIS: bytes4 wird durch bytes32 mit Padding dargestellt
+ @param _from Der aktuelle Eigentümer des NFT.
+ @param _to Der neue Eigentümer.
+ @param _tokenId Der zu übertragende NFT.
+ @param _data Zusätzliche Daten ohne spezifiziertes Format, die im Aufruf an `_to` gesendet werden.
+ """
+ self._transferFrom(_from, _to, _tokenId, msg.sender)
+```
+
+Es ist in Ordnung, die Übertragung zuerst durchzuführen, denn wenn es ein Problem gibt, werden wir es sowieso rückgängig machen,
+so dass alles, was in dem Aufruf getan wird, abgebrochen wird.
+
+```python
+ if _to.is_contract: # prüfen, ob `_to` eine Vertragsadresse ist
+```
+
+Prüfen Sie zunächst, ob die Adresse ein Vertrag ist (ob sie Code enthält). Wenn nicht, gehen Sie davon aus, dass es sich um eine Benutzeradresse
+handelt und der Benutzer den Token verwenden oder übertragen kann. Aber lassen Sie sich nicht
+in falscher Sicherheit wiegen. Sie können Token auch mit `safeTransferFrom` verlieren, wenn Sie sie
+an eine Adresse übertragen, für die niemand den privaten Schlüssel kennt.
+
+```python
+ returnValue: bytes32 = ERC721Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data)
+```
+
+Rufen Sie den Zielvertrag auf, um zu sehen, ob er ERC-721-Token empfangen kann.
+
+```python
+ # Löst einen Fehler aus, wenn das Übertragungsziel ein Vertrag ist, der 'onERC721Received' nicht implementiert
+ assert returnValue == method_id("onERC721Received(address,address,uint256,bytes)", output_type=bytes32)
+```
+
+Wenn das Ziel ein Vertrag ist, der aber keine ERC-721-Token akzeptiert (oder der sich entschieden hat, diese
+besondere Übertragung nicht zu akzeptieren), wird die Aktion rückgängig gemacht.
+
+```python
+@external
+def approve(_approved: address, _tokenId: uint256):
+ """
+ @dev Legt die genehmigte Adresse für einen NFT fest oder bestätigt sie erneut. Die Null-Adresse gibt an, dass es keine genehmigte Adresse gibt.
+ Löst einen Fehler aus, es sei denn `msg.sender` ist der aktuelle NFT-Eigentümer oder ein autorisierter Betreiber des aktuellen Eigentümers.
+ Löst einen Fehler aus, wenn `_tokenId` kein gültiger NFT ist. (HINWEIS: Dies ist nicht im EIP geschrieben)
+ Löst einen Fehler aus, wenn `_approved` der aktuelle Eigentümer ist. (HINWEIS: Dies ist nicht im EIP geschrieben)
+ @param _approved Adresse, die für die angegebene NFT-ID genehmigt werden soll.
+ @param _tokenId ID des zu genehmigenden Tokens.
+ """
+ owner: address = self.idToOwner[_tokenId]
+ # Löst einen Fehler aus, wenn `_tokenId` kein gültiger NFT ist
+ assert owner != ZERO_ADDRESS
+ # Löst einen Fehler aus, wenn `_approved` der aktuelle Eigentümer ist
+ assert _approved != owner
+```
+
+Wenn Sie konventionsgemäß keinen Genehmiger haben wollen, ernennen Sie die Null-Adresse, nicht sich selbst.
+
+```python
+ # Anforderungen prüfen
+ senderIsOwner: bool = self.idToOwner[_tokenId] == msg.sender
+ senderIsApprovedForAll: bool = (self.ownerToOperators[owner])[msg.sender]
+ assert (senderIsOwner or senderIsApprovedForAll)
+```
+
+Um eine Genehmigung zu erteilen, können Sie entweder der Eigentümer sein oder ein vom Eigentümer autorisierter Betreiber.
+
+```python
+ # Die Genehmigung festlegen
+ self.idToApprovals[_tokenId] = _approved
+ log Approval(owner, _approved, _tokenId)
+
+
+@external
+def setApprovalForAll(_operator: address, _approved: bool):
+ """
+ @dev Aktiviert oder deaktiviert die Genehmigung für einen Dritten ("Betreiber"), alle
+ Vermögenswerte von `msg.sender` zu verwalten. Es löst auch das ApprovalForAll-Ereignis aus.
+ Löst einen Fehler aus, wenn `_operator` der `msg.sender` ist. (HINWEIS: Dies ist nicht im EIP geschrieben)
+ @notice Dies funktioniert auch, wenn der Absender zu diesem Zeitpunkt keine Token besitzt.
+ @param _operator Adresse, die zum Satz der autorisierten Betreiber hinzugefügt werden soll.
+ @param _approved True, wenn die Betreiber genehmigt sind, false, um die Genehmigung zu widerrufen.
+ """
+ # Löst einen Fehler aus, wenn `_operator` der `msg.sender` ist
+ assert _operator != msg.sender
+ self.ownerToOperators[msg.sender][_operator] = _approved
+ log ApprovalForAll(msg.sender, _operator, _approved)
+```
+
+#### Neue Token prägen und bestehende zerstören {#mint-burn}
+
+Das Konto, das den Vertrag erstellt hat, ist der `minter`, der Superuser, der berechtigt ist, neue
+NFTs zu prägen. Jedoch ist es ihm nicht erlaubt, bestehende Token zu verbrennen. Nur der Eigentümer oder eine vom Eigentümer
+autorisierte Entität kann dies tun.
+
+```python
+### PRÄGE- & VERBRENNUNGSFUNKTIONEN ###
+
+@external
+def mint(_to: address, _tokenId: uint256) -> bool:
+```
+
+Diese Funktion gibt immer `True` zurück, denn wenn die Operation fehlschlägt, wird sie rückgängig gemacht.
+
+```python
+ """
+ @dev Funktion zum Prägen von Token
+ Löst einen Fehler aus, wenn `msg.sender` nicht der Minter ist.
+ Löst einen Fehler aus, wenn `_to` die Null-Adresse ist.
+ Löst einen Fehler aus, wenn `_tokenId` jemandem gehört.
+ @param _to Die Adresse, die die geprägten Token erhalten wird.
+ @param _tokenId Die zu prägende Token-ID.
+ @return Ein boolescher Wert, der angibt, ob die Operation erfolgreich war.
+ """
+ # Löst einen Fehler aus, wenn `msg.sender` nicht der Minter ist
+ assert msg.sender == self.minter
+```
+
+Nur der Minter (das Konto, das den ERC-721-Vertrag erstellt hat) kann neue Token prägen. Dies kann in der Zukunft ein
+Problem sein, wenn wir die Identität des Minters ändern wollen. In
+einem Produktionsvertrag würden Sie wahrscheinlich eine Funktion wollen, die es dem Minter erlaubt, Minter-Privilegien
+an jemand anderen zu übertragen.
+
+```python
+ # Löst einen Fehler aus, wenn `_to` die Null-Adresse ist
+ assert _to != ZERO_ADDRESS
+ # NFT hinzufügen. Löst einen Fehler aus, wenn `_tokenId` jemandem gehört
+ self._addTokenTo(_to, _tokenId)
+ log Transfer(ZERO_ADDRESS, _to, _tokenId)
+ return True
+```
+
+Konventionsgemäß zählt das Prägen neuer Token als Übertragung von der Adresse Null.
+
+```python
+
+@external
+def burn(_tokenId: uint256):
+ """
+ @dev Verbrennt einen bestimmten ERC721-Token.
+ Löst einen Fehler aus, es sei denn `msg.sender` ist der aktuelle Eigentümer, ein autorisierter Betreiber oder die genehmigte
+ Adresse für diesen NFT.
+ Löst einen Fehler aus, wenn `_tokenId` kein gültiger NFT ist.
+ @param _tokenId uint256 ID des zu verbrennenden ERC721-Tokens.
+ """
+ # Anforderungen prüfen
+ assert self._isApprovedOrOwner(msg.sender, _tokenId)
+ owner: address = self.idToOwner[_tokenId]
+ # Löst einen Fehler aus, wenn `_tokenId` kein gültiger NFT ist
+ assert owner != ZERO_ADDRESS
+ self._clearApproval(owner, _tokenId)
+ self._removeTokenFrom(owner, _tokenId)
+ log Transfer(owner, ZERO_ADDRESS, _tokenId)
+```
+
+Jeder, der berechtigt ist, einen Token zu übertragen, darf ihn auch verbrennen. Während ein Verbrennen einer Übertragung
+an die Null-Adresse gleichkommt, empfängt die Null-Adresse den Token nicht tatsächlich. Dies ermöglicht es uns,
+den gesamten Speicher freizugeben, der für den Token verwendet wurde, was die Gaskosten der Transaktion reduzieren kann.
+
+## Verwendung dieses Vertrags {#using-contract}
+
+Im Gegensatz zu Solidity hat Vyper keine Vererbung. Dies ist eine bewusste Designentscheidung, um den
+Code klarer und damit leichter zu sichern. Um also Ihren eigenen Vyper ERC-721-Vertrag zu erstellen, nehmen Sie diesen
+Vertrag und modifizieren Sie ihn,
+um die gewünschte Geschäftslogik zu implementieren.
+
+## Fazit {#conclusion}
+
+Zur Wiederholung hier einige der wichtigsten Ideen in diesem Vertrag:
+
+- Um ERC-721-Token mit einer sicheren Übertragung zu empfangen, müssen Verträge die `ERC721Receiver`-Schnittstelle implementieren.
+- Auch wenn Sie eine sichere Übertragung verwenden, können Token immer noch stecken bleiben, wenn Sie sie an eine Adresse senden, deren privater Schlüssel
+ unbekannt ist.
+- Wenn es ein Problem mit einer Operation gibt, ist es eine gute Idee, den Aufruf `rückgängig zu machen`, anstatt nur
+ einen Fehlerwert zurückzugeben.
+- ERC-721-Token existieren, wenn sie einen Besitzer haben.
+- Es gibt drei Möglichkeiten, zur Übertragung eines NFT autorisiert zu sein. Sie können der Eigentümer sein, für einen bestimmten Token zugelassen sein
+ oder ein Betreiber für alle Token des Eigentümers sein.
+- Vergangene Ereignisse sind nur außerhalb der Blockchain sichtbar. Code, der innerhalb der Blockchain ausgeführt wird, kann sie nicht anzeigen.
+
+Gehen Sie nun hin und implementieren Sie sichere Vyper-Verträge.
+
+[Hier finden Sie mehr von meiner Arbeit](https://cryptodocguy.pro/).
+
diff --git a/public/content/translations/de/developers/tutorials/erc20-annotated-code/index.md b/public/content/translations/de/developers/tutorials/erc20-annotated-code/index.md
new file mode 100644
index 00000000000..ec47cfb8494
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/erc20-annotated-code/index.md
@@ -0,0 +1,930 @@
+---
+title: "ERC-20-Vertrag – exemplarische Vorgehensweise"
+description: Was beinhaltet der OpenZeppelin ERC-20-Vertrag und warum ist er da?
+author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+lang: de
+tags: [ "solidity", "Erc-20" ]
+skill: beginner
+published: 2021-03-09
+---
+
+## Einführung {#introduction}
+
+Eine der häufigsten Anwendungen von Ethereum ist die Schaffung eines handelbaren Tokens durch eine Gruppe, der gewissermaßen ihre eigene Währung darstellt. Diese Token folgen typischerweise einem Standard,
+[ERC-20](/developers/docs/standards/tokens/erc-20/). Dieser Standard ermöglicht es, Tools wie Liquiditätspools und Wallets zu entwickeln, die mit allen ERC-20-
+Token funktionieren. In diesem Artikel analysieren wir die
+[OpenZeppelin Solidity ERC20-Implementierung](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol) sowie die
+[Interface-Definition](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol).
+
+Dies ist kommentierter Quellcode. Wenn Sie ERC-20 implementieren möchten,
+[lesen Sie dieses Tutorial](https://docs.openzeppelin.com/contracts/2.x/erc20-supply).
+
+## Die Schnittstelle {#the-interface}
+
+Der Zweck eines Standards wie ERC-20 besteht darin, eine Vielzahl von Token-Implementierungen zu ermöglichen, die mit anderen Anwendungen wie Wallets und dezentralen Börsen interoperabel sind. Um das zu erreichen, erstellen wir eine
+[Schnittstelle](https://www.geeksforgeeks.org/solidity/solidity-basics-of-interface/). Jeder Code, der den Token-Vertrag verwenden muss, kann die gleichen Definitionen in der Schnittstelle verwenden und mit allen Token-Verträgen, die ihn verwenden, kompatibel sein, unabhängig davon, ob es sich um eine Wallet wie
+MetaMask, eine Dapp wie etherscan.io oder einen anderen Vertrag wie einen Liquiditätspool handelt.
+
+
+
+Wenn Sie ein erfahrener Programmierer sind, erinnern Sie sich wahrscheinlich an ähnliche Konstrukte in [Java](https://www.w3schools.com/java/java_interface.asp)
+oder sogar in [C-Header-Dateien](https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html).
+
+Dies ist eine Definition der [ERC-20-Schnittstelle](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol)
+von OpenZeppelin. Es ist eine Übersetzung des [für Menschen lesbaren Standards](https://eips.ethereum.org/EIPS/eip-20) in Solidity-Code. Natürlich definiert die
+Schnittstelle selbst nicht, _wie_ etwas zu tun ist. Dies wird im nachstehenden Vertragsquelltext erläutert.
+
+
+
+```solidity
+// SPDX-License-Identifier: MIT
+```
+
+Solidity-Dateien sollten einen Lizenzbezeichner enthalten. [Die Liste der Lizenzen finden Sie hier](https://spdx.org/licenses/). Wenn Sie eine andere
+Lizenz benötigen, erklären Sie dies einfach in den Kommentaren.
+
+
+
+```solidity
+pragma solidity >=0.6.0 <0.8.0;
+```
+
+Die Sprache Solidity entwickelt sich noch immer schnell weiter, und neue Versionen sind möglicherweise nicht mit altem Code kompatibel
+([siehe hier](https://docs.soliditylang.org/en/v0.7.0/070-breaking-changes.html)). Daher ist es eine gute Idee, nicht nur eine Mindestversion
+der Sprache anzugeben, sondern auch eine Höchstversion, die letzte, mit der Sie den Code getestet haben.
+
+
+
+```solidity
+/**
+ * @dev Schnittstelle des ERC20-Standards, wie im EIP definiert.
+ */
+```
+
+Das `@dev` im Kommentar ist Teil des [NatSpec-Formats](https://docs.soliditylang.org/en/develop/natspec-format.html), das zur Erstellung von
+Dokumentation aus dem Quellcode verwendet wird.
+
+
+
+```solidity
+interface IERC20 {
+```
+
+Konventionsgemäß beginnen Schnittstellennamen mit `I`.
+
+
+
+```solidity
+ /**
+ * @dev Gibt die Menge der existierenden Token zurück.
+ */
+ function totalSupply() external view returns (uint256);
+```
+
+Diese Funktion ist `external`, was bedeutet, dass [sie nur von außerhalb des Vertrags aufgerufen werden kann](https://docs.soliditylang.org/en/v0.7.0/cheatsheet.html#index-2).
+Sie gibt den Gesamtvorrat an Token im Vertrag zurück. Dieser Wert wird mit dem in Ethereum gebräuchlichsten Typ zurückgegeben, 256 Bit ohne Vorzeichen (256 Bit ist die
+native Wortgröße der EVM). Diese Funktion ist auch eine `view`, was bedeutet, dass sie den Zustand nicht ändert, so dass sie auf einem einzelnen Knoten ausgeführt werden kann, anstatt dass sie
+auf jedem Knoten in der Blockchain ausgeführt werden muss. Diese Art von Funktion erzeugt keine Transaktion und kostet kein [Gas](/developers/docs/gas/).
+
+**Hinweis:** Theoretisch könnte es so aussehen, als ob der Ersteller eines Vertrags betrügen könnte, indem er einen geringeren Gesamtvorrat als den tatsächlichen Wert zurückgibt, wodurch jeder Token
+wertvoller erscheint, als er tatsächlich ist. Diese Befürchtung ignoriert jedoch die wahre Natur der Blockchain. Alles, was auf der Blockchain geschieht, kann von
+jedem Knoten verifiziert werden. Um dies zu erreichen, sind der Maschinencode und der Speicher jedes Vertrags auf jedem Knoten verfügbar. Obwohl Sie nicht verpflichtet sind, den Solidity-Code
+für Ihren Vertrag zu veröffentlichen, würde Sie niemand ernst nehmen, wenn Sie nicht den Quellcode und die Version von Solidity, mit der er kompiliert wurde, veröffentlichen, damit er
+mit dem von Ihnen bereitgestellten Maschinencode verifiziert werden kann.
+Siehe zum Beispiel [diesen Vertrag](https://eth.blockscout.com/address/0xa530F85085C6FE2f866E7FdB716849714a89f4CD?tab=contract).
+
+
+
+```solidity
+ /**
+ * @dev Gibt die Menge an Token zurück, die `account` besitzt.
+ */
+ function balanceOf(address account) external view returns (uint256);
+```
+
+Wie der Name schon sagt, gibt `balanceOf` den Saldo eines Kontos zurück. Ethereum-Konten werden in Solidity mit dem Typ `address` identifiziert, der 160 Bit enthält.
+Sie ist ebenfalls `external` und `view`.
+
+
+
+```solidity
+ /**
+ * @dev Verschiebt `amount` Token vom Konto des Aufrufers an `recipient`.
+ *
+ * Gibt einen booleschen Wert zurück, der angibt, ob die Operation erfolgreich war.
+ *
+ * Löst ein {Transfer}-Ereignis aus.
+ */
+ function transfer(address recipient, uint256 amount) external returns (bool);
+```
+
+Die Funktion `transfer` überträgt Token vom Aufrufer an eine andere Adresse. Dies beinhaltet eine Zustandsänderung, also ist es keine `view`.
+Wenn ein Nutzer diese Funktion aufruft, erzeugt das eine Transaktion und kostet Gas. Sie löst auch ein Ereignis, `Transfer`, aus, um alle auf
+der Blockchain über das Ereignis zu informieren.
+
+Die Funktion hat zwei Arten von Ausgaben für zwei verschiedene Arten von Aufrufern:
+
+- Benutzer, die die Funktion direkt über eine Benutzeroberfläche aufrufen. Typischerweise sendet der Nutzer eine Transaktion
+ und wartet nicht auf eine Antwort, was unbestimmt lange dauern kann. Der Nutzer kann sehen, was passiert ist,
+ indem er nach dem Transaktionsbeleg (der durch den Transaktions-Hash identifiziert wird) oder nach dem
+ `Transfer`-Ereignis sucht.
+- Andere Verträge, die die Funktion als Teil einer Gesamttransaktion aufrufen. Diese Verträge erhalten das Ergebnis sofort,
+ da sie in derselben Transaktion laufen und somit den Rückgabewert der Funktion verwenden können.
+
+Die gleiche Art von Ausgabe wird von den anderen Funktionen erzeugt, die den Zustand des Vertrags ändern.
+
+
+
+Berechtigungen („Allowances“) erlauben es einem Konto, einige Token auszugeben, die einem anderen Besitzer gehören.
+Dies ist z. B. für Verträge nützlich, die als Verkäufer fungieren. Verträge können nicht
+auf Ereignisse warten. Wenn also ein Käufer Token direkt an den Verkäufervertrag überweisen würde,
+wüsste dieser Vertrag nicht, dass er bezahlt wurde. Stattdessen erlaubt der Käufer dem
+Verkäufervertrag, einen bestimmten Betrag auszugeben, und der Verkäufer überweist diesen Betrag.
+Dies geschieht über eine Funktion, die der Verkäufervertrag aufruft, sodass der Verkäufervertrag
+wissen kann, ob sie erfolgreich war.
+
+```solidity
+ /**
+ * @dev Gibt die verbleibende Anzahl von Token zurück, die `spender` im
+ * Namen von `owner` über {transferFrom} ausgeben darf. Dieser Wert ist
+ * standardmäßig null.
+ *
+ * Dieser Wert ändert sich, wenn {approve} oder {transferFrom} aufgerufen werden.
+ */
+ function allowance(address owner, address spender) external view returns (uint256);
+```
+
+Die Funktion `allowance` ermöglicht es jedem, abzufragen, welche Berechtigung eine
+Adresse (`owner`) einer anderen Adresse (`spender`) zum Ausgeben erteilt.
+
+
+
+```solidity
+ /**
+ * @dev Legt `amount` als die Berechtigung von `spender` über die Token des Aufrufers fest.
+ *
+ * Gibt einen booleschen Wert zurück, der angibt, ob die Operation erfolgreich war.
+ *
+ * WICHTIG: Beachten Sie, dass das Ändern einer Berechtigung mit dieser Methode das Risiko birgt,
+ * dass jemand durch eine unglückliche Transaktionsreihenfolge sowohl die alte als auch die neue
+ * Berechtigung verwenden kann. Eine mögliche Lösung zur Minderung dieser Race-Condition
+ * besteht darin, zuerst die Berechtigung des Spenders auf 0 zu reduzieren und danach den
+ * gewünschten Wert festzulegen:
+ * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+ *
+ * Löst ein {Approval}-Ereignis aus.
+ */
+ function approve(address spender, uint256 amount) external returns (bool);
+```
+
+Die Funktion `approve` erstellt eine Berechtigung. Lesen Sie unbedingt die Meldung darüber,
+wie sie missbraucht werden kann. In Ethereum kontrollieren Sie die Reihenfolge Ihrer eigenen Transaktionen,
+aber Sie können nicht die Reihenfolge kontrollieren, in der die Transaktionen anderer Personen ausgeführt werden,
+es sei denn, Sie reichen Ihre eigene Transaktion erst ein, wenn Sie sehen, dass
+die Transaktion der anderen Seite stattgefunden hat.
+
+
+
+```solidity
+ /**
+ * @dev Verschiebt `amount` Token von `sender` zu `recipient` unter Verwendung des
+ * Berechtigungsmechanismus. `amount` wird dann von der Berechtigung des Aufrufers
+ * abgezogen.
+ *
+ * Gibt einen booleschen Wert zurück, der angibt, ob die Operation erfolgreich war.
+ *
+ * Löst ein {Transfer}-Ereignis aus.
+ */
+ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+```
+
+Schließlich wird `transferFrom` vom Ausgebenden verwendet, um die Berechtigung tatsächlich zu nutzen.
+
+
+
+```solidity
+
+ /**
+ * @dev Wird ausgelöst, wenn `value` Token von einem Konto (`from`) auf
+ * ein anderes (`to`) verschoben werden.
+ *
+ * Beachten Sie, dass `value` null sein kann.
+ */
+ event Transfer(address indexed from, address indexed to, uint256 value);
+
+ /**
+ * @dev Wird ausgelöst, wenn die Berechtigung eines `spender` für einen `owner` durch
+ * einen Aufruf von {approve} festgelegt wird. `value` ist die neue Berechtigung.
+ */
+ event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+```
+
+Diese Ereignisse werden ausgelöst, wenn sich der Zustand des ERC-20-Vertrags ändert.
+
+## Der eigentliche Vertrag {#the-actual-contract}
+
+Dies ist der eigentliche Vertrag, der den ERC-20-Standard implementiert,
+[entnommen von hier](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol).
+Er ist nicht dafür gedacht, so wie er ist verwendet zu werden, aber Sie können
+[davon erben](https://www.tutorialspoint.com/solidity/solidity_inheritance.htm), um ihn zu etwas Nutzbarem zu erweitern.
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.6.0 <0.8.0;
+```
+
+
+
+### Import-Anweisungen {#import-statements}
+
+Zusätzlich zu den oben genannten Interface-Definitionen importiert die Contract-Definition zwei weitere Dateien:
+
+```solidity
+
+import "../../GSN/Context.sol";
+import "./IERC20.sol";
+import "../../math/SafeMath.sol";
+```
+
+- `GSN/Context.sol` enthält die Definitionen, die für die Verwendung von [OpenGSN](https://www.opengsn.org/) erforderlich sind, einem System, das es Nutzern ohne Ether
+ ermöglicht, die Blockchain zu verwenden. Beachten Sie, dass dies eine alte Version ist. Wenn Sie OpenGSN integrieren möchten,
+ [verwenden Sie dieses Tutorial](https://docs.opengsn.org/javascript-client/tutorial.html).
+- [Die SafeMath-Bibliothek](https://ethereumdev.io/using-safe-math-library-to-prevent-from-overflows/), die
+ arithmetische Über- und Unterläufe für Solidity-Versionen **<0.8.0** verhindert. In Solidity ≥0.8.0 werden arithmetische Operationen bei
+ Über-/Unterlauf automatisch zurückgesetzt, wodurch SafeMath überflüssig wird. Dieser Vertrag verwendet SafeMath für die Abwärtskompatibilität mit
+ älteren Compiler-Versionen.
+
+
+
+Dieser Kommentar erklärt den Zweck des Vertrags.
+
+```solidity
+/**
+ * @dev Implementierung der {IERC20}-Schnittstelle.
+ *
+ * Diese Implementierung ist agnostisch gegenüber der Art und Weise, wie Token erstellt werden. Das bedeutet,
+ * dass ein Versorgungsmechanismus in einem abgeleiteten Vertrag mit {_mint} hinzugefügt werden muss.
+ * Einen generischen Mechanismus finden Sie unter {ERC20PresetMinterPauser}.
+ *
+ * TIPP: Eine detaillierte Beschreibung finden Sie in unserem Leitfaden
+ * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[Wie
+ * Versorgungsmechanismen implementiert werden].
+ *
+ * Wir haben die allgemeinen OpenZeppelin-Richtlinien befolgt: Funktionen werden zurückgesetzt, anstatt
+ * bei einem Fehler `false` zurückzugeben. Dieses Verhalten ist jedoch konventionell
+ * und steht nicht im Widerspruch zu den Erwartungen von ERC20-Anwendungen.
+ *
+ * Zusätzlich wird bei Aufrufen von {transferFrom} ein {Approval}-Ereignis ausgelöst.
+ * Dies ermöglicht es Anwendungen, die Berechtigung für alle Konten allein
+ * durch das Abhören dieser Ereignisse zu rekonstruieren. Andere Implementierungen des EIP geben
+ * diese Ereignisse möglicherweise nicht aus, da dies nicht von der Spezifikation gefordert wird.
+ *
+ * Schließlich wurden die nicht standardmäßigen Funktionen {decreaseAllowance} und {increaseAllowance}
+ * hinzugefügt, um die bekannten Probleme bei der Festlegung von
+ * Berechtigungen zu entschärfen. Siehe {IERC20-approve}.
+ */
+
+```
+
+### Vertragsdefinition {#contract-definition}
+
+```solidity
+contract ERC20 is Context, IERC20 {
+```
+
+Diese Zeile gibt die Vererbung an, in diesem Fall von `IERC20` von oben und `Context` für OpenGSN.
+
+
+
+```solidity
+
+ using SafeMath for uint256;
+
+```
+
+Diese Zeile hängt die `SafeMath`-Bibliothek an den Typ `uint256` an. Sie können diese Bibliothek
+[hier](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/SafeMath.sol) finden.
+
+### Variablendefinitionen {#variable-definitions}
+
+Diese Definitionen legen die Zustandsvariablen des Vertrags fest. Diese Variablen sind `private` deklariert, aber
+das bedeutet nur, dass andere Verträge auf der Blockchain sie nicht lesen können. _Es gibt keine
+Geheimnisse auf der Blockchain_, die Software auf jedem Knoten hat den Zustand jedes Vertrags
+bei jedem Block. Konventionsgemäß werden Zustandsvariablen `_` genannt.
+
+Die ersten beiden Variablen sind [Mappings](https://www.tutorialspoint.com/solidity/solidity_mappings.htm),
+was bedeutet, dass sie sich ungefähr wie [assoziative Arrays](https://wikipedia.org/wiki/Associative_array) verhalten,
+außer dass die Schlüssel numerische Werte sind. Speicher wird nur für Einträge zugewiesen, die Werte haben, die sich vom
+Standardwert (Null) unterscheiden.
+
+```solidity
+ mapping (address => uint256) private _balances;
+```
+
+Das erste Mapping, `_balances`, enthält Adressen und ihre jeweiligen Saldi dieses Tokens. Um auf
+den Saldo zuzugreifen, verwenden Sie diese Syntax: `_balances[]`.
+
+
+
+```solidity
+ mapping (address => mapping (address => uint256)) private _allowances;
+```
+
+Diese Variable, `_allowances`, speichert die zuvor erläuterten Berechtigungen. Der erste Index ist der Besitzer
+der Token, und der zweite ist der Vertrag mit der Berechtigung. Um auf den Betrag zuzugreifen, den Adresse A vom Konto von Adresse B
+ausgeben kann, verwenden Sie `_allowances[B][A]`.
+
+
+
+```solidity
+ uint256 private _totalSupply;
+```
+
+Wie der Name schon sagt, hält diese Variable den Gesamtvorrat an Token nach.
+
+
+
+```solidity
+ string private _name;
+ string private _symbol;
+ uint8 private _decimals;
+```
+
+Diese drei Variablen werden verwendet, um die Lesbarkeit zu verbessern. Die ersten beiden sind selbsterklärend, aber `_decimals`
+ist es nicht.
+
+Einerseits gibt es bei Ethereum keine Gleitkomma- oder Bruchvariablen. Andererseits
+mögen es Menschen, Token teilen zu können. Ein Grund, warum man sich auf Gold als Währung einigte, war,
+dass es schwer war, Wechselgeld herauszugeben, wenn jemand eine Ente im Wert einer Kuh kaufen wollte.
+
+Die Lösung besteht darin, ganze Zahlen zu verfolgen, aber anstelle des echten Tokens einen Bruchteil eines Tokens zu zählen, der
+fast wertlos ist. Im Fall von Ether wird der Bruchteil des Tokens „Wei“ genannt, und 10^18 Wei entsprechen einem
+ETH. Zum Zeitpunkt der Erstellung dieses Artikels entsprechen 10.000.000.000.000 Wei ungefähr einem US- oder Euro-Cent.
+
+Anwendungen müssen wissen, wie der Token-Saldo angezeigt wird. Wenn ein Nutzer 3.141.000.000.000.000.000 Wei hat, sind das
+3,14 ETH? 31,41 ETH? 3.141 ETH? Im Fall von Ether ist 10^18 Wei zu ETH definiert, aber für Ihren
+Token können Sie einen anderen Wert wählen. Wenn die Teilung des Tokens keinen Sinn macht, können Sie einen
+`_decimals`-Wert von Null verwenden. Wenn Sie denselben Standard wie ETH verwenden möchten, verwenden Sie den Wert **18**.
+
+### Der Konstruktor {#the-constructor}
+
+```solidity
+ /**
+ * @dev Setzt die Werte für {name} und {symbol}, initialisiert {decimals} mit
+ * einem Standardwert von 18.
+ *
+ * Um einen anderen Wert für {decimals} zu wählen, verwenden Sie {_setupDecimals}.
+ *
+ * Alle drei dieser Werte sind unveränderlich: Sie können nur einmal während
+ * der Konstruktion festgelegt werden.
+ */
+ constructor (string memory name_, string memory symbol_) public {
+ // In Solidity ≥0.7.0 ist 'public' implizit und kann weggelassen werden.
+
+ _name = name_;
+ _symbol = symbol_;
+ _decimals = 18;
+ }
+```
+
+Der Konstruktor wird aufgerufen, wenn der Vertrag zum ersten Mal erstellt wird. Konventionsgemäß werden Funktionsparameter `_` genannt.
+
+### Benutzeroberflächenfunktionen {#user-interface-functions}
+
+```solidity
+ /**
+ * @dev Gibt den Namen des Tokens zurück.
+ */
+ function name() public view returns (string memory) {
+ return _name;
+ }
+
+ /**
+ * @dev Gibt das Symbol des Tokens zurück, normalerweise eine kürzere Version des
+ * Namens.
+ */
+ function symbol() public view returns (string memory) {
+ return _symbol;
+ }
+
+ /**
+ * @dev Gibt die Anzahl der Dezimalstellen zurück, die zur Darstellung für den Benutzer verwendet werden.
+ * Wenn `decimals` beispielsweise `2` ist, sollte ein Saldo von `505` Token
+ * einem Benutzer als `5,05` (`505 / 10 ** 2`) angezeigt werden.
+ *
+ * Token entscheiden sich normalerweise für einen Wert von 18 und ahmen damit die Beziehung zwischen
+ * Ether und Wei nach. Dies ist der Wert, den {ERC20} verwendet, es sei denn, {_setupDecimals} wird
+ * aufgerufen.
+ *
+ * HINWEIS: Diese Information wird nur zu _Anzeige_-Zwecken verwendet: Sie beeinflusst
+ * in keiner Weise die Arithmetik des Vertrags, einschließlich
+ * {IERC20-balanceOf} und {IERC20-transfer}.
+ */
+ function decimals() public view returns (uint8) {
+ return _decimals;
+ }
+```
+
+Diese Funktionen, `name`, `symbol` und `decimals`, helfen Benutzeroberflächen, Ihren Vertrag zu kennen, damit sie ihn richtig anzeigen können.
+
+Der Rückgabetyp ist `string memory`, was bedeutet, dass eine Zeichenfolge zurückgegeben wird, die im Speicher gespeichert ist. Variablen, wie z. B.
+Zeichenketten, können an drei Stellen gespeichert werden:
+
+| | Lebensdauer | Vertragszugriff | Gaskosten |
+| ----------- | ---------------- | --------------- | ---------------------------------------------------------------------------------- |
+| Speicher | Funktionsaufruf | Lesen/Schreiben | Zehner oder Hunderter (höher für höhere Lagen) |
+| Aufrufdaten | Funktionsaufruf | Nur Lesen | Kann nicht als Rückgabetyp verwendet werden, sondern nur als Funktionsparametertyp |
+| Speicherort | Bis zur Änderung | Lesen/Schreiben | Hoch (800 für Lesen, 20.000 für Schreiben) |
+
+In diesem Fall ist der Speicher die beste Wahl.
+
+### Token-Informationen lesen {#read-token-information}
+
+Dies sind Funktionen, die Informationen über den Token liefern, entweder den Gesamtvorrat oder den
+Saldo eines Kontos.
+
+```solidity
+ /**
+ * @dev Siehe {IERC20-totalSupply}.
+ */
+ function totalSupply() public view override returns (uint256) {
+ return _totalSupply;
+ }
+```
+
+Die Funktion `totalSupply` gibt den Gesamtvorrat an Token zurück.
+
+
+
+```solidity
+ /**
+ * @dev Siehe {IERC20-balanceOf}.
+ */
+ function balanceOf(address account) public view override returns (uint256) {
+ return _balances[account];
+ }
+```
+
+Lesen Sie den Saldo eines Kontos. Beachten Sie, dass jeder den Kontostand eines anderen abrufen darf. Es hat keinen Sinn, diese Informationen zu verbergen, da sie ohnehin auf jedem Knoten verfügbar sind. _Es gibt keine Geheimnisse in der Blockchain._
+
+### Token übertragen {#transfer-tokens}
+
+```solidity
+ /**
+ * @dev Siehe {IERC20-transfer}.
+ *
+ * Anforderungen:
+ *
+ * - `recipient` darf nicht die Null-Adresse sein.
+ * - Der Aufrufer muss einen Saldo von mindestens `amount` haben.
+ */
+ function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
+```
+
+Die Funktion `transfer` wird aufgerufen, um Token vom Konto des Absenders auf ein anderes zu übertragen. Beachten Sie,
+dass sie zwar einen booleschen Wert zurückgibt, dieser aber immer **true** ist. Wenn die Übertragung
+fehlschlägt, setzt der Vertrag den Aufruf zurück.
+
+
+
+```solidity
+ _transfer(_msgSender(), recipient, amount);
+ return true;
+ }
+```
+
+Die Funktion `_transfer` erledigt die eigentliche Arbeit. Es handelt sich um eine private Funktion, die nur von
+anderen Vertragsfunktionen aufgerufen werden kann. Konventionsgemäß werden private Funktionen wie Zustands-
+variablen `_` genannt.
+
+Normalerweise verwenden wir in Solidity `msg.sender` für den Absender der Nachricht. Das stört jedoch
+[OpenGSN](http://opengsn.org/). Wenn wir Transaktionen ohne Ether mit unserem Token zulassen wollen, müssen wir
+`_msgSender()` verwenden. Sie gibt `msg.sender` für normale Transaktionen zurück, aber für solche ohne Ether
+gibt sie den ursprünglichen Unterzeichner und nicht den Vertrag zurück, der die Nachricht weitergeleitet hat.
+
+### Berechtigungsfunktionen {#allowance-functions}
+
+Dies sind die Funktionen, die die Berechtigungsfunktionalität implementieren: `allowance`, `approve`, `transferFrom`
+und `_approve`. Zusätzlich geht die OpenZeppelin-Implementierung über den Basisstandard hinaus und enthält einige Funktionen, die die
+Sicherheit verbessern: `increaseAllowance` und `decreaseAllowance`.
+
+#### Die allowance-Funktion {#allowance}
+
+```solidity
+ /**
+ * @dev Siehe {IERC20-allowance}.
+ */
+ function allowance(address owner, address spender) public view virtual override returns (uint256) {
+ return _allowances[owner][spender];
+ }
+```
+
+Die Funktion `allowance` ermöglicht es jedem, jede Berechtigung zu überprüfen.
+
+#### Die approve-Funktion {#approve}
+
+```solidity
+ /**
+ * @dev Siehe {IERC20-approve}.
+ *
+ * Anforderungen:
+ *
+ * - `spender` darf nicht die Null-Adresse sein.
+ */
+ function approve(address spender, uint256 amount) public virtual override returns (bool) {
+```
+
+Diese Funktion wird aufgerufen, um eine Berechtigung zu erstellen. Sie ähnelt der obigen `transfer`-Funktion:
+
+- Die Funktion ruft lediglich eine interne Funktion auf (in diesem Fall `_approve`), die die eigentliche Arbeit erledigt.
+- Die Funktion gibt entweder `true` zurück (wenn erfolgreich) oder wird zurückgesetzt (wenn nicht).
+
+
+
+```solidity
+ _approve(_msgSender(), spender, amount);
+ return true;
+ }
+```
+
+Wir verwenden interne Funktionen, um die Anzahl der Stellen, an denen Zustandsänderungen stattfinden, zu minimieren. _Jede_ Funktion, die den
+Zustand ändert, stellt ein potenzielles Sicherheitsrisiko dar, das auf Sicherheit geprüft werden muss. Auf diese Weise ist die Wahrscheinlichkeit geringer, dass wir etwas falsch machen.
+
+#### Die transferFrom-Funktion {#transferFrom}
+
+Dies ist die Funktion, die ein Ausgebender aufruft, um eine Berechtigung zu nutzen. Dies erfordert zwei Operationen: die Übertragung des ausgegebenen
+Betrags und die Reduzierung der Berechtigung um diesen Betrag.
+
+```solidity
+ /**
+ * @dev Siehe {IERC20-transferFrom}.
+ *
+ * Löst ein {Approval}-Ereignis aus, das die aktualisierte Berechtigung anzeigt. Dies ist nicht
+ * vom EIP gefordert. Siehe den Hinweis am Anfang von {ERC20}.
+ *
+ * Anforderungen:
+ *
+ * - `sender` und `recipient` dürfen nicht die Null-Adresse sein.
+ * - `sender` muss einen Saldo von mindestens `amount` haben.
+ * - der Aufrufer muss eine Berechtigung für die Token von `sender` von mindestens
+ * `amount` haben.
+ */
+ function transferFrom(address sender, address recipient, uint256 amount) public virtual
+ override returns (bool) {
+ _transfer(sender, recipient, amount);
+```
+
+
+
+Der Funktionsaufruf `a.sub(b, "message")` tut zwei Dinge. Erstens berechnet er `a-b`, was die neue Berechtigung ist.
+Zweitens prüft er, ob dieses Ergebnis nicht negativ ist. Wenn es negativ ist, wird der Aufruf mit der angegebenen Nachricht zurückgesetzt. Beachten Sie, dass bei einem Zurücksetzen eines Aufrufs jede zuvor während dieses Aufrufs durchgeführte Verarbeitung ignoriert wird, sodass wir den
+`_transfer` nicht rückgängig machen müssen.
+
+```solidity
+ _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount,
+ "ERC20: transfer amount exceeds allowance"));
+ return true;
+ }
+```
+
+#### Sicherheitserweiterungen von OpenZeppelin {#openzeppelin-safety-additions}
+
+Es ist gefährlich, eine Berechtigung, die nicht Null ist, auf einen anderen Wert ungleich Null zu setzen,
+da Sie nur die Reihenfolge Ihrer eigenen Transaktionen kontrollieren, nicht die von jemand anderem. Stellen Sie sich vor,
+Sie haben zwei Nutzer, Alice, die naiv ist, und Bill, der unehrlich ist. Alice möchte eine Dienstleistung von
+Bill, von der sie glaubt, dass sie fünf Token kostet – also gibt sie Bill eine Berechtigung von fünf Token.
+
+Dann ändert sich etwas und Bills Preis steigt auf zehn Token. Alice, die den Dienst immer noch will,
+sendet eine Transaktion, die Bills Berechtigung auf zehn setzt. Sobald Bill diese neue Transaktion
+im Transaktionspool sieht, sendet er eine Transaktion, die Alices fünf Token ausgibt und einen viel
+höheren Gaspreis hat, damit sie schneller gemint wird. Auf diese Weise kann Bill zuerst fünf Token ausgeben und dann,
+sobald Alices neue Berechtigung gemint wurde, zehn weitere ausgeben, für einen Gesamtpreis von fünfzehn Token, mehr als
+Alice autorisieren wollte. Diese Technik wird
+[Front-Running](https://consensysdiligence.github.io/smart-contract-best-practices/attacks/#front-running) genannt
+
+| Alice-Transaktion | Alice-Nonce | Bill-Transaktion | Bill-Nonce | Bills Berechtigung | Bills Gesamteinkommen von Alice |
+| ------------------------------------ | ----------- | ------------------------------------------------ | ---------- | ------------------ | ------------------------------- |
+| approve(Bill, 5) | 10 | | | 5 | 0 |
+| | | transferFrom(Alice, Bill, 5) | 10,123 | 0 | 5 |
+| approve(Bill, 10) | 11 | | | 10 | 5 |
+| | | transferFrom(Alice, Bill, 10) | 10,124 | 0 | 15 |
+
+Um dieses Problem zu vermeiden, ermöglichen es diese beiden Funktionen (`increaseAllowance` und `decreaseAllowance`), die
+Berechtigung um einen bestimmten Betrag zu ändern. Wenn Bill also bereits fünf Token ausgegeben hat, wird er nur
+noch fünf weitere ausgeben können. Je nach Zeitplan gibt es zwei Möglichkeiten, wie dies funktionieren kann, die beide damit enden, dass Bill nur zehn Token erhält:
+
+A:
+
+| Alice-Transaktion | Alice-Nonce | Bill-Transaktion | Bill-Nonce | Bills Berechtigung | Bills Gesamteinkommen von Alice |
+| --------------------------------------------- | ----------: | ----------------------------------------------- | ---------: | -----------------: | ------------------------------- |
+| approve(Bill, 5) | 10 | | | 5 | 0 |
+| | | transferFrom(Alice, Bill, 5) | 10,123 | 0 | 5 |
+| increaseAllowance(Bill, 5) | 11 | | | 0+5 = 5 | 5 |
+| | | transferFrom(Alice, Bill, 5) | 10,124 | 0 | 10 |
+
+B:
+
+| Alice-Transaktion | Alice-Nonce | Bill-Transaktion | Bill-Nonce | Bills Berechtigung | Bills Gesamteinkommen von Alice |
+| --------------------------------------------- | ----------: | ------------------------------------------------ | ---------: | -----------------: | ------------------------------: |
+| approve(Bill, 5) | 10 | | | 5 | 0 |
+| increaseAllowance(Bill, 5) | 11 | | | 5+5 = 10 | 0 |
+| | | transferFrom(Alice, Bill, 10) | 10,124 | 0 | 10 |
+
+```solidity
+ /**
+ * @dev Erhöht atomar die dem `spender` vom Aufrufer gewährte Berechtigung.
+ *
+ * Dies ist eine Alternative zu {approve}, die als Milderung für
+ * in {IERC20-approve} beschriebene Probleme verwendet werden kann.
+ *
+ * Löst ein {Approval}-Ereignis aus, das die aktualisierte Berechtigung anzeigt.
+ *
+ * Anforderungen:
+ *
+ * - `spender` darf nicht die Null-Adresse sein.
+ */
+ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
+ _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
+ return true;
+ }
+```
+
+Die Funktion `a.add(b)` ist eine sichere Addition. In dem unwahrscheinlichen Fall, dass `a`+`b`>=`2^256` ist, findet kein Umbruch
+statt, wie es bei der normalen Addition der Fall ist.
+
+```solidity
+
+ /**
+ * @dev Verringert atomar die dem `spender` vom Aufrufer gewährte Berechtigung.
+ *
+ * Dies ist eine Alternative zu {approve}, die als Milderung für
+ * in {IERC20-approve} beschriebene Probleme verwendet werden kann.
+ *
+ * Löst ein {Approval}-Ereignis aus, das die aktualisierte Berechtigung anzeigt.
+ *
+ * Anforderungen:
+ *
+ * - `spender` darf nicht die Null-Adresse sein.
+ * - `spender` muss eine Berechtigung für den Aufrufer von mindestens
+ * `subtractedValue` haben.
+ */
+ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
+ _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue,
+ "ERC20: decreased allowance below zero"));
+ return true;
+ }
+```
+
+### Funktionen, die Token-Informationen ändern {#functions-that-modify-token-information}
+
+Dies sind die vier Funktionen, die die eigentliche Arbeit erledigen: `_transfer`, `_mint`, `_burn` und `_approve`.
+
+#### Die _transfer-Funktion {#_transfer}
+
+```solidity
+ /**
+ * @dev Verschiebt `amount` Token von `sender` zu `recipient`.
+ *
+ * Diese interne Funktion ist äquivalent zu {transfer} und kann verwendet werden,
+ * um z. B. automatische Token-Gebühren, Slashing-Mechanismen usw. zu implementieren.
+ *
+ * Löst ein {Transfer}-Ereignis aus.
+ *
+ * Anforderungen:
+ *
+ * - `sender` darf nicht die Null-Adresse sein.
+ * - `recipient` darf nicht die Null-Adresse sein.
+ * - `sender` muss einen Saldo von mindestens `amount` haben.
+ */
+ function _transfer(address sender, address recipient, uint256 amount) internal virtual {
+```
+
+Diese Funktion, `_transfer`, überträgt Token von einem Konto auf ein anderes. Sie wird sowohl von
+`transfer` (für Übertragungen vom eigenen Konto des Absenders) als auch von `transferFrom` (zur Verwendung von Berechtigungen
+zur Übertragung vom Konto eines anderen) aufgerufen.
+
+
+
+```solidity
+ require(sender != address(0), "ERC20: transfer from the zero address");
+ require(recipient != address(0), "ERC20: transfer to the zero address");
+```
+
+Niemand besitzt tatsächlich die Adresse Null in Ethereum (d. h., niemand kennt einen privaten Schlüssel, dessen zugehöriger öffentlicher Schlüssel
+in die Null-Adresse umgewandelt wird). Wenn Leute diese Adresse verwenden, handelt es sich normalerweise um einen Softwarefehler – daher
+schlagen wir fehl, wenn die Null-Adresse als Absender oder Empfänger verwendet wird.
+
+
+
+```solidity
+ _beforeTokenTransfer(sender, recipient, amount);
+
+```
+
+Es gibt zwei Möglichkeiten, diesen Vertrag zu verwenden:
+
+1. Verwenden Sie ihn als Vorlage für Ihren eigenen Code
+2. [Erben Sie davon](https://www.bitdegree.org/learn/solidity-inheritance) und überschreiben Sie nur die Funktionen, die Sie ändern müssen
+
+Die zweite Methode ist viel besser, da der OpenZeppelin ERC-20-Code bereits geprüft wurde und als sicher gilt. Wenn Sie Vererbung verwenden,
+ist es klar, welche Funktionen Sie ändern, und um Ihrem Vertrag zu vertrauen, müssen die Leute nur diese spezifischen Funktionen prüfen.
+
+Es ist oft nützlich, eine Funktion jedes Mal auszuführen, wenn Token den Besitzer wechseln. `_transfer` ist jedoch eine sehr wichtige Funktion und es ist
+möglich, sie unsicher zu schreiben (siehe unten), daher ist es am besten, sie nicht zu überschreiben. Die Lösung ist `_beforeTokenTransfer`, eine
+[Hook-Funktion](https://wikipedia.org/wiki/Hooking). Sie können diese Funktion überschreiben, und sie wird bei jeder Übertragung aufgerufen.
+
+
+
+```solidity
+ _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
+ _balances[recipient] = _balances[recipient].add(amount);
+```
+
+Dies sind die Zeilen, die die Übertragung tatsächlich durchführen. Beachten Sie, dass **nichts** zwischen ihnen steht und dass wir den
+übertragenen Betrag vom Absender abziehen, bevor wir ihn dem Empfänger hinzufügen. Dies ist wichtig, denn wenn es in der Mitte einen
+Aufruf an einen anderen Vertrag gäbe, hätte dieser genutzt werden können, um diesen Vertrag zu betrügen. Auf diese Weise ist die Übertragung
+atomar, nichts kann in der Mitte davon passieren.
+
+
+
+```solidity
+ emit Transfer(sender, recipient, amount);
+ }
+```
+
+Schließlich wird ein `Transfer`-Ereignis ausgelöst. Ereignisse sind für Smart Contracts nicht zugänglich, aber Code, der außerhalb der Blockchain
+ausgeführt wird, kann auf Ereignisse lauschen und darauf reagieren. Zum Beispiel kann eine Wallet nachverfolgen, wann der Besitzer mehr Token erhält.
+
+#### Die _mint- und _burn-Funktionen {#_mint-and-_burn}
+
+Diese beiden Funktionen (`_mint` und `_burn`) ändern den Gesamtvorrat an Token.
+Sie sind intern und es gibt keine Funktion, die sie in diesem Vertrag aufruft,
+sie sind also nur nützlich, wenn Sie von dem Vertrag erben und Ihre eigene
+Logik hinzufügen, um zu entscheiden, unter welchen Bedingungen neue Token gemint oder bestehende
+gebrannt werden.
+
+**HINWEIS:** Jeder ERC-20-Token hat seine eigene Geschäftslogik, die die Token-Verwaltung vorschreibt.
+Ein Vertrag mit festem Angebot könnte beispielsweise nur `_mint`
+im Konstruktor aufrufen und niemals `_burn`. Ein Vertrag, der Token verkauft,
+ruft `_mint` auf, wenn er bezahlt wird, und ruft vermutlich irgendwann `_burn` auf,
+um eine galoppierende Inflation zu vermeiden.
+
+```solidity
+ /** @dev Erstellt `amount` Token und weist sie `account` zu, wodurch der
+ * Gesamtvorrat erhöht wird.
+ *
+ * Löst ein {Transfer}-Ereignis aus, bei dem `from` auf die Null-Adresse gesetzt ist.
+ *
+ * Anforderungen:
+ *
+ * - `to` darf nicht die Null-Adresse sein.
+ */
+ function _mint(address account, uint256 amount) internal virtual {
+ require(account != address(0), "ERC20: mint to the zero address");
+ _beforeTokenTransfer(address(0), account, amount);
+ _totalSupply = _totalSupply.add(amount);
+ _balances[account] = _balances[account].add(amount);
+ emit Transfer(address(0), account, amount);
+ }
+```
+
+Stellen Sie sicher, dass `_totalSupply` aktualisiert wird, wenn sich die Gesamtzahl der Token ändert.
+
+
+
+```solidity
+ /**
+ * @dev Zerstört `amount` Token von `account` und reduziert so den
+ * Gesamtvorrat.
+ *
+ * Löst ein {Transfer}-Ereignis aus, bei dem `to` auf die Null-Adresse gesetzt ist.
+ *
+ * Anforderungen:
+ *
+ * - `account` darf nicht die Null-Adresse sein.
+ * - `account` muss mindestens `amount` Token besitzen.
+ */
+ function _burn(address account, uint256 amount) internal virtual {
+ require(account != address(0), "ERC20: burn from the zero address");
+
+ _beforeTokenTransfer(account, address(0), amount);
+
+ _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
+ _totalSupply = _totalSupply.sub(amount);
+ emit Transfer(account, address(0), amount);
+ }
+```
+
+Die Funktion `_burn` ist fast identisch mit `_mint`, außer dass sie in die andere Richtung geht.
+
+#### Die _approve-Funktion {#_approve}
+
+Dies ist die Funktion, die tatsächlich Berechtigungen festlegt. Beachten Sie, dass es einem Besitzer erlaubt, eine
+Berechtigung anzugeben, die höher ist als der aktuelle Saldo des Besitzers. Das ist in Ordnung, da der Saldo zum Zeitpunkt der
+Übertragung überprüft wird, wo er sich von dem Saldo unterscheiden kann, der bei der Erstellung der Berechtigung
+vorhanden war.
+
+```solidity
+ /**
+ * @dev Legt `amount` als die Berechtigung von `spender` über die Token des `owner` fest.
+ *
+ * Diese interne Funktion ist äquivalent zu `approve` und kann verwendet werden,
+ * um z. B. automatische Berechtigungen für bestimmte Subsysteme festzulegen.
+ *
+ * Löst ein {Approval}-Ereignis aus.
+ *
+ * Anforderungen:
+ *
+ * - `owner` darf nicht die Null-Adresse sein.
+ * - `spender` darf nicht die Null-Adresse sein.
+ */
+ function _approve(address owner, address spender, uint256 amount) internal virtual {
+ require(owner != address(0), "ERC20: approve from the zero address");
+ require(spender != address(0), "ERC20: approve to the zero address");
+
+ _allowances[owner][spender] = amount;
+```
+
+
+
+Lösen Sie ein `Approval`-Ereignis aus. Je nachdem, wie die Anwendung geschrieben ist, kann der Vertrag des Ausgebenden über die
+Genehmigung entweder vom Eigentümer oder von einem Server, der auf diese Ereignisse lauscht, informiert werden.
+
+```solidity
+ emit Approval(owner, spender, amount);
+ }
+
+```
+
+### Die Dezimalvariable ändern {#modify-the-decimals-variable}
+
+```solidity
+
+
+ /**
+ * @dev Setzt {decimals} auf einen anderen Wert als den Standardwert 18.
+ *
+ * WARNUNG: Diese Funktion sollte nur vom Konstruktor aufgerufen werden. Die meisten
+ * Anwendungen, die mit Token-Verträgen interagieren, erwarten nicht,
+ * dass sich {decimals} jemals ändert, und könnten bei einer Änderung falsch funktionieren.
+ */
+ function _setupDecimals(uint8 decimals_) internal {
+ _decimals = decimals_;
+ }
+```
+
+Diese Funktion ändert die Variable `_decimals`, die verwendet wird, um Benutzeroberflächen mitzuteilen, wie der Betrag zu interpretieren ist.
+Sie sollten sie vom Konstruktor aus aufrufen. Es wäre unehrlich, sie zu einem späteren Zeitpunkt aufzurufen, und Anwendungen
+sind nicht darauf ausgelegt, damit umzugehen.
+
+### Hooks {#hooks}
+
+```solidity
+
+ /**
+ * @dev Hook, der vor jeder Übertragung von Token aufgerufen wird. Dies schließt
+ * Minting und Burning ein.
+ *
+ * Aufrufbedingungen:
+ *
+ * - Wenn `from` und `to` beide nicht null sind, wird `amount` der Token von `from`
+ * an `to` übertragen.
+ * - Wenn `from` null ist, werden `amount` Token für `to` gemint.
+ * - Wenn `to` null ist, wird `amount` der Token von `from` verbrannt.
+ * - `from` und `to` sind niemals beide null.
+ *
+ * Um mehr über Hooks zu erfahren, gehen Sie zu xref:ROOT:extending-contracts.adoc#using-hooks[Verwendung von Hooks].
+ */
+ function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
+}
+```
+
+Dies ist die Hook-Funktion, die bei Übertragungen aufgerufen wird. Sie ist hier leer, aber wenn Sie möchten,
+dass sie etwas tut, überschreiben Sie sie einfach.
+
+## Fazit {#conclusion}
+
+Zur Wiederholung, hier sind einige der wichtigsten Ideen in diesem Vertrag (meiner Meinung nach, Ihre kann abweichen):
+
+- _Es gibt keine Geheimnisse in der Blockchain_. Alle Informationen, auf die ein Smart Contract zugreifen kann,
+ sind der ganzen Welt zugänglich.
+- Sie können die Reihenfolge Ihrer eigenen Transaktionen kontrollieren, aber nicht, wann die Transaktionen anderer Personen
+ stattfinden. Dies ist der Grund, warum das Ändern einer Berechtigung gefährlich sein kann, da es dem
+ Ausgebenden ermöglicht, die Summe beider Berechtigungen auszugeben.
+- Werte vom Typ `uint256` haben einen Überlauf. Mit anderen Worten: _0-1=2^256-1_. Wenn das kein erwünschtes
+ Verhalten ist, müssen Sie es überprüfen (oder die SafeMath-Bibliothek verwenden, die das für Sie tut). Beachten Sie, dass sich dies in
+ [Solidity 0.8.0](https://docs.soliditylang.org/en/breaking/080-breaking-changes.html) geändert hat.
+- Führen Sie alle Zustandsänderungen eines bestimmten Typs an einem bestimmten Ort durch, da dies die Prüfung erleichtert.
+ Dies ist der Grund, warum wir zum Beispiel `_approve` haben, das von `approve`, `transferFrom`,
+ `increaseAllowance` und `decreaseAllowance` aufgerufen wird
+- Zustandsänderungen sollten atomar sein, ohne dass eine andere Aktion in ihrer Mitte stattfindet (wie Sie
+ in `_transfer` sehen können). Dies liegt daran, dass Sie während der Zustandsänderung einen inkonsistenten Zustand haben. Zum Beispiel
+ gibt es zwischen dem Zeitpunkt, an dem Sie vom Saldo des Absenders abziehen, und dem Zeitpunkt, an dem Sie dem Saldo des
+ Empfängers hinzufügen, weniger Token, als es sein sollten. Dies könnte potenziell missbraucht werden, wenn
+ Operationen zwischen ihnen stattfinden, insbesondere Aufrufe an einen anderen Vertrag.
+
+Jetzt, da Sie gesehen haben, wie der OpenZeppelin ERC-20-Vertrag geschrieben ist und insbesondere, wie er
+sicherer gemacht wurde, können Sie Ihre eigenen sicheren Verträge und Anwendungen schreiben.
+
+[Hier finden Sie mehr von meiner Arbeit](https://cryptodocguy.pro/).
diff --git a/public/content/translations/de/developers/tutorials/erc20-with-safety-rails/index.md b/public/content/translations/de/developers/tutorials/erc20-with-safety-rails/index.md
new file mode 100644
index 00000000000..1f76a93c690
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/erc20-with-safety-rails/index.md
@@ -0,0 +1,217 @@
+---
+title: ERC-20 mit Sicherheitsvorkehrungen
+description: Wie man Leuten helfen kann, dumme Fehler zu vermeiden
+author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+lang: de
+tags: [ "Erc-20" ]
+skill: beginner
+published: 2022-08-15
+---
+
+## Einführung {#introduction}
+
+Einer der großen Vorteile von Ethereum ist, dass es keine zentrale Instanz gibt, die Ihre Transaktionen ändern oder rückgängig machen kann. Eines der großen Probleme bei Ethereum ist, dass es keine zentrale Instanz gibt, die die Macht hat, Benutzerfehler oder illegale Transaktionen rückgängig zu machen. In diesem Artikel erfahren Sie mehr über einige der häufigsten Fehler, die Benutzer mit [ERC-20](/developers/docs/standards/tokens/erc-20/)-Token machen, sowie darüber, wie Sie ERC-20-Verträge erstellen, die den Benutzern helfen, diese Fehler zu vermeiden, oder die einer zentralen Instanz eine gewisse Macht geben (zum Beispiel das Einfrieren von Konten).
+
+Beachten Sie, dass wir zwar den [OpenZeppelin ERC-20-Token-Vertrag](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20) verwenden werden, dieser Artikel ihn aber nicht im Detail erklärt. Sie können diese Informationen [hier](/developers/tutorials/erc20-annotated-code) finden.
+
+Wenn Sie den vollständigen Quellcode sehen möchten:
+
+1. Öffnen Sie die [Remix IDE](https://remix.ethereum.org/).
+2. Klicken Sie auf das GitHub-Klon-Symbol ().
+3. Klonen Sie das GitHub-Repository `https://github.com/qbzzt/20220815-erc20-safety-rails`.
+4. Öffnen Sie **contracts > erc20-safety-rails.sol**.
+
+## Einen ERC-20-Vertrag erstellen {#creating-an-erc-20-contract}
+
+Bevor wir die Sicherheitsfunktionalität hinzufügen können, benötigen wir einen ERC-20-Vertrag. In diesem Artikel verwenden wir [den OpenZeppelin Contracts Wizard](https://docs.openzeppelin.com/contracts/5.x/wizard). Öffnen Sie es in einem anderen Browser und befolgen Sie diese Anweisungen:
+
+1. Wählen Sie **ERC20** aus.
+
+2. Geben Sie diese Einstellungen ein:
+
+ | Parameter | Wert |
+ | ------------------ | ------------------------------- |
+ | Name | SafetyRailsToken |
+ | Symbol | SAFE |
+ | Premint | 1000 |
+ | Eigenschaften | Keine (None) |
+ | Zugriffskontrolle | Ownable |
+ | Aktualisierbarkeit | Keine (None) |
+
+3. Scrollen Sie nach oben und klicken Sie auf **In Remix öffnen** (für Remix) oder auf **Herunterladen**, um eine andere Umgebung zu verwenden. Ich gehe davon aus, dass Sie Remix verwenden. Wenn Sie etwas anderes verwenden, nehmen Sie einfach die entsprechenden Änderungen vor.
+
+4. Wir haben jetzt einen voll funktionsfähigen ERC-20-Vertrag. Sie können `.deps` > `npm` erweitern, um den importierten Code zu sehen.
+
+5. Kompilieren, deployen und spielen Sie mit dem Vertrag, um zu sehen, dass er als ERC-20-Vertrag funktioniert. Wenn Sie lernen müssen, wie man Remix benutzt, [verwenden Sie dieses Tutorial](https://remix.ethereum.org/?#activate=udapp,solidity,LearnEth).
+
+## Häufige Fehler {#common-mistakes}
+
+### Die Fehler {#the-mistakes}
+
+Benutzer senden manchmal Token an die falsche Adresse. Wir können zwar nicht ihre Gedanken lesen, um zu wissen, was sie vorhatten, aber es gibt zwei Fehlertypen, die häufig vorkommen und leicht zu erkennen sind:
+
+1. Senden der Token an die eigene Adresse des Vertrags. Zum Beispiel hat [Optimisms OP-Token](https://optimism.mirror.xyz/qvd0WfuLKnePm1Gxb9dpGchPf5uDz5NSMEFdgirDS4c) in weniger als zwei Monaten [über 120.000](https://optimism.blockscout.com/address/0x4200000000000000000000000000000000000042) OP-Token angesammelt. Dies stellt ein beträchtliches Vermögen dar, das die Leute vermutlich einfach verloren haben.
+
+2. Senden der Token an eine leere Adresse, die weder einem [externen Konto](/developers/docs/accounts/#externally-owned-accounts-and-key-pairs) noch einem [Smart Contract](/developers/docs/smart-contracts) entspricht. Obwohl ich keine Statistiken darüber habe, wie oft dies vorkommt, [hätte ein Vorfall 20.000.000 Token kosten können](https://gov.optimism.io/t/message-to-optimism-community-from-wintermute/2595).
+
+### Verhindern von Überweisungen {#preventing-transfers}
+
+Der OpenZeppelin ERC-20-Vertrag enthält [einen Hook, `_beforeTokenTransfer`](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol#L364-L368), der aufgerufen wird, bevor ein Token übertragen wird. Standardmäßig tut dieser Hook nichts, aber wir können unsere eigene Funktionalität daran hängen, wie z. B. Prüfungen, die zurücksetzen, wenn es ein Problem gibt.
+
+Um den Hook zu verwenden, fügen Sie diese Funktion nach dem Konstruktor hinzu:
+
+```solidity
+ function _beforeTokenTransfer(address from, address to, uint256 amount)
+ internal virtual
+ override(ERC20)
+ {
+ super._beforeTokenTransfer(from, to, amount);
+ }
+```
+
+Einige Teile dieser Funktion sind vielleicht neu für Sie, wenn Sie mit Solidity nicht sehr vertraut sind:
+
+```solidity
+ internal virtual
+```
+
+Das Schlüsselwort `virtual` bedeutet, dass, so wie wir die Funktionalität von `ERC20` geerbt und diese Funktion überschrieben haben, andere Verträge von uns erben und diese Funktion überschreiben können.
+
+```solidity
+ override(ERC20)
+```
+
+Wir müssen explizit angeben, dass wir die ERC20-Token-Definition von `_beforeTokenTransfer` [überschreiben](https://docs.soliditylang.org/en/v0.8.15/contracts.html#function-overriding). Im Allgemeinen sind explizite Definitionen aus Sicherheitssicht viel besser als implizite – man kann nicht vergessen, dass man etwas getan hat, wenn es direkt vor einem liegt. Das ist auch der Grund, warum wir angeben müssen, welche `_beforeTokenTransfer`-Funktion der Superklasse wir überschreiben.
+
+```solidity
+ super._beforeTokenTransfer(from, to, amount);
+```
+
+Diese Zeile ruft die `_beforeTokenTransfer`-Funktion des Vertrags oder der Verträge auf, von denen wir geerbt haben und die sie besitzen. In diesem Fall ist das nur `ERC20`, `Ownable` hat diesen Hook nicht. Auch wenn `ERC20._beforeTokenTransfer` derzeit nichts tut, rufen wir es auf, für den Fall, dass in Zukunft Funktionalität hinzugefügt wird (und wir uns dann entscheiden, den Vertrag neu zu deployen, da sich Verträge nach dem Deployment nicht ändern).
+
+### Kodierung der Anforderungen {#coding-the-requirements}
+
+Wir wollen der Funktion diese Anforderungen hinzufügen:
+
+- Die `to`-Adresse darf nicht `address(this)` sein, die Adresse des ERC-20-Vertrags selbst.
+- Die `to`-Adresse darf nicht leer sein, sie muss entweder:
+ - Ein externes Konto (EOA). Wir können nicht direkt prüfen, ob eine Adresse ein EOA ist, aber wir können den ETH-Saldo einer Adresse prüfen. EOAs haben fast immer einen Saldo, auch wenn sie nicht mehr verwendet werden – es ist schwierig, sie bis auf den letzten Wei zu leeren.
+ - Ein Smart Contract. Zu testen, ob eine Adresse ein Smart Contract ist, ist etwas schwieriger. Es gibt einen Opcode, der die externe Codelänge prüft, namens [`EXTCODESIZE`](https://www.evm.codes/#3b), aber er ist in Solidity nicht direkt verfügbar. Wir müssen dafür [Yul](https://docs.soliditylang.org/en/v0.8.15/yul.html) verwenden, was EVM-Assembly ist. Es gibt andere Werte, die wir von Solidity verwenden könnten ([`.code` und `.codehash`](https://docs.soliditylang.org/en/v0.8.15/units-and-global-variables.html#members-of-address-types)), aber sie kosten mehr.
+
+Gehen wir den neuen Code Zeile für Zeile durch:
+
+```solidity
+ require(to != address(this), "Token können nicht an die Vertragsadresse gesendet werden");
+```
+
+Dies ist die erste Anforderung: Prüfen, dass `to` und `this(address)` nicht dasselbe sind.
+
+```solidity
+ bool isToContract;
+ assembly {
+ isToContract := gt(extcodesize(to), 0)
+ }
+```
+
+So prüfen wir, ob eine Adresse ein Vertrag ist. Wir können die Ausgabe nicht direkt von Yul empfangen, also definieren wir stattdessen eine Variable, die das Ergebnis enthält (in diesem Fall `isToContract`). Yul funktioniert so, dass jeder Opcode als eine Funktion betrachtet wird. Zuerst rufen wir also [`EXTCODESIZE`](https://www.evm.codes/#3b) auf, um die Vertragsgröße zu erhalten, und verwenden dann [`GT`](https://www.evm.codes/#11), um zu prüfen, ob sie nicht Null ist (wir haben es mit vorzeichenlosen Ganzzahlen zu tun, also kann sie natürlich nicht negativ sein). Wir schreiben dann das Ergebnis in `isToContract`.
+
+```solidity
+ require(to.balance != 0 || isToContract, "Token können nicht an eine leere Adresse gesendet werden");
+```
+
+Und schließlich haben wir die eigentliche Prüfung auf leere Adressen.
+
+## Administrativer Zugriff {#admin-access}
+
+Manchmal ist es nützlich, einen Administrator zu haben, der Fehler rückgängig machen kann. Um das Missbrauchspotenzial zu verringern, kann dieser Administrator ein [Multisig](https://blog.logrocket.com/security-choices-multi-signature-wallets/) sein, sodass mehrere Personen einer Aktion zustimmen müssen. In diesem Artikel werden wir zwei administrative Funktionen haben:
+
+1. Einfrieren und Freigeben von Konten. Dies kann nützlich sein, zum Beispiel, wenn ein Konto kompromittiert sein könnte.
+2. Asset-Bereinigung.
+
+ Manchmal senden Betrüger betrügerische Token an den Vertrag des echten Tokens, um an Legitimität zu gewinnen. Zum Beispiel, [sehen Sie hier](https://optimism.blockscout.com/token/0x2348B1a1228DDCd2dB668c3d30207c3E1852fBbe?tab=holders). Der legitime ERC-20-Vertrag ist [0x4200....0042](https://optimism.blockscout.com/token/0x4200000000000000000000000000000000000042). Der Betrug, der vorgibt, er zu sein, ist [0x234....bbe](https://optimism.blockscout.com/token/0x2348B1a1228DDCd2dB668c3d30207c3E1852fBbe).
+
+ Es ist auch möglich, dass Leute versehentlich legitime ERC-20-Token an unseren Vertrag senden, was ein weiterer Grund ist, eine Möglichkeit zu haben, sie herauszuholen.
+
+OpenZeppelin bietet zwei Mechanismen, um administrativen Zugriff zu ermöglichen:
+
+- [`Ownable`](https://docs.openzeppelin.com/contracts/5.x/access-control#ownership-and-ownable)-Verträge haben einen einzigen Besitzer. Funktionen, die den `onlyOwner`-[Modifikator](https://www.tutorialspoint.com/solidity/solidity_function_modifiers.htm) haben, können nur von diesem Besitzer aufgerufen werden. Besitzer können das Eigentum an jemand anderen übertragen oder vollständig darauf verzichten. Die Rechte aller anderen Konten sind typischerweise identisch.
+- [`AccessControl`](https://docs.openzeppelin.com/contracts/5.x/access-control#role-based-access-control)-Verträge haben eine [rollenbasierte Zugriffskontrolle (RBAC)](https://en.wikipedia.org/wiki/Role-based_access_control).
+
+Der Einfachheit halber verwenden wir in diesem Artikel `Ownable`.
+
+### Einfrieren und Auftauen von Verträgen {#freezing-and-thawing-contracts}
+
+Das Einfrieren und Auftauen von Verträgen erfordert mehrere Änderungen:
+
+- Ein [Mapping](https://www.tutorialspoint.com/solidity/solidity_mappings.htm) von Adressen zu [Booleans](https://en.wikipedia.org/wiki/Boolean_data_type), um zu verfolgen, welche Adressen eingefroren sind. Alle Werte sind anfangs Null, was bei booleschen Werten als falsch interpretiert wird. Das ist, was wir wollen, denn standardmäßig sind Konten nicht eingefroren.
+
+ ```solidity
+ mapping(address => bool) public frozenAccounts;
+ ```
+
+- [Ereignisse](https://www.tutorialspoint.com/solidity/solidity_events.htm), um alle Interessierten zu informieren, wenn ein Konto eingefroren oder aufgetaut wird. Technisch gesehen sind Ereignisse für diese Aktionen nicht erforderlich, aber es hilft Offchain-Code, auf diese Ereignisse zu lauschen und zu wissen, was passiert. Es gilt als guter Stil, wenn ein Smart Contract sie ausgibt, wenn etwas passiert, das für jemand anderen relevant sein könnte.
+
+ Die Ereignisse sind indiziert, so dass es möglich sein wird, nach allen Zeitpunkten zu suchen, an denen ein Konto eingefroren oder aufgetaut wurde.
+
+ ```solidity
+ // Wenn Konten eingefroren oder aufgetaut werden
+ event AccountFrozen(address indexed _addr);
+ event AccountThawed(address indexed _addr);
+ ```
+
+- Funktionen zum Einfrieren und Auftauen von Konten. Diese beiden Funktionen sind fast identisch, also werden wir nur die Einfrierfunktion durchgehen.
+
+ ```solidity
+ function freezeAccount(address addr)
+ public
+ onlyOwner
+ ```
+
+ Funktionen, die als [`public`](https://www.tutorialspoint.com/solidity/solidity_contracts.htm) markiert sind, können von anderen Smart Contracts oder direkt durch eine Transaktion aufgerufen werden.
+
+ ```solidity
+ {
+ require(!frozenAccounts[addr], "Konto bereits eingefroren");
+ frozenAccounts[addr] = true;
+ emit AccountFrozen(addr);
+ } // freezeAccount
+ ```
+
+ Wenn das Konto bereits eingefroren ist, wird die Transaktion zurückgesetzt (revert). Andernfalls wird es eingefroren und ein Ereignis per `emit` ausgegeben.
+
+- Ändern Sie `_beforeTokenTransfer`, um zu verhindern, dass Geld von einem eingefrorenen Konto bewegt wird. Beachten Sie, dass Geld weiterhin auf das eingefrorene Konto überwiesen werden kann.
+
+ ```solidity
+ require(!frozenAccounts[from], "Das Konto ist eingefroren");
+ ```
+
+### Asset-Bereinigung {#asset-cleanup}
+
+Um ERC-20-Token freizugeben, die von diesem Vertrag gehalten werden, müssen wir eine Funktion auf dem Token-Vertrag aufrufen, zu dem sie gehören, entweder [`transfer`](https://eips.ethereum.org/EIPS/eip-20#transfer) oder [`approve`](https://eips.ethereum.org/EIPS/eip-20#approve). Es hat keinen Sinn, in diesem Fall Gas für Freigaben (allowances) zu verschwenden, wir können genauso gut direkt übertragen.
+
+```solidity
+ function cleanupERC20(
+ address erc20,
+ address dest
+ )
+ public
+ onlyOwner
+ {
+ IERC20 token = IERC20(erc20);
+```
+
+Dies ist die Syntax, um ein Objekt für einen Vertrag zu erstellen, wenn wir die Adresse erhalten. Wir können dies tun, weil wir die Definition für ERC20-Token als Teil des Quellcodes haben (siehe Zeile 4), und diese Datei enthält [die Definition für IERC20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol), die Schnittstelle für einen OpenZeppelin ERC-20-Vertrag.
+
+```solidity
+ uint balance = token.balanceOf(address(this));
+ token.transfer(dest, balance);
+ }
+```
+
+Dies ist eine Bereinigungsfunktion, also wollen wir vermutlich keine Token übrig lassen. Anstatt den Saldo manuell vom Benutzer abzurufen, können wir den Prozess auch automatisieren.
+
+## Fazit {#conclusion}
+
+Dies ist keine perfekte Lösung – es gibt keine perfekte Lösung für das Problem \"Benutzer hat einen Fehler gemacht\". Die Verwendung dieser Art von Überprüfungen kann jedoch zumindest einige Fehler verhindern. Die Möglichkeit, Konten einzufrieren, ist zwar gefährlich, kann aber genutzt werden, um den Schaden bestimmter Hacks zu begrenzen, indem dem Hacker die gestohlenen Gelder verweigert werden.
+
+[Hier finden Sie mehr von meiner Arbeit](https://cryptodocguy.pro/).
diff --git a/public/content/translations/de/developers/tutorials/ethereum-for-web2-auth/index.md b/public/content/translations/de/developers/tutorials/ethereum-for-web2-auth/index.md
new file mode 100644
index 00000000000..0778a28d7dd
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/ethereum-for-web2-auth/index.md
@@ -0,0 +1,886 @@
+---
+title: Verwendung von Ethereum für die Web2-Authentifizierung
+description: Nach der Lektüre dieses Tutorials kann ein Entwickler die Ethereum-Anmeldung (Web3) in die SAML-Anmeldung integrieren, einen in Web2 verwendeten Standard zur Bereitstellung von Single Sign-On und anderen damit verbundenen Diensten. Dies ermöglicht die Authentifizierung des Zugriffs auf Web2-Ressourcen durch Ethereum-Signaturen, wobei die Benutzerattribute aus Attestierungen stammen.
+author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+tags: [ "web2", "authentifizierung", "eas" ]
+skill: beginner
+lang: de
+published: 2025-04-30
+---
+
+## Einführung
+
+[SAML](https://www.onelogin.com/learn/saml) ist ein in Web2 verwendeter Standard, der es einem [Identitätsanbieter (IdP)](https://en.wikipedia.org/wiki/Identity_provider#SAML_identity_provider) ermöglicht, Benutzerinformationen für [Dienstanbieter (SP)](https://en.wikipedia.org/wiki/Service_provider_\(SAML\)) bereitzustellen.
+
+In diesem Tutorial lernen Sie, wie Sie Ethereum-Signaturen in SAML integrieren, damit Benutzer ihre Ethereum-Wallets zur Authentifizierung bei Web2-Diensten verwenden können, die Ethereum noch nicht nativ unterstützen.
+
+Beachten Sie, dass dieses Tutorial für zwei verschiedene Zielgruppen geschrieben wurde:
+
+- Ethereum-Leute, die Ethereum verstehen und SAML lernen müssen
+- Web2-Leute, die SAML und die Web2-Authentifizierung verstehen und Ethereum lernen müssen
+
+Daher wird es eine Menge Einführungsmaterial enthalten, das Sie bereits kennen. Sie können es gerne überspringen.
+
+### SAML für Ethereum-Leute
+
+SAML ist ein zentralisiertes Protokoll. Ein Dienstanbieter (SP) akzeptiert nur dann Zusicherungen (z. B. „Dies ist mein Benutzer John, er sollte die Berechtigungen haben, A, B und C zu tun“) von einem Identitätsanbieter (IdP), wenn er eine bereits bestehende Vertrauensbeziehung entweder zu diesem oder zu der [Zertifizierungsstelle](https://www.ssl.com/article/what-is-a-certificate-authority-ca/) hat, die das Zertifikat dieses IdP unterzeichnet hat.
+
+Der SP kann beispielsweise ein Reisebüro sein, das Reisedienstleistungen für Unternehmen anbietet, und der IdP kann die interne Website eines Unternehmens sein. Wenn Mitarbeiter eine Geschäftsreise buchen müssen, schickt das Reisebüro sie zur Authentifizierung an das Unternehmen, bevor es sie tatsächlich die Reise buchen lässt.
+
+
+
+Auf diese Weise verhandeln die drei Entitäten, der Browser, der SP und der IdP, über den Zugriff. Der SP muss im Voraus nichts über den Benutzer wissen, der den Browser verwendet, sondern nur dem IdP vertrauen.
+
+### Ethereum für SAML-Leute
+
+Ethereum ist ein dezentralisiertes System.
+
+
+
+Benutzer haben einen privaten Schlüssel (in der Regel in einer Browser-Erweiterung). Aus dem privaten Schlüssel können Sie einen öffentlichen Schlüssel und daraus eine 20-Byte-Adresse ableiten. Wenn sich Benutzer in einem System anmelden müssen, werden sie aufgefordert, eine Nachricht mit einer Nonce (einem einmalig verwendbaren Wert) zu signieren. Der Server kann überprüfen, ob die Signatur von dieser Adresse erstellt wurde.
+
+
+
+Die Signatur verifiziert nur die Ethereum-Adresse. Um andere Benutzerattribute zu erhalten, verwenden Sie normalerweise [Attestierungen](https://attest.org/). Eine Attestierung hat normalerweise diese Felder:
+
+- **Attestierer**, die Adresse, die die Attestierung vorgenommen hat
+- **Empfänger**, die Adresse, für die die Attestierung gilt
+- **Daten**, die zu bescheinigenden Daten, wie Name, Berechtigungen usw.
+- **Schema**, die ID des Schemas, das zur Interpretation der Daten verwendet wird.
+
+Aufgrund der dezentralen Natur von Ethereum kann jeder Benutzer Attestierungen erstellen. Die Identität des Attestierers ist wichtig, um zu bestimmen, welche Attestierungen wir als zuverlässig betrachten.
+
+## Einrichtung
+
+Der erste Schritt besteht darin, einen SAML-SP und einen SAML-IdP zu haben, die miteinander kommunizieren.
+
+1. Laden Sie die Software herunter. Die Beispielsoftware für diesen Artikel ist [auf GitHub](https://github.com/qbzzt/250420-saml-ethereum) verfügbar. Verschiedene Phasen werden in verschiedenen Branches gespeichert, für diese Phase benötigen Sie `saml-only`
+
+ ```sh
+ git clone https://github.com/qbzzt/250420-saml-ethereum -b saml-only
+ cd 250420-saml-ethereum
+ pnpm install
+ ```
+
+2. Erstellen Sie Schlüssel mit selbstsignierten Zertifikaten. Das bedeutet, dass der Schlüssel seine eigene Zertifizierungsstelle ist und manuell beim Dienstanbieter importiert werden muss. Weitere Informationen finden Sie in den [OpenSSL-Dokumenten](https://docs.openssl.org/master/man1/openssl-req/).
+
+ ```sh
+ mkdir keys
+ cd keys
+ openssl req -new -x509 -days 365 -nodes -sha256 -out saml-sp.crt -keyout saml-sp.pem -subj /CN=sp/
+ openssl req -new -x509 -days 365 -nodes -sha256 -out saml-idp.crt -keyout saml-idp.pem -subj /CN=idp/
+ cd ..
+ ```
+
+3. Starten Sie die Server (sowohl SP als auch IdP)
+
+ ```sh
+ pnpm start
+ ```
+
+4. Navigieren Sie zum SP unter der URL [http://localhost:3000/](http://localhost:3000/) und klicken Sie auf die Schaltfläche, um zum IdP (Port 3001) weitergeleitet zu werden.
+
+5. Geben Sie dem IdP Ihre E-Mail-Adresse und klicken Sie auf **Beim Dienstanbieter anmelden**. Sehen Sie, dass Sie zum Dienstanbieter (Port 3000) zurückgeleitet werden und dass dieser Sie anhand Ihrer E-Mail-Adresse erkennt.
+
+### Detaillierte Erklärung
+
+Folgendes geschieht Schritt für Schritt:
+
+
+
+#### src/config.mts
+
+Diese Datei enthält die Konfiguration sowohl für den Identitätsanbieter als auch für den Dienstanbieter. Normalerweise wären dies zwei verschiedene Entitäten, aber hier können wir der Einfachheit halber Code gemeinsam nutzen.
+
+```typescript
+const fs = await import("fs")
+
+const protocol="http"
+```
+
+Im Moment testen wir nur, daher ist die Verwendung von HTTP in Ordnung.
+
+```typescript
+export const spCert = fs.readFileSync("keys/saml-sp.crt").toString()
+export const idpCert = fs.readFileSync("keys/saml-idp.crt").toString()
+```
+
+Lesen Sie die öffentlichen Schlüssel, die normalerweise beiden Komponenten zur Verfügung stehen (und denen entweder direkt vertraut wird oder die von einer vertrauenswürdigen Zertifizierungsstelle signiert sind).
+
+```typescript
+export const spPort = 3000
+export const spHostname = "localhost"
+export const spDir = "sp"
+
+export const idpPort = 3001
+export const idpHostname = "localhost"
+export const idpDir = "idp"
+
+export const spUrl = `${protocol}://${spHostname}:${spPort}/${spDir}`
+export const idpUrl = `${protocol}://${idpHostname}:${idpPort}/${idpDir}`
+```
+
+Die URLs für beide Komponenten.
+
+```typescript
+export const spPublicData = {
+```
+
+Die öffentlichen Daten für den Dienstanbieter.
+
+```typescript
+ entityID: `${spUrl}/metadata`,
+```
+
+Konventionell ist in SAML die `entityID` die URL, unter der die Metadaten der Entität verfügbar sind. Diese Metadaten entsprechen den hier vorliegenden öffentlichen Daten, außer dass sie in XML-Form vorliegen.
+
+```typescript
+ wantAssertionsSigned: true,
+ authnRequestsSigned: false,
+ signingCert: spCert,
+ allowCreate: true,
+ assertionConsumerService: [{
+ Binding: 'urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST',
+ Location: `${spUrl}/assertion`,
+ }]
+ }
+```
+
+Die wichtigste Definition für unsere Zwecke ist der `assertionConsumerServer`. Das bedeutet, dass wir, um etwas gegenüber dem Dienstanbieter zu behaupten (z. B. „Der Benutzer, der Ihnen diese Informationen sendet, ist jemand@example.com“), einen [HTTP-POST](https://www.w3schools.com/tags/ref_httpmethods.asp) an die URL `http://localhost:3000/sp/assertion` verwenden müssen.
+
+```typescript
+export const idpPublicData = {
+ entityID: `${idpUrl}/metadata`,
+ signingCert: idpCert,
+ wantAuthnRequestsSigned: false,
+ singleSignOnService: [{
+ Binding: "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST",
+ Location: `${idpUrl}/login`
+ }],
+ singleLogoutService: [{
+ Binding: "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST",
+ Location: `${idpUrl}/logout`
+ }],
+ }
+```
+
+Die öffentlichen Daten für den Identitätsanbieter sind ähnlich. Es gibt an, dass Sie zum Anmelden eines Benutzers einen POST an `http://localhost:3001/idp/login` und zum Abmelden eines Benutzers einen POST an `http://localhost:3001/idp/logout` senden.
+
+#### src/sp.mts
+
+Dies ist der Code, der einen Dienstanbieter implementiert.
+
+```typescript
+import * as config from "./config.mts"
+const fs = await import("fs")
+const saml = await import("samlify")
+```
+
+Wir verwenden die Bibliothek [`samlify`](https://www.npmjs.com/package/samlify), um SAML zu implementieren.
+
+```typescript
+import * as validator from "@authenio/samlify-node-xmllint"
+saml.setSchemaValidator(validator)
+```
+
+Die `samlify`-Bibliothek erwartet ein Paket, das validiert, dass das XML korrekt ist, mit dem erwarteten öffentlichen Schlüssel signiert ist usw. Wir verwenden [`@authenio/samlify-node-xmllint`](https://www.npmjs.com/package/@authenio/samlify-node-xmllint) für diesen Zweck.
+
+```typescript
+const express = (await import("express")).default
+const spRouter = express.Router()
+const app = express()
+```
+
+Ein [`express`](https://expressjs.com/)-[`Router`](https://expressjs.com/en/5x/api.html#router) ist eine „Mini-Website“, die innerhalb einer Website eingebunden werden kann. In diesem Fall verwenden wir ihn, um alle Definitionen des Dienstanbieters zusammenzufassen.
+
+```typescript
+const spPrivateKey = fs.readFileSync("keys/saml-sp.pem").toString()
+
+const sp = saml.ServiceProvider({
+ privateKey: spPrivateKey,
+ ...config.spPublicData
+})
+```
+
+Die Eigendarstellung des Dienstanbieters besteht aus allen öffentlichen Daten und dem privaten Schlüssel, den er zum Signieren von Informationen verwendet.
+
+```typescript
+const idp = saml.IdentityProvider(config.idpPublicData);
+```
+
+Die öffentlichen Daten enthalten alles, was der Dienstanbieter über den Identitätsanbieter wissen muss.
+
+```typescript
+spRouter.get(`/metadata`,
+ (req, res) => res.header("Content-Type", "text/xml").send(sp.getMetadata())
+)
+```
+
+Um die Interoperabilität mit anderen SAML-Komponenten zu ermöglichen, sollten Dienst- und Identitätsanbieter ihre öffentlichen Daten (die Metadaten) im XML-Format unter `/metadata` zur Verfügung stellen.
+
+```typescript
+spRouter.post(`/assertion`,
+```
+
+Dies ist die Seite, auf die der Browser zugreift, um sich zu identifizieren. Die Zusicherung enthält die Benutzerkennung (hier verwenden wir die E-Mail-Adresse) und kann zusätzliche Attribute enthalten. Dies ist der Handler für Schritt 7 im obigen Sequenzdiagramm.
+
+```typescript
+ async (req, res) => {
+ // console.log(`SAML response:\n${Buffer.from(req.body.SAMLResponse, 'base64').toString('utf-8')})
+```
+
+Sie können den auskommentierten Befehl verwenden, um die in der Zusicherung bereitgestellten XML-Daten zu sehen. Sie ist [Base64-kodiert](https://en.wikipedia.org/wiki/Base64).
+
+```typescript
+ try {
+ const loginResponse = await sp.parseLoginResponse(idp, 'post', req);
+```
+
+Analysieren Sie die Anmeldeanforderung vom Identitätsserver.
+
+```typescript
+ res.send(`
+
+
+ Hallo ${loginResponse.extract.nameID}
+
+
+ `)
+ res.send();
+```
+
+Senden Sie eine HTML-Antwort, nur um dem Benutzer zu zeigen, dass wir die Anmeldung erhalten haben.
+
+```typescript
+ } catch (err) {
+ console.error('Fehler bei der Verarbeitung der SAML-Antwort:', err);
+ res.status(400).send('SAML-Authentifizierung fehlgeschlagen');
+ }
+ }
+)
+```
+
+Informieren Sie den Benutzer im Falle eines Fehlers.
+
+```typescript
+spRouter.get('/login',
+```
+
+Erstellen Sie eine Anmeldeanforderung, wenn der Browser versucht, diese Seite aufzurufen. Dies ist der Handler für Schritt 1 im obigen Sequenzdiagramm.
+
+```typescript
+ async (req, res) => {
+ const loginRequest = await sp.createLoginRequest(idp, "post")
+```
+
+Holen Sie sich die Informationen, um eine Anmeldeanforderung zu posten.
+
+```typescript
+ res.send(`
+
+
+
+```
+
+Diese Seite sendet das Formular (siehe unten) automatisch ab. Auf diese Weise muss der Benutzer nichts tun, um weitergeleitet zu werden. Dies ist Schritt 2 im obigen Sequenzdiagramm.
+
+```typescript
+
+
+
+ `)
+ }
+)
+
+app.use(express.urlencoded({extended: true}))
+```
+
+[Diese Middleware](https://expressjs.com/en/5x/api.html#express.urlencoded) liest den Body der [HTTP-Anfrage](https://www.tutorialspoint.com/http/http_requests.htm). Standardmäßig ignoriert Express ihn, da die meisten Anfragen ihn nicht benötigen. Wir brauchen ihn, weil POST den Body verwendet.
+
+```typescript
+app.use(`/${config.spDir}`, spRouter)
+```
+
+Binden Sie den Router im Verzeichnis des Dienstanbieters (`/sp`) ein.
+
+```typescript
+app.get("/", (req, res) => {
+ res.send(`
+
+
+
+
+
+ `)
+})
+```
+
+Wenn ein Browser versucht, das Stammverzeichnis aufzurufen, stellen Sie ihm einen Link zur Anmeldeseite zur Verfügung.
+
+```typescript
+app.listen(config.spPort, () => {
+ console.log(`Dienstanbieter läuft auf http://${config.spHostname}:${config.spPort}`)
+})
+```
+
+Hören Sie mit dieser Express-Anwendung auf den `spPort`.
+
+#### src/idp.mts
+
+Dies ist der Identitätsanbieter. Er ist dem Dienstanbieter sehr ähnlich, die folgenden Erklärungen beziehen sich auf die Teile, die sich unterscheiden.
+
+```typescript
+const xmlParser = new (await import("fast-xml-parser")).XMLParser(
+ {
+ ignoreAttributes: false, // Attribute beibehalten
+ attributeNamePrefix: "@_", // Präfix für Attribute
+ }
+)
+```
+
+Wir müssen die XML-Anforderung, die wir vom Dienstanbieter erhalten, lesen und verstehen.
+
+```typescript
+const getLoginPage = requestId => `
+```
+
+Diese Funktion erstellt die Seite mit dem automatisch übermittelten Formular, das in Schritt 4 des obigen Sequenzdiagramms zurückgegeben wird.
+
+```typescript
+
+
+ Anmeldeseite
+
+
+ Anmeldeseite
+
+
+
+
+const idpRouter = express.Router()
+
+idpRouter.post("/loginSubmitted", async (req, res) => {
+ const loginResponse = await idp.createLoginResponse(
+```
+
+Dies ist der Handler für Schritt 5 des obigen Sequenzdiagramms. [`idp.createLoginResponse`](https://github.com/tngan/samlify/blob/master/src/entity-idp.ts#L73-L125) erstellt die Anmeldeantwort.
+
+```typescript
+ sp,
+ {
+ authnContextClassRef: 'urn:oasis:names:tc:SAML:2.0:ac:classes:PasswordProtectedTransport',
+ audience: sp.entityID,
+```
+
+Die Zielgruppe ist der Dienstanbieter.
+
+```typescript
+ extract: {
+ request: {
+ id: req.body.requestId
+ }
+ },
+```
+
+Aus der Anfrage extrahierte Informationen. Der einzige Parameter, der uns in der Anfrage interessiert, ist die requestId, die es dem Dienstanbieter ermöglicht, Anfragen und deren Antworten zuzuordnen.
+
+```typescript
+ signingKey: { privateKey: idpPrivateKey, publicKey: config.idpCert } // Signierung sicherstellen
+```
+
+Wir benötigen `signingKey`, um die Daten zum Signieren der Antwort zu haben. Der Dienstanbieter vertraut keinen unsignierten Anfragen.
+
+```typescript
+ },
+ "post",
+ {
+ email: req.body.email
+```
+
+Dies ist das Feld mit den Benutzerinformationen, die wir an den Dienstanbieter zurücksenden.
+
+```typescript
+ }
+ );
+
+ res.send(`
+
+
+
+
+
+
+
+ `)
+})
+```
+
+Verwenden Sie erneut ein automatisch übermitteltes Formular. Dies ist Schritt 6 im obigen Sequenzdiagramm.
+
+```typescript
+
+// IdP-Endpunkt für Anmeldeanforderungen
+idpRouter.post(`/login`,
+```
+
+Dies ist der Endpunkt, der eine Anmeldeanforderung vom Dienstanbieter empfängt. Dies ist der Handler für Schritt 3 des obigen Sequenzdiagramms.
+
+```typescript
+ async (req, res) => {
+ try {
+ // Workaround, weil ich parseLoginRequest nicht zum Laufen bringen konnte.
+ // const loginRequest = await idp.parseLoginRequest(sp, 'post', req)
+ const samlRequest = xmlParser.parse(Buffer.from(req.body.SAMLRequest, 'base64').toString('utf-8'))
+ res.send(getLoginPage(samlRequest["samlp:AuthnRequest"]["@_ID"]))
+```
+
+Wir sollten [`idp.parseLoginRequest`](https://github.com/tngan/samlify/blob/master/src/entity-idp.ts#L127-L144) verwenden können, um die ID der Authentifizierungsanforderung zu lesen. Ich konnte es jedoch nicht zum Laufen bringen und es war nicht wert, viel Zeit damit zu verbringen, also verwende ich einfach einen [allgemeinen XML-Parser](https://www.npmjs.com/package/fast-xml-parser). Die Information, die wir benötigen, ist das `ID`-Attribut innerhalb des ``-Tags, das sich auf der obersten Ebene des XML befindet.
+
+## Verwendung von Ethereum-Signaturen
+
+Nachdem wir nun eine Benutzeridentität an den Dienstanbieter senden können, besteht der nächste Schritt darin, die Benutzeridentität auf vertrauenswürdige Weise zu erhalten. Viem ermöglicht es uns, die Wallet einfach nach der Benutzeradresse zu fragen, aber das bedeutet, den Browser nach den Informationen zu fragen. Wir kontrollieren den Browser nicht, daher können wir der Antwort, die wir von ihm erhalten, nicht automatisch vertrauen.
+
+Stattdessen wird der IdP dem Browser eine zu signierende Zeichenfolge senden. Wenn die Wallet im Browser diese Zeichenfolge signiert, bedeutet dies, dass es sich wirklich um diese Adresse handelt (d. h. sie kennt den privaten Schlüssel, der der Adresse entspricht).
+
+Um dies in Aktion zu sehen, stoppen Sie den vorhandenen IdP und SP und führen Sie diese Befehle aus:
+
+```sh
+git checkout eth-signatures
+pnpm install
+pnpm start
+```
+
+Navigieren Sie dann [zum SP](http://localhost:3000) und folgen Sie den Anweisungen.
+
+Beachten Sie, dass wir an dieser Stelle nicht wissen, wie wir die E-Mail-Adresse aus der Ethereum-Adresse erhalten, also melden wir stattdessen `@bad.email.address` an den SP.
+
+### Detaillierte Erklärung
+
+Die Änderungen befinden sich in den Schritten 4-5 des vorherigen Diagramms.
+
+
+
+Die einzige Datei, die wir geändert haben, ist `idp.mts`. Hier sind die geänderten Teile.
+
+```typescript
+import { v4 as uuidv4 } from 'uuid'
+import { verifyMessage } from 'viem'
+```
+
+Wir benötigen diese beiden zusätzlichen Bibliotheken. Wir verwenden [`uuid`](https://www.npmjs.com/package/uuid), um den [Nonce](https://en.wikipedia.org/wiki/Cryptographic_nonce)-Wert zu erstellen. Der Wert selbst spielt keine Rolle, nur die Tatsache, dass er nur einmal verwendet wird.
+
+Die Bibliothek [`viem`](https://viem.sh/) ermöglicht es uns, Ethereum-Definitionen zu verwenden. Hier benötigen wir sie, um zu überprüfen, ob die Signatur tatsächlich gültig ist.
+
+```typescript
+const loginPrompt = "Um auf den Dienstanbieter zuzugreifen, signieren Sie diese Nonce: "
+```
+
+Die Wallet bittet den Benutzer um die Erlaubnis, die Nachricht zu signieren. Eine Nachricht, die nur eine Nonce ist, könnte Benutzer verwirren, daher fügen wir diese Aufforderung hinzu.
+
+```typescript
+// requestIDs hier aufbewahren
+let nonces = {}
+```
+
+Wir benötigen die Anfrageinformationen, um darauf antworten zu können. Wir könnten sie mit der Anfrage (Schritt 4) senden und sie zurückerhalten (Schritt 5). Wir können jedoch den Informationen, die wir vom Browser erhalten, nicht vertrauen, da dieser unter der Kontrolle eines potenziell feindseligen Benutzers steht. Daher ist es besser, sie hier mit der Nonce als Schlüssel zu speichern.
+
+Beachten Sie, dass wir dies der Einfachheit halber hier als Variable tun. Dies hat jedoch mehrere Nachteile:
+
+- Wir sind anfällig für einen Denial-of-Service-Angriff. Ein böswilliger Benutzer könnte versuchen, sich mehrmals anzumelden und so unseren Speicher zu füllen.
+- Wenn der IdP-Prozess neu gestartet werden muss, verlieren wir die vorhandenen Werte.
+- Wir können keinen Lastenausgleich über mehrere Prozesse durchführen, da jeder seine eigene Variable hätte.
+
+Auf einem Produktionssystem würden wir eine Datenbank verwenden und eine Art Ablaufmechanismus implementieren.
+
+```typescript
+const getSignaturePage = requestId => {
+ const nonce = uuidv4()
+ nonces[nonce] = requestId
+```
+
+Erstellen Sie eine Nonce und speichern Sie die `requestId` für die zukünftige Verwendung.
+
+```typescript
+ return `
+
+
+
+
+
+ Bitte signieren
+
+
+
+
+
+`
+}
+```
+
+Der Rest ist nur Standard-HTML.
+
+```typescript
+idpRouter.get("/signature/:nonce/:account/:signature", async (req, res) => {
+```
+
+Dies ist der Handler für Schritt 5 im Sequenzdiagramm.
+
+```typescript
+ const requestId = nonces[req.params.nonce]
+ if (requestId === undefined) {
+ res.send("Schlechte Nonce")
+ return ;
+ }
+
+ nonces[req.params.nonce] = undefined
+```
+
+Holen Sie sich die Anfrage-ID und löschen Sie die Nonce aus den `nonces`, um sicherzustellen, dass sie nicht wiederverwendet werden kann.
+
+```typescript
+ try {
+```
+
+Da es so viele Möglichkeiten gibt, wie die Signatur ungültig sein kann, umschließen wir dies in einem `try ...` `catch`-Block, um alle geworfenen Fehler abzufangen.
+
+```typescript
+ const validSignature = await verifyMessage({
+ address: req.params.account,
+ message: `${loginPrompt}${req.params.nonce}`,
+ signature: req.params.signature
+ })
+```
+
+Verwenden Sie [`verifyMessage`](https://viem.sh/docs/actions/public/verifyMessage#verifymessage), um Schritt 5.5 im Sequenzdiagramm zu implementieren.
+
+```typescript
+ if (!validSignature)
+ throw("Schlechte Signatur")
+ } catch (err) {
+ res.send("Fehler:" + err)
+ return ;
+ }
+```
+
+Der Rest des Handlers ist äquivalent zu dem, was wir zuvor im `/loginSubmitted`-Handler getan haben, mit Ausnahme einer kleinen Änderung.
+
+```typescript
+ const loginResponse = await idp.createLoginResponse(
+ .
+ .
+ .
+ {
+ email: req.params.account + "@bad.email.address"
+ }
+ );
+```
+
+Wir haben nicht die tatsächliche E-Mail-Adresse (wir werden sie im nächsten Abschnitt erhalten), also geben wir vorerst die Ethereum-Adresse zurück und kennzeichnen sie deutlich als keine E-Mail-Adresse.
+
+```typescript
+// IdP-Endpunkt für Anmeldeanforderungen
+idpRouter.post(`/login`,
+ async (req, res) => {
+ try {
+ // Workaround, weil ich parseLoginRequest nicht zum Laufen bringen konnte.
+ // const loginRequest = await idp.parseLoginRequest(sp, 'post', req)
+ const samlRequest = xmlParser.parse(Buffer.from(req.body.SAMLRequest, 'base64').toString('utf-8'))
+ res.send(getSignaturePage(samlRequest["samlp:AuthnRequest"]["@_ID"]))
+ } catch (err) {
+ console.error('Fehler bei der Verarbeitung der SAML-Antwort:', err);
+ res.status(400).send('SAML-Authentifizierung fehlgeschlagen');
+ }
+ }
+)
+```
+
+Verwenden Sie jetzt anstelle von `getLoginPage` `getSignaturePage` im Handler für Schritt 3.
+
+## Abrufen der E-Mail-Adresse
+
+Der nächste Schritt ist das Abrufen der E-Mail-Adresse, der vom Dienstanbieter angeforderten Kennung. Dazu verwenden wir den [Ethereum Attestation Service (EAS)](https://attest.org/).
+
+Der einfachste Weg, Attestierungen zu erhalten, ist die Verwendung der [GraphQL-API](https://docs.attest.org/docs/developer-tools/api). Wir verwenden diese Abfrage:
+
+```
+query GetAttestationsByRecipient {
+ attestations(
+ where: {
+ recipient: { equals: "${getAddress(ethAddr)}" }
+ schemaId: { equals: "0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977" }
+ }
+ take: 1
+ ) {
+ data
+ id
+ attester
+ }
+}
+```
+
+Diese [`schemaId`](https://optimism.easscan.org/schema/view/0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977) enthält nur eine E-Mail-Adresse. Diese Abfrage fragt nach Attestierungen dieses Schemas. Das Subjekt der Attestierung wird als `Empfänger` bezeichnet. Es ist immer eine Ethereum-Adresse.
+
+Warnung: Die Art und Weise, wie wir hier Attestierungen erhalten, hat zwei Sicherheitsprobleme.
+
+- Wir greifen auf den API-Endpunkt `https://optimism.easscan.org/graphql` zu, der eine zentralisierte Komponente ist. Wir können das `id`-Attribut erhalten und dann eine On-Chain-Abfrage durchführen, um zu überprüfen, ob eine Attestierung echt ist, aber der API-Endpunkt kann immer noch Attestierungen zensieren, indem er uns nicht darüber informiert.
+
+ Dieses Problem ist nicht unlösbar, wir könnten unseren eigenen GraphQL-Endpunkt betreiben und die Attestierungen aus den Chain-Logs abrufen, aber das ist für unsere Zwecke übertrieben.
+
+- Wir schauen nicht auf die Identität des Attestierers. Jeder kann uns falsche Informationen liefern. In einer realen Implementierung hätten wir eine Reihe vertrauenswürdiger Attestierer und würden nur deren Attestierungen betrachten.
+
+Um dies in Aktion zu sehen, stoppen Sie den vorhandenen IdP und SP und führen Sie diese Befehle aus:
+
+```sh
+git checkout email-address
+pnpm install
+pnpm start
+```
+
+Geben Sie dann Ihre E-Mail-Adresse an. Sie haben zwei Möglichkeiten, dies zu tun:
+
+- Importieren Sie eine Wallet mit einem privaten Schlüssel und verwenden Sie den privaten Testschlüssel `0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80`.
+
+- Fügen Sie eine Attestierung für Ihre eigene E-Mail-Adresse hinzu:
+
+ 1. Navigieren Sie zu [dem Schema im Attestierungs-Explorer](https://optimism.easscan.org/schema/view/0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977).
+
+ 2. Klicken Sie auf **Mit Schema attestieren**.
+
+ 3. Geben Sie Ihre Ethereum-Adresse als Empfänger und Ihre E-Mail-Adresse als E-Mail-Adresse ein und wählen Sie **On-Chain**. Klicken Sie dann auf **Attestierung erstellen**.
+
+ 4. Genehmigen Sie die Transaktion in Ihrer Wallet. Sie benötigen etwas ETH auf der [Optimism Blockchain](https://app.optimism.io/bridge/deposit), um für Gas zu bezahlen.
+
+So oder so, navigieren Sie danach zu [http://localhost:3000](http://localhost:3000) und folgen Sie den Anweisungen. Wenn Sie den privaten Testschlüssel importiert haben, lautet die E-Mail, die Sie erhalten, `test_addr_0@example.com`. Wenn Sie Ihre eigene Adresse verwendet haben, sollte es das sein, was Sie attestiert haben.
+
+### Detaillierte Erklärung
+
+
+
+Die neuen Schritte sind die GraphQL-Kommunikation, Schritte 5.6 und 5.7.
+
+Auch hier sind die geänderten Teile von `idp.mts`.
+
+```typescript
+import { GraphQLClient } from 'graphql-request'
+import { SchemaEncoder } from '@ethereum-attestation-service/eas-sdk'
+```
+
+Importieren Sie die Bibliotheken, die wir benötigen.
+
+```typescript
+const graphqlEndpointUrl = "https://optimism.easscan.org/graphql"
+```
+
+Es gibt [einen separaten Endpunkt für jede Blockchain](https://docs.attest.org/docs/developer-tools/api).
+
+```typescript
+const graphqlClient = new GraphQLClient(graphqlEndpointUrl, { fetch })
+```
+
+Erstellen Sie einen neuen `GraphQLClient`-Client, den wir zur Abfrage des Endpunkts verwenden können.
+
+```typescript
+const graphqlSchema = 'string emailAddress'
+const graphqlEncoder = new SchemaEncoder(graphqlSchema)
+```
+
+GraphQL gibt uns nur ein undurchsichtiges Datenobjekt mit Bytes. Um es zu verstehen, benötigen wir das Schema.
+
+```typescript
+const ethereumAddressToEmail = async ethAddr => {
+```
+
+Eine Funktion, um von einer Ethereum-Adresse zu einer E-Mail-Adresse zu gelangen.
+
+```typescript
+ const query = `
+ query GetAttestationsByRecipient {
+```
+
+Dies ist eine GraphQL-Abfrage.
+
+```typescript
+ Attestierungen(
+```
+
+Wir suchen nach Attestierungen.
+
+```typescript
+ where: {
+ recipient: { equals: "${getAddress(ethAddr)}" }
+ schemaId: { equals: "0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977" }
+ }
+```
+
+Die Attestierungen, die wir wollen, sind diejenigen in unserem Schema, bei denen der Empfänger `getAddress(ethAddr)` ist. Die Funktion [`getAddress`](https://viem.sh/docs/utilities/getAddress#getaddress) stellt sicher, dass unsere Adresse die korrekte [Prüfsumme](https://github.com/ethereum/ercs/blob/master/ERCS/erc-55.md) hat. Dies ist notwendig, da bei GraphQL die Groß- und Kleinschreibung beachtet wird. "0xBAD060A7", "0xBad060A7" und "0xbad060a7" sind verschiedene Werte.
+
+```typescript
+ take: 1
+```
+
+Unabhängig davon, wie viele Attestierungen wir finden, wollen wir nur die erste.
+
+```typescript
+ ) {
+ data
+ id
+ attester
+ }
+ }`
+```
+
+Die Felder, die wir empfangen wollen.
+
+- `attester`: Die Adresse, die die Attestierung eingereicht hat. Normalerweise wird dies verwendet, um zu entscheiden, ob der Attestierung vertraut werden soll oder nicht.
+- `id`: Die Attestierungs-ID. Sie können diesen Wert verwenden, um [die Attestierung On-Chain zu lesen](https://optimism.blockscout.com/address/0x4200000000000000000000000000000000000021?tab=read_proxy&source_address=0x4E0275Ea5a89e7a3c1B58411379D1a0eDdc5b088#0xa3112a64) und zu überprüfen, ob die Informationen aus der GraphQL-Abfrage korrekt sind.
+- `data`: Die Schemadaten (in diesem Fall die E-Mail-Adresse).
+
+```typescript
+ const queryResult = await graphqlClient.request(query)
+
+ if (queryResult.attestations.length == 0)
+ return "no_address@available.is"
+```
+
+Wenn keine Attestierung vorhanden ist, geben Sie einen Wert zurück, der offensichtlich falsch ist, aber für den Dienstanbieter gültig erscheinen würde.
+
+```typescript
+ const attestationDataFields = graphqlEncoder.decodeData(queryResult.attestations[0].data)
+ return attestationDataFields[0].value.value
+}
+```
+
+Wenn ein Wert vorhanden ist, verwenden Sie `decodeData`, um die Daten zu dekodieren. Wir benötigen nicht die Metadaten, die es bereitstellt, sondern nur den Wert selbst.
+
+```typescript
+ const loginResponse = await idp.createLoginResponse(
+ sp,
+ {
+ .
+ .
+ .
+ },
+ "post",
+ {
+ email: await ethereumAddressToEmail(req.params.account)
+ }
+ );
+```
+
+Verwenden Sie die neue Funktion, um die E-Mail-Adresse abzurufen.
+
+## Was ist mit der Dezentralisierung?
+
+In dieser Konfiguration können sich Benutzer nicht als jemand ausgeben, der sie nicht sind, solange wir uns auf vertrauenswürdige Attestierer für die Zuordnung von Ethereum- zu E-Mail-Adressen verlassen. Unser Identitätsanbieter ist jedoch immer noch eine zentralisierte Komponente. Wer den privaten Schlüssel des Identitätsanbieters besitzt, kann falsche Informationen an den Dienstanbieter senden.
+
+Es könnte eine Lösung geben, die [Mehrparteienberechnung (MPC)](https://en.wikipedia.org/wiki/Secure_multi-party_computation) verwendet. Ich hoffe, in einem zukünftigen Tutorial darüber zu schreiben.
+
+## Zusammenfassung
+
+Die Einführung eines Anmeldestandards wie Ethereum-Signaturen steht vor einem Henne-Ei-Problem. Dienstanbieter wollen den größtmöglichen Markt ansprechen. Benutzer möchten auf Dienste zugreifen können, ohne sich Gedanken über die Unterstützung ihres Anmeldestandards machen zu müssen.
+Die Erstellung von Adaptern, wie z. B. einem Ethereum-IdP, kann uns helfen, diese Hürde zu überwinden.
+
+[Hier finden Sie mehr von meiner Arbeit](https://cryptodocguy.pro/).
diff --git a/public/content/translations/de/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md b/public/content/translations/de/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md
new file mode 100644
index 00000000000..8396f5b36e0
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md
@@ -0,0 +1,156 @@
+---
+title: Erste Schritte in der Ethereum-Entwicklung
+description: "Dies ist ein Leitfaden für Einsteiger in die Ethereum-Entwicklung. Wir führen dich vom Einrichten eines API-Endpunkts über eine Befehlszeilenanforderung bis hin zum Schreiben deines ersten Web3-Skripts! Es sind keine Vorkenntnisse in der Blockchain-Entwicklung erforderlich!"
+author: "Elan Halpern"
+tags:
+ [
+ "javascript",
+ "ethers.js",
+ "Nodes",
+ "Abfragen",
+ "Alchemy"
+ ]
+skill: beginner
+lang: de
+published: 2020-10-30
+source: Mittel
+sourceUrl: https://medium.com/alchemy-api/getting-started-with-ethereum-development-using-alchemy-c3d6a45c567f
+---
+
+
+
+Dies ist ein Anfängerleitfaden für den Einstieg in die Ethereum-Entwicklung. Für dieses Tutorial verwenden wir [Alchemy](https://alchemyapi.io/), die führende Blockchain-Entwicklerplattform, die Millionen von Nutzern von 70 % der Top-Blockchain-Apps wie Maker, 0x, MyEtherWallet, Dharma und Kyber antreibt. Alchemy gibt uns Zugriff auf einen API-Endpunkt auf der Ethereum-Chain, damit wir Transaktionen lesen und schreiben können.
+
+Wir zeigen dir alle Schritte von der Anmeldung bei Alchemy bis hin zum Schreiben deines ersten Web3-Skripts! Es sind keine Vorkenntnisse in der Blockchain-Entwicklung erforderlich!
+
+## 1. Registriere dich für ein kostenloses Alchemy-Konto {#sign-up-for-a-free-alchemy-account}
+
+Ein Konto bei Alchemy zu erstellen ist einfach, [registriere dich hier kostenlos](https://auth.alchemy.com/).
+
+## 2. Erstelle eine Alchemy-App {#create-an-alchemy-app}
+
+Um mit der Ethereum-Chain zu kommunizieren und die Produkte von Alchemy zu nutzen, benötigst du einen API-Schlüssel, um deine Anfragen zu authentifizieren.
+
+Du kannst [API-Schlüssel über das Dashboard erstellen](https://dashboard.alchemy.com/). Um einen neuen Schlüssel zu erstellen, navigiere zu „App erstellen“, wie unten gezeigt:
+
+Besonderer Dank an [_ShapeShift_](https://shapeshift.com/), _dass wir ihr Dashboard zeigen dürfen!_
+
+
+
+Fülle die Details unter „App erstellen“ aus, um deinen neuen Schlüssel zu erhalten. Hier kannst du auch Apps sehen, die du zuvor erstellt hast, und solche, die von deinem Team erstellt wurden. Bestehende Schlüssel rufst du ab, indem du bei einer beliebigen App auf „Schlüssel anzeigen“ klickst.
+
+
+
+Du kannst auch bestehende API-Schlüssel abrufen, indem du mit der Maus über „Apps“ fährst und eine auswählst. Hier kannst du den „Schlüssel anzeigen“ sowie die „App bearbeiten“, um bestimmte Domains auf die Whitelist zu setzen, mehrere Entwicklertools anzuzeigen und Analysen einzusehen.
+
+
+
+## 3. Eine Anfrage über die Befehlszeile stellen {#make-a-request-from-the-command-line}
+
+Interagiere mit der Ethereum-Blockchain über Alchemy mithilfe von JSON-RPC und curl.
+
+Für manuelle Anfragen empfehlen wir die Interaktion mit `JSON-RPC` über `POST`-Anfragen. Übergebe einfach den Header `Content-Type: application/json` und deine Anfrage als `POST`-Body mit den folgenden Feldern:
+
+- `jsonrpc`: Die JSON-RPC-Version – derzeit wird nur `2.0` unterstützt.
+- `method`: Die ETH-API-Methode. [Siehe API-Referenz.](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc)
+- `params`: Eine Liste von Parametern, die an die Methode übergeben werden.
+- `id`: Die ID deiner Anfrage. Wird mit der Antwort zurückgegeben, damit du verfolgen kannst, zu welcher Anfrage eine Antwort gehört.
+
+Hier ist ein Beispiel, das du in der Befehlszeile ausführen kannst, um den aktuellen Gaspreis abzurufen:
+
+```bash
+curl https://eth-mainnet.alchemyapi.io/v2/demo \
+-X POST \
+-H "Content-Type: application/json" \
+-d '{"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":73}'
+```
+
+_**HINWEIS:** Ersetze [https://eth-mainnet.alchemyapi.io/v2/demo](https://eth-mainnet.alchemyapi.io/jsonrpc/demo) durch deinen eigenen API-Schlüssel `https://eth-mainnet.alchemyapi.io/v2/**your-api-key`._
+
+**Ergebnisse:**
+
+```json
+{ "id": 73,"jsonrpc": "2.0","result": "0x09184e72a000" // 10000000000000 }
+```
+
+## 4. Richte deinen Web3-Client ein {#set-up-your-web3-client}
+
+**Wenn du bereits einen Client hast,** ändere die URL deines aktuellen Node Providers in eine Alchemy-URL mit deinem API-Schlüssel: `"https://eth-mainnet.alchemyapi.io/v2/your-api-key"`
+
+**_HINWEIS:_** Die folgenden Skripte müssen in einem **Node-Kontext** ausgeführt oder **in einer Datei gespeichert werden**, nicht über die Befehlszeile. Wenn du Node oder npm noch nicht installiert hast, sieh dir diese kurze [Einrichtungsanleitung für Macs](https://app.gitbook.com/@alchemyapi/s/alchemy/guides/alchemy-for-macs) an.
+
+Es gibt eine Vielzahl von [Web3-Bibliotheken](https://docs.alchemyapi.io/guides/getting-started#other-web3-libraries), die du mit Alchemy integrieren kannst. Wir empfehlen jedoch [Alchemy Web3](https://docs.alchemy.com/reference/api-overview) zu verwenden, einen Drop-in-Ersatz für web3.js, der für die nahtlose Zusammenarbeit mit Alchemy entwickelt und konfiguriert wurde. Dies bietet mehrere Vorteile, wie z. B. automatische Wiederholungsversuche und eine robuste WebSocket-Unterstützung.
+
+Um AlchemyWeb3.js zu installieren, **navigiere zu deinem Projektverzeichnis** und führe aus:
+
+**Mit Yarn:**
+
+```
+yarn add @alch/alchemy-web3
+```
+
+**Mit NPM:**
+
+```
+npm install @alch/alchemy-web3
+```
+
+Um mit der Knoten-Infrastruktur von Alchemy zu interagieren, führe dies in NodeJS aus oder füge es zu einer JavaScript-Datei hinzu:
+
+```js
+const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
+const web3 = createAlchemyWeb3(
+ "https://eth-mainnet.alchemyapi.io/v2/your-api-key"
+)
+```
+
+## 5. Schreibe dein erstes Web3-Skript! {#write-your-first-web3-script}
+
+Machen wir uns nun mit ein wenig Web3-Programmierung die Hände schmutzig und schreiben ein einfaches Skript, das die neueste Blocknummer aus dem Ethereum Mainnet ausgibt.
+
+**1. Wenn du es noch nicht getan hast, erstelle in deinem Terminal ein neues Projektverzeichnis und wechsle mit cd hinein:**
+
+```
+mkdir web3-example
+cd web3-example
+```
+
+**2. Installiere die Alchemy Web3 (oder eine andere Web3) Abhängigkeit in deinem Projekt, falls du dies noch nicht getan hast:**
+
+```
+npm install @alch/alchemy-web3
+```
+
+**3. Erstelle eine Datei namens `index.js` und füge den folgenden Inhalt hinzu:**
+
+> Du solltest `demo` schlussendlich durch deinen Alchemy HTTP-API-Schlüssel ersetzen.
+
+```js
+async function main() {
+ const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
+ const web3 = createAlchemyWeb3("https://eth-mainnet.alchemyapi.io/v2/demo")
+ const blockNumber = await web3.eth.getBlockNumber()
+ console.log("Die letzte Blocknummer ist " + blockNumber)
+}
+main()
+```
+
+Noch nicht mit async/await vertraut? Sieh dir diesen [Medium-Beitrag](https://medium.com/better-programming/understanding-async-await-in-javascript-1d81bb079b2c) an.
+
+**4. Führe es mit node in deinem Terminal aus**
+
+```
+node index.js
+```
+
+**5. Du solltest jetzt die neueste Blocknummer in deiner Konsole ausgegeben sehen!**
+
+```
+Die letzte Blocknummer ist 11043912
+```
+
+**Woo!** Glückwunsch! Du hast soeben dein erstes Web3-Skript mit Alchemy geschrieben 🎉\*\*
+
+Du weißt nicht, was du als Nächstes tun sollst? Versuche, deinen ersten Smart Contract bereitzustellen und versuche dich an der Solidity-Programmierung in unserem [Hello World Smart Contract Guide](https://www.alchemy.com/docs/hello-world-smart-contract), oder teste dein Dashboard-Wissen mit der [Dashboard Demo App](https://docs.alchemyapi.io/tutorials/demo-app)!
+
+_[Registriere dich kostenlos bei Alchemy](https://auth.alchemy.com/), sieh dir unsere [Dokumentation](https://www.alchemy.com/docs/) an und folge uns für die neuesten Nachrichten auf [Twitter](https://twitter.com/AlchemyPlatform)_.
diff --git a/public/content/translations/de/developers/tutorials/guide-to-smart-contract-security-tools/index.md b/public/content/translations/de/developers/tutorials/guide-to-smart-contract-security-tools/index.md
new file mode 100644
index 00000000000..32c6770712e
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/guide-to-smart-contract-security-tools/index.md
@@ -0,0 +1,102 @@
+---
+title: Ein Leitfaden für Smart-Contract-Sicherheitstools
+description: Ein Überblick über drei verschiedene Test- und Programmanalysetechniken
+author: "Spuren von bits"
+lang: de
+tags: [ "solidity", "intelligente Verträge", "Sicherheit" ]
+skill: intermediate
+published: 07.09.2020
+source: Aufbau sicherer Verträge
+sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis
+---
+
+Wir werden drei verschiedene Test- und Programmanalysetechniken verwenden:
+
+- **Statische Analyse mit [Slither](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/).** Alle Pfade des Programms werden gleichzeitig durch verschiedene Programmdarstellungen (z. B. Kontrollflussgraph) angenähert und analysiert.
+- **Fuzzing mit [Echidna](/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/).** Der Code wird mit einer pseudozufälligen Generierung von Transaktionen ausgeführt. Der Fuzzer versucht, eine Folge von Transaktionen zu finden, die eine bestimmte Eigenschaft verletzen.
+- **Symbolische Ausführung mit [Manticore](/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/).** Eine formale Verifikationstechnik, die jeden Ausführungspfad in eine mathematische Formel übersetzt, anhand derer Einschränkungen überprüft werden können.
+
+Jede Technik hat ihre Vor- und Nachteile und ist in [bestimmten Fällen](#determining-security-properties) nützlich:
+
+| Technik | Werkzeug | Verwendung | Geschwindigkeit | Übersehene Fehler | Fehlalarme |
+| ---------------------- | --------- | ---------------------------------------------------- | --------------- | ----------------- | ---------- |
+| Statische Analyse | Slither | CLI & Skripte | Sekunden | moderat | gering |
+| Fuzzing | Echidna | Solidity-Eigenschaften | Minuten | gering | keine |
+| Symbolische Ausführung | Manticore | Solidity-Eigenschaften & Skripte | Stunden | keine\* | keine |
+
+- wenn alle Pfade ohne Zeitüberschreitung untersucht werden
+
+**Slither** analysiert Verträge innerhalb von Sekunden, allerdings kann eine statische Analyse zu Fehlalarmen führen und ist für komplexe Prüfungen (z. B. arithmetische Prüfungen) weniger geeignet. Führe Slither über die API aus, um per Knopfdruck auf integrierte Detektoren zuzugreifen, oder über die API für benutzerdefinierte Prüfungen.
+
+**Echidna** muss einige Minuten lang laufen und erzeugt nur echte Positiv-Ergebnisse. Echidna überprüft vom Benutzer bereitgestellte Sicherheitseigenschaften, die in Solidity geschrieben sind. Es können Fehler übersehen werden, da es auf einer zufälligen Untersuchung basiert.
+
+**Manticore** führt die "tiefgreifendste" Analyse durch. Wie Echidna verifiziert auch Manticore vom Benutzer bereitgestellte Eigenschaften. Die Ausführung dauert länger, aber es kann die Gültigkeit einer Eigenschaft beweisen und meldet keine Fehlalarme.
+
+## Empfohlener Arbeitsablauf {#suggested-workflow}
+
+Beginne mit den integrierten Detektoren von Slither, um sicherzustellen, dass jetzt und in Zukunft keine einfachen Fehler vorhanden sind. Verwende Slither, um Eigenschaften im Zusammenhang mit Vererbung, Variablenabhängigkeiten und strukturellen Problemen zu überprüfen. Wenn die Codebasis wächst, verwende Echidna, um komplexere Eigenschaften des Zustandsautomaten zu testen. Greife erneut auf Slither zurück, um benutzerdefinierte Prüfungen für Schutzmaßnahmen zu entwickeln, die in Solidity nicht verfügbar sind, wie z. B. den Schutz vor dem Überschreiben einer Funktion. Verwende schließlich Manticore, um eine gezielte Überprüfung kritischer Sicherheitseigenschaften durchzuführen, z. B. arithmetische Operationen.
+
+- Verwende die CLI von Slither, um häufige Probleme zu finden.
+- Verwende Echidna, um übergeordnete Sicherheitseigenschaften deines Vertrags zu testen.
+- Verwende Slither, um benutzerdefinierte statische Prüfungen zu schreiben.
+- Verwende Manticore, wenn du eine tiefgehende Absicherung kritischer Sicherheitseigenschaften wünschst.
+
+**Ein Hinweis zu Unit-Tests**. Unit-Tests sind notwendig, um qualitativ hochwertige Software zu erstellen. Diese Techniken sind jedoch nicht am besten geeignet, um Sicherheitslücken zu finden. Sie werden typischerweise verwendet, um das positive Verhalten von Code zu testen (d. h. der Code funktioniert im normalen Kontext wie erwartet), während Sicherheitslücken eher in Grenzfällen auftreten, die die Entwickler nicht bedacht haben. In unserer Untersuchung von Dutzenden von Smart-Contract-Sicherheitsüberprüfungen hatte die [Unit-Test-Abdeckung keine Auswirkung auf die Anzahl oder den Schweregrad der Sicherheitslücken](https://blog.trailofbits.com/2019/08/08/246-findings-from-our-smart-contract-audits-an-executive-summary/), die wir im Code unserer Kunden fanden.
+
+## Bestimmung von Sicherheitseigenschaften {#determining-security-properties}
+
+Um deinen Code effektiv zu testen und zu verifizieren, musst du die Bereiche identifizieren, die Aufmerksamkeit erfordern. Da deine für die Sicherheit aufgewendeten Ressourcen begrenzt sind, ist es wichtig, die schwachen oder hochwertigen Teile deiner Codebasis zu bestimmen, um deinen Aufwand zu optimieren. Bedrohungsmodellierung kann dabei helfen. Ziehe Folgendes in Betracht:
+
+- [Rapid Risk Assessments](https://infosec.mozilla.org/guidelines/risk/rapid_risk_assessment.html) (unser bevorzugter Ansatz bei Zeitmangel)
+- [Guide to Data-Centric System Threat Modeling](https://csrc.nist.gov/pubs/sp/800/154/ipd) (alias NIST 800-154)
+- [Shostack Threat Modeling](https://www.amazon.com/Threat-Modeling-Designing-Adam-Shostack/dp/1118809998)
+- [STRIDE](https://wikipedia.org/wiki/STRIDE_\(security\)) / [DREAD](https://wikipedia.org/wiki/DREAD_\(risk_assessment_model\))
+- [PASTA](https://wikipedia.org/wiki/Threat_model#P.A.S.T.A.)
+- [Verwendung von Assertions](https://blog.regehr.org/archives/1091)
+
+### Komponenten {#components}
+
+Wenn du weißt, was du überprüfen willst, hilft dir das auch bei der Auswahl des richtigen Tools.
+
+Die allgemeinen Bereiche, die für Smart Contracts häufig relevant sind, umfassen:
+
+- **Zustandsautomat.** Die meisten Verträge lassen sich als Zustandsautomat darstellen. Überlege zu prüfen, ob (1) kein ungültiger Zustand erreicht werden kann, (2) ein gültiger Zustand erreicht werden kann und (3) kein Zustand den Vertrag blockiert.
+
+ - Echidna und Manticore sind die zu bevorzugenden Tools, um die Spezifikationen von Zustandsautomaten zu testen.
+
+- **Zugriffskontrollen.** Wenn dein System privilegierte Benutzer hat (z. B. einen Eigentümer, Controller, ...) musst du sicherstellen, dass (1) jeder Benutzer nur die autorisierten Aktionen durchführen kann und (2) kein Benutzer Aktionen eines privilegierteren Benutzers blockieren kann.
+
+ - Slither, Echidna und Manticore können korrekte Zugriffskontrollen überprüfen. Slither kann zum Beispiel überprüfen, dass nur bei Funktionen auf der Whitelist der onlyOwner-Modifikator fehlt. Echidna und Manticore sind für komplexere Zugriffskontrollen nützlich, z. B. für eine Berechtigung, die nur erteilt wird, wenn der Vertrag einen bestimmten Zustand erreicht.
+
+- **Arithmetische Operationen.** Die Überprüfung der Korrektheit der arithmetischen Operationen ist entscheidend. Die durchgängige Verwendung von `SafeMath` ist ein guter Schritt, um Über- und Unterläufe zu verhindern. Dennoch musst du andere arithmetische Fehler berücksichtigen, einschließlich Rundungsfehler und Fehler, die den Vertrag blockieren.
+
+ - Manticore ist hier die beste Wahl. Echidna kann verwendet werden, wenn die Arithmetik außerhalb des Bereichs des SMT-Solvers liegt.
+
+- **Korrektheit der Vererbung.** Solidity-Verträge stützen sich stark auf Mehrfachvererbung. Fehler wie eine überschattende Funktion, bei der ein `super`-Aufruf fehlt, und eine falsch interpretierte c3-Linearisierungsreihenfolge können leicht entstehen.
+
+ - Slither ist das Tool, um die Erkennung dieser Probleme sicherzustellen.
+
+- **Externe Interaktionen.** Verträge interagieren miteinander, und einigen externen Verträgen sollte man nicht vertrauen. Wenn dein Vertrag zum Beispiel von externen Orakeln abhängt, bleibt er dann sicher, wenn die Hälfte der verfügbaren Orakel kompromittiert ist?
+
+ - Manticore und Echidna sind die beste Wahl, um externe Interaktionen mit deinen Verträgen zu testen. Manticore verfügt über einen eingebauten Mechanismus, um externe Verträge zu stubben.
+
+- **Standardkonformität.** Ethereum-Standards (z. B. ERC20) weisen in ihrer Entwurfsgeschichte immer wieder Fehler auf. Sei dir der Einschränkungen des Standards bewusst, auf dem du aufbaust.
+ - Slither, Echidna und Manticore helfen dir dabei, Abweichungen von einem bestimmten Standard zu erkennen.
+
+### Spickzettel zur Werkzeugauswahl {#tool-selection-cheatsheet}
+
+| Komponente | Tools | Beispiele |
+| ------------------------- | --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Zustandsautomat | Echidna, Manticore | |
+| Zugriffskontrolle | Slither, Echidna, Manticore | [Slither-Übung 2](https://github.com/crytic/slither/blob/7f54c8b948c34fb35e1d61adaa1bd568ca733253/docs/src/tutorials/exercise2.md), [Echidna-Übung 2](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/exercises/Exercise-2.md) |
+| Arithmetische Operationen | Manticore, Echidna | [Echidna-Übung 1](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/exercises/Exercise-1.md), [Manticore-Übungen 1 - 3](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/manticore/exercises) |
+| Korrektheit der Vererbung | Slither | [Slither-Übung 1](https://github.com/crytic/slither/blob/7f54c8b948c34fb35e1d61adaa1bd568ca733253/docs/src/tutorials/exercise1.md) |
+| Externe Interaktionen | Manticore, Echidna | |
+| Standardkonformität | Slither, Echidna, Manticore | [`slither-erc`](https://github.com/crytic/slither/wiki/ERC-Conformance) |
+
+Je nach deinen Zielen müssen auch andere Bereiche überprüft werden, aber diese grob umrissenen Schwerpunktbereiche sind ein guter Anfang für jedes Smart-Contract-System.
+
+Unsere öffentlichen Audits enthalten Beispiele für verifizierte oder getestete Eigenschaften. Lies die Abschnitte `Automated Testing and Verification` der folgenden Berichte, um dir Sicherheitseigenschaften aus der Praxis anzusehen:
+
+- [0x](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf)
+- [Balancer](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf)
diff --git a/public/content/translations/de/developers/tutorials/hello-world-smart-contract-fullstack/index.md b/public/content/translations/de/developers/tutorials/hello-world-smart-contract-fullstack/index.md
new file mode 100644
index 00000000000..82a4f3c33ff
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/hello-world-smart-contract-fullstack/index.md
@@ -0,0 +1,1543 @@
+---
+title: Hello World Smart-Contract für Einsteiger – Fullstack
+description: Einführungstutorial zum Schreiben und Bereitstellen eines einfachen Smart Contracts auf Ethereum.
+author: "nstrike2"
+tags:
+ [
+ "solidity",
+ "Hardhat",
+ "Alchemy",
+ "intelligente Verträge",
+ "Bereitstellung",
+ "Block-Explorer",
+ "Frontend",
+ "Transaktionen"
+ ]
+skill: beginner
+lang: de
+published: 2021-10-25
+---
+
+Dieser Leitfaden ist für Sie, wenn Sie neu in der Blockchain-Entwicklung sind und nicht wissen, wo Sie anfangen sollen oder wie Sie Smart Contracts bereitstellen und mit ihnen interagieren können. Wir werden die Erstellung und Bereitstellung eines einfachen Smart Contracts im Goerli-Testnet unter Verwendung von [MetaMask](https://metamask.io), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org) und [Alchemy](https://alchemy.com/eth) durchgehen.
+
+Sie benötigen ein Alchemy-Konto, um dieses Tutorial abzuschließen. [Registrieren Sie sich für ein kostenloses Konto](https://www.alchemy.com/).
+
+Wenn Sie zu irgendeinem Zeitpunkt Fragen haben, können Sie sich gerne im [Alchemy Discord](https://discord.gg/gWuC7zB) melden!
+
+## Teil 1 – Erstellen und Bereitstellen Ihres Smart Contracts mit Hardhat {#part-1}
+
+### Verbindung mit dem Ethereum-Netzwerk herstellen {#connect-to-the-ethereum-network}
+
+Es gibt viele Möglichkeiten, Anfragen an die Ethereum-Chain zu stellen. Der Einfachheit halber verwenden wir ein kostenloses Konto bei Alchemy, einer Blockchain-Entwicklerplattform und API, die es uns ermöglicht, mit der Ethereum-Chain zu kommunizieren, ohne selbst einen Node betreiben zu müssen. Alchemy verfügt auch über Entwickler-Tools für Monitoring und Analytik; wir werden diese in diesem Tutorial nutzen, um zu verstehen, was bei der Bereitstellung unseres Smart Contracts „unter der Haube“ passiert.
+
+### Erstellen Sie Ihre App und Ihren API-Schlüssel {#create-your-app-and-api-key}
+
+Sobald Sie ein Alchemy-Konto erstellt haben, können Sie einen API-Schlüssel generieren, indem Sie eine App erstellen. Damit können Sie Anfragen an das Goerli-Testnet stellen. Wenn Sie mit Testnets nicht vertraut sind, können Sie [Alchemys Leitfaden zur Auswahl eines Netzwerks](https://www.alchemy.com/docs/choosing-a-web3-network) lesen.
+
+Suchen Sie auf dem Alchemy-Dashboard das Dropdown-Menü **Apps** in der Navigationsleiste und klicken Sie auf **App erstellen**.
+
+
+
+Geben Sie Ihrer App den Namen „_Hello World_“ und schreiben Sie eine kurze Beschreibung. Wählen Sie **Staging** als Ihre Umgebung und **Goerli** als Ihr Netzwerk.
+
+
+
+_Hinweis: Wählen Sie unbedingt **Goerli** aus, sonst funktioniert dieses Tutorial nicht._
+
+Klicken Sie auf **App erstellen**. Ihre App wird in der folgenden Tabelle angezeigt.
+
+### Ein Ethereum-Konto erstellen {#create-an-ethereum-account}
+
+Sie benötigen ein Ethereum-Konto, um Transaktionen zu senden und zu empfangen. Wir verwenden MetaMask, eine virtuelle Wallet im Browser, mit der Benutzer ihre Ethereum-Kontoadresse verwalten können.
+
+Sie können MetaMask [hier](https://metamask.io/download) kostenlos herunterladen und ein Konto erstellen. Wenn Sie ein Konto erstellen oder bereits eines haben, stellen Sie sicher, dass Sie oben rechts zum „Goerli Test Network“ wechseln (damit wir nicht mit echtem Geld arbeiten).
+
+### Schritt 4: Ether von einem Faucet hinzufügen {#step-4-add-ether-from-a-faucet}
+
+Um Ihren Smart Contract im Testnet bereitzustellen, benötigen Sie einige Fake-ETH. Um ETH im Goerli-Netzwerk zu erhalten, gehen Sie zu einem Goerli-Faucet und geben Sie Ihre Goerli-Kontoadresse ein. Beachten Sie, dass Goerli-Faucets in letzter Zeit etwas unzuverlässig sein können – auf der [Seite der Testnets](/developers/docs/networks/#goerli) finden Sie eine Liste mit Optionen, die Sie ausprobieren können:
+
+_Hinweis: Aufgrund von Netzwerküberlastung kann dies eine Weile dauern._
+\`\`
+
+### Schritt 5: Überprüfen Sie Ihr Guthaben {#step-5-check-your-balance}
+
+Um zu überprüfen, ob sich die ETH in Ihrer Wallet befinden, stellen wir eine [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance)-Anfrage mit dem [Composer-Tool von Alchemy](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D). Das gibt den ETH-Betrag in unserem Wallet wieder. Um mehr zu erfahren, sehen Sie sich [Alchemys kurzes Tutorial zur Verwendung des Composer-Tools](https://youtu.be/r6sjRxBZJuU) an.
+
+Geben Sie Ihre MetaMask-Kontoadresse ein und klicken Sie auf **Anfrage senden**. Sie sehen eine Antwort, die wie der folgende Codeausschnitt aussieht.
+
+```json
+{ "jsonrpc": "2.0", "id": 0, "result": "0x2B5E3AF16B1880000" }
+```
+
+> _HINWEIS: Dieses Ergebnis ist in wei, nicht in ETH, angegeben._ Wei ist die kleinste Einheit von Ether._
+
+Puh! Unser Falschgeld ist da.
+
+### Schritt 6: Initialisieren unseres Projekts {#step-6-initialize-our-project}
+
+Zunächst müssen wir einen Ordner für unser Projekt erstellen. Navigieren Sie zu Ihrer Kommandozeile und geben Sie Folgendes ein.
+
+```
+mkdir hello-world
+cd hello-world
+```
+
+Da wir uns nun in unserem Projektordner befinden, verwenden wir `npm init`, um das Projekt zu initialisieren.
+
+> Wenn Sie npm noch nicht installiert haben, befolgen Sie [diese Anweisungen zur Installation von Node.js und npm](https://docs.alchemyapi.io/alchemy/guides/alchemy-for-macs#1-install-nodejs-and-npm).
+
+Für den Zweck dieses Tutorials spielt es keine Rolle, wie Sie die Initialisierungsfragen beantworten. Hier ist, wie wir es als Referenz gemacht haben:
+
+```
+package name: (hello-world)
+version: (1.0.0)
+description: hallo Welt Smart Contract
+entry point: (index.js)
+test command:
+git repository:
+keywords:
+author:
+license: (ISC)
+
+About to write to /Users/.../.../.../hello-world/package.json:
+
+{
+ "name": "hello-world",
+ "version": "1.0.0",
+ "description": "hallo Welt Smart Contract",
+ "main": "index.js",
+ "scripts": {
+ "test": "echo \"Fehler: kein Test angegeben\" && exit 1"
+ },
+ "author": "",
+ "license": "ISC"
+}
+```
+
+Bestätigen Sie die package.json und schon kann es losgehen!
+
+### Schritt 7: Hardhat herunterladen {#step-7-download-hardhat}
+
+Hardhat ist eine Entwicklungsumgebung zum Kompilieren, Bereitstellen, Testen und Debuggen Ihrer Ethereum-Software. Es hilft Entwicklern Smart Contracts und dApps lokal zu erstellen, bevor diese auf der Live-Chain bereitgestellt werden.
+
+Führen Sie in unserem `hello-world`-Projekt Folgendes aus:
+
+```
+npm install --save-dev hardhat
+```
+
+Weitere Details zu den [Installationsanweisungen](https://hardhat.org/getting-started/#overview) finden Sie auf dieser Seite.
+
+### Schritt 8: Hardhat-Projekt erstellen {#step-8-create-hardhat-project}
+
+Führen Sie im Projektordner `hello-world` Folgendes aus:
+
+```
+npx hardhat
+```
+
+Sie sollten dann eine Willkommensnachricht sehen und die Möglichkeit haben, auszuwählen, wie Sie fortfahren möchten. Wählen Sie "create an empty hardhat.config.js" (Leere hardhat.config.js erstellen) aus:
+
+```
+888 888 888 888 888
+888 888 888 888 888
+888 888 888 888 888
+8888888888 8888b. 888d888 .d88888 88888b. 8888b. 888888
+888 888 "88b 888P" d88" 888 888 "88b "88b 888
+888 888 .d888888 888 888 888 888 888 .d888888 888
+888 888 888 888 888 Y88b 888 888 888 888 888 Y88b.
+888 888 "Y888888 888 "Y88888 888 888 "Y888888 "Y888
+
+👷 Welcome to Hardhat v2.0.11 👷
+
+What do you want to do? …
+Create a sample project
+❯ Create an empty hardhat.config.js
+Quit
+```
+
+Dadurch wird eine `hardhat.config.js`-Datei im Projekt generiert. Wir werden dies später im Tutorial verwenden, um das Setup für unser Projekt festzulegen.
+
+### Schritt 9: Projektordner hinzufügen {#step-9-add-project-folders}
+
+Um das Projekt zu organisieren, erstellen wir zwei neue Ordner. Navigieren Sie in der Kommandozeile zum Stammverzeichnis Ihres `hello-world`-Projekts und geben Sie ein:
+
+```
+mkdir contracts
+mkdir scripts
+```
+
+- `contracts/` ist der Ort, an dem wir unsere `Hello-World-Smart-Contract`-Codedatei aufbewahren.
+- `scripts/` ist der Ort, an dem wir Skripte zur Bereitstellung und Interaktion mit unserem Vertrag aufbewahren.
+
+### Schritt 10: Schreiben unseres Vertrags {#step-10-write-our-contract}
+
+Sie fragen sich vielleicht, wann wir anfangen, Code zu schreiben? Es ist soweit!
+
+Öffnen Sie das hello-world-Projekt in Ihrem bevorzugten Editor. Smart Contracts werden meistens in Solidity geschrieben, was wir verwenden werden, um unseren Smart Contract zu schreiben.
+
+1. Navigieren Sie zum `contracts`-Ordner und erstellen Sie eine neue Datei namens `HelloWorld.sol`
+2. Unten ist ein Beispiel für einen Hallo-Welt-Smart-Contract, den wir für dieses Tutorial verwenden werden. Kopieren Sie den folgenden Inhalt in die `HelloWorld.sol`-Datei.
+
+_Hinweis: Lesen Sie unbedingt die Kommentare, um zu verstehen, was dieser Vertrag bewirkt._
+
+```
+// Gibt die Version von Solidity an, unter Verwendung von semantischer Versionierung.
+// Mehr erfahren: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
+pragma solidity >=0.7.3;
+
+// Definiert einen Vertrag namens `HelloWorld`.
+// Ein Vertrag ist eine Sammlung von Funktionen und Daten (seinem Zustand). Nach der Bereitstellung befindet sich ein Vertrag an einer bestimmten Adresse auf der Ethereum-Blockchain. Mehr erfahren: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
+contract HelloWorld {
+
+ //Wird ausgegeben, wenn die update-Funktion aufgerufen wird
+ //Smart-Contract-Ereignisse sind eine Möglichkeit für Ihren Vertrag, Ihrer App-Frontend mitzuteilen, dass auf der Blockchain etwas passiert ist. Das Frontend kann auf bestimmte Ereignisse „hören“ und bei deren Eintreten Maßnahmen ergreifen.
+ event UpdatedMessages(string oldStr, string newStr);
+
+ // Deklariert eine Zustandsvariable `message` vom Typ `string`.
+ // Zustandsvariablen sind Variablen, deren Werte dauerhaft im Vertragsspeicher gespeichert werden. Das Schlüsselwort `public` macht Variablen von außerhalb eines Vertrags zugänglich und erstellt eine Funktion, die andere Verträge oder Clients aufrufen können, um auf den Wert zuzugreifen.
+ string public message;
+
+ // Ähnlich wie in vielen klassenbasierten objektorientierten Sprachen ist ein Konstruktor eine spezielle Funktion, die nur bei der Erstellung des Vertrags ausgeführt wird.
+ // Konstruktoren werden verwendet, um die Daten des Vertrags zu initialisieren. Mehr erfahren:https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
+ constructor(string memory initMessage) {
+
+ // Akzeptiert ein String-Argument `initMessage` und setzt den Wert in die Speichervariable `message` des Vertrags).
+ message = initMessage;
+ }
+
+ // Eine öffentliche Funktion, die ein String-Argument akzeptiert und die Speichervariable `message` aktualisiert.
+ function update(string memory newMessage) public {
+ string memory oldMsg = message;
+ message = newMessage;
+ emit UpdatedMessages(oldMsg, newMessage);
+ }
+}
+```
+
+Dies ist ein einfacher Smart Contract, der bei der Erstellung eine Nachricht speichert. Er kann durch Aufrufen der `update`-Funktion aktualisiert werden.
+
+### Schritt 11: Verbinden Sie MetaMask und Alchemy mit Ihrem Projekt {#step-11-connect-metamask-alchemy-to-your-project}
+
+Wir haben eine MetaMask-Wallet und ein Alchemy-Konto erstellt und unseren Smart Contract geschrieben. Jetzt ist es an der Zeit, die drei zu verbinden.
+
+Jede von Ihrer Wallet gesendete Transaktion erfordert eine Signatur mit Ihrem eindeutigen privaten Schlüssel. Um unserem Programm diese Berechtigung zu erteilen, können wir unseren privaten Schlüssel sicher in einer Umgebungsdatei speichern. Wir werden hier auch einen API-Schlüssel für Alchemy speichern.
+
+> Um mehr über das Senden von Transaktionen zu erfahren, lesen Sie [dieses Tutorial](https://www.alchemy.com/docs/hello-world-smart-contract#step-11-connect-metamask--alchemy-to-your-project) über das Senden von Transaktionen mit web3.
+
+Installieren Sie zuerst das dotenv-Paket in Ihrem Projektverzeichnis:
+
+```
+npm install dotenv --save
+```
+
+Erstellen Sie dann eine `.env`-Datei im Stammverzeichnis des Projekts. Fügen Sie Ihren privaten MetaMask-Schlüssel und die HTTP-Alchemy-API-URL hinzu.
+
+Ihre Umgebungsdatei muss den Namen `.env` haben, sonst wird sie nicht als Umgebungsdatei erkannt.
+
+Nennen Sie sie nicht `process.env` oder `.env-custom` oder irgendetwas anderes.
+
+- Befolgen Sie [diese Anweisungen](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key), um Ihren privaten Schlüssel zu exportieren
+- Siehe unten, um die HTTP Alchemy API-URL zu erhalten
+
+
+
+Ihre `.env`-Datei sollte wie folgt aussehen:
+
+```
+API_URL = "https://eth-goerli.alchemyapi.io/v2/your-api-key"
+PRIVATE_KEY = "your-metamask-private-key"
+```
+
+Um diese tatsächlich mit unserem Code zu verbinden, verweisen wir in Schritt 13 in unserer `hardhat.config.js`-Datei auf diese Variablen.
+
+### Schritt 12: Ethers.js installieren {#step-12-install-ethersjs}
+
+Ethers.js ist eine Bibliothek, die es einfacher macht, mit Ethereum zu interagieren und Anfragen zu stellen, indem sie [standardmäßige JSON-RPC-Methoden](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc) mit benutzerfreundlicheren Methoden umschließt.
+
+Hardhat ermöglicht es uns, [Plugins](https://hardhat.org/plugins/) für zusätzliche Tools und erweiterte Funktionalität zu integrieren. Wir werden das [Ethers-Plugin](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers) für die Vertragsbereitstellung nutzen.
+
+Geben Sie Folgendes in Ihrem Projektverzeichnis ein:
+
+```bash
+npm install --save-dev @nomiclabs/hardhat-ethers "ethers@^5.0.0"
+```
+
+### Schritt 13: Aktualisieren der hardhat.config.js {#step-13-update-hardhat-configjs}
+
+Wir haben bisher mehrere Abhängigkeiten und Plugins hinzugefügt. Jetzt müssen wir `hardhat.config.js` aktualisieren, damit unser Projekt alle kennt.
+
+Aktualisieren Sie Ihre `hardhat.config.js`, sodass sie wie folgt aussieht:
+
+```javascript
+/**
+ * @type import('hardhat/config').HardhatUserConfig
+ */
+
+require("dotenv").config()
+require("@nomiclabs/hardhat-ethers")
+
+const { API_URL, PRIVATE_KEY } = process.env
+
+module.exports = {
+ solidity: "0.7.3",
+ defaultNetwork: "goerli",
+ networks: {
+ hardhat: {},
+ goerli: {
+ url: API_URL,
+ accounts: [`0x${PRIVATE_KEY}`],
+ },
+ },
+}
+```
+
+### Schritt 14: Kompilieren unseres Vertrags {#step-14-compile-our-contract}
+
+Um sicherzugehen, dass so weit alles funktioniert, sollten wir unseren Vertrag erstellen. Der `compile`-Task ist einer der integrierten Hardhat-Tasks.
+
+Führen Sie folgenden Befehl in der Befehlszeile aus:
+
+```bash
+npx hardhat compile
+```
+
+Möglicherweise erhalten Sie eine Warnung über `SPDX license identifier not provided in source file`, aber machen Sie sich darüber keine Sorgen – hoffentlich sieht alles andere gut aus! Wenn nicht, können Sie jederzeit eine Nachricht im [Alchemy-Discord](https://discord.gg/u72VCg3) schreiben.
+
+### Schritt 15: Schreiben unseres Bereitstellungsskripts {#step-15-write-our-deploy-script}
+
+Nun, da unser Vertrag geschrieben und unsere Konfigurationsdatei einsatzbereit ist, ist es an der Zeit, das Skript zur Bereitstellung des Vertrags zu schreiben.
+
+Navigieren Sie zum Ordner `scripts/` und erstellen Sie eine neue Datei namens `deploy.js`, und fügen Sie ihr den folgenden Inhalt hinzu:
+
+```javascript
+async function main() {
+ const HelloWorld = await ethers.getContractFactory("HelloWorld")
+
+ // Startet die Bereitstellung und gibt ein Promise zurück, das zu einem Vertragsobjekt aufgelöst wird
+ const hello_world = await HelloWorld.deploy("Hello World!")
+ console.log("Vertrag bereitgestellt unter Adresse:", hello_world.address)
+}
+
+main()
+ .then(() => process.exit(0))
+ .catch((error) => {
+ console.error(error)
+ process.exit(1)
+ })
+```
+
+Hardhat erklärt in seinem [Contracts-Tutorial](https://hardhat.org/tutorial/testing-contracts.html#writing-tests) hervorragend, was jede dieser Codezeilen bewirkt; wir haben die Erklärungen hier übernommen.
+
+```javascript
+const HelloWorld = await ethers.getContractFactory("HelloWorld")
+```
+
+Eine `ContractFactory` in ethers.js ist eine Abstraktion, die verwendet wird, um neue Smart Contracts bereitzustellen. `HelloWorld` ist hier also eine [Factory](https://en.wikipedia.org/wiki/Factory_\(object-oriented_programming\)) für Instanzen unseres Hallo-Welt-Vertrags. Bei der Verwendung des `hardhat-ethers`-Plugins werden `ContractFactory`- und `Contract`-Instanzen standardmäßig mit dem ersten Unterzeichner (Besitzer) verbunden.
+
+```javascript
+const hello_world = await HelloWorld.deploy()
+```
+
+Der Aufruf von `deploy()` auf einer `ContractFactory` startet die Bereitstellung und gibt ein `Promise` zurück, das zu einem `Contract`-Objekt aufgelöst wird. Das ist das Objekt, das eine Methode für jede unserer Smart-Contract-Funktionen enthält.
+
+### Schritt 16: Unseren Vertrag bereitstellen {#step-16-deploy-our-contract}
+
+Nun sind wir endlich bereit, unseren Smart Contract bereitzustellen. Navigieren Sie zur Befehlszeile und führen Sie Folgendes aus:
+
+```bash
+npx hardhat run scripts/deploy.js --network goerli
+```
+
+Sie sollten dann etwas sehen wie:
+
+```bash
+Contract deployed to address: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570
+```
+
+**Bitte speichern Sie diese Adresse**. Wir werden sie später im Tutorial verwenden.
+
+Wenn wir zum [Goerli-Etherscan](https://goerli.etherscan.io) gehen und nach unserer Vertragsadresse suchen, sollten wir sehen können, dass sie erfolgreich bereitgestellt wurde. Die Transaktion wird ungefähr so aussehen:
+
+
+
+Die `From`-Adresse sollte mit Ihrer MetaMask-Kontoadresse übereinstimmen und die `To`-Adresse lautet **Vertragserstellung**. Wenn wir auf die Transaktion klicken, sehen wir unsere Vertragsadresse im `To`-Feld.
+
+
+
+Glückwunsch! Sie haben gerade einen Smart Contract in einem Ethereum-Testnet bereitgestellt.
+
+Um zu verstehen, was „unter der Haube“ vor sich geht, navigieren wir zum Explorer-Tab in unserem [Alchemy-Dashboard](https://dashboard.alchemy.com/explorer). Wenn Sie mehrere Alchemy-Apps haben, stellen Sie sicher, dass Sie nach App filtern und **Hello World** auswählen.
+
+
+
+Hier sehen Sie eine Handvoll JSON-RPC-Methoden, die Hardhat/Ethers für uns „unter der Haube“ ausgeführt hat, als wir die `.deploy()`-Funktion aufgerufen haben. Zwei wichtige Methoden sind hier [`eth_sendRawTransaction`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_sendrawtransaction), das ist die Anforderung, unseren Vertrag in die Goerli-Chain zu schreiben, und [`eth_getTransactionByHash`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_gettransactionbyhash), eine Anforderung zum Lesen von Informationen über unsere Transaktion anhand des Hashes. Um mehr über das Senden von Transaktionen zu erfahren, lesen Sie unser [Tutorial zum Senden von Transaktionen mit Web3](/developers/tutorials/sending-transactions-using-web3-and-alchemy/).
+
+## Teil 2: Interaktion mit Ihrem Smart Contract {#part-2-interact-with-your-smart-contract}
+
+Nachdem wir nun erfolgreich einen Smart Contract im Goerli-Netzwerk bereitgestellt haben, lernen wir, wie man mit ihm interagiert.
+
+### Eine interact.js-Datei erstellen {#create-a-interactjs-file}
+
+Dies ist die Datei, in die wir unser Interaktionsskript schreiben werden. Wir werden die Ethers.js-Bibliothek verwenden, die Sie zuvor in Teil 1 installiert haben.
+
+Erstellen Sie im Ordner `scripts/` eine neue Datei namens `interact.js` und fügen Sie den folgenden Code hinzu:
+
+```javascript
+// interact.js
+
+const API_KEY = process.env.API_KEY
+const PRIVATE_KEY = process.env.PRIVATE_KEY
+const CONTRACT_ADDRESS = process.env.CONTRACT_ADDRESS
+```
+
+### Aktualisieren Sie Ihre .env-Datei {#update-your-env-file}
+
+Wir werden neue Umgebungsvariablen verwenden, also müssen wir sie in der `.env`-Datei definieren, die [wir zuvor erstellt haben](#step-11-connect-metamask-&-alchemy-to-your-project).
+
+Wir müssen eine Definition für unseren Alchemy `API_KEY` und die `CONTRACT_ADDRESS` hinzufügen, unter der Ihr Smart Contract bereitgestellt wurde.
+
+Ihre `.env`-Datei sollte ungefähr so aussehen:
+
+```bash
+# .env
+
+API_URL = "https://eth-goerli.alchemyapi.io/v2/"
+API_KEY = ""
+PRIVATE_KEY = ""
+CONTRACT_ADDRESS = "0x"
+```
+
+### Ihre Vertrags-ABI abrufen {#grab-your-contract-ABI}
+
+Unsere Vertrags-[ABI (Application Binary Interface)](/glossary/#abi) ist die Schnittstelle, über die die Interaktion mit unserem Smart Contract erfolgt. Hardhat generiert automatisch eine ABI und speichert sie in `HelloWorld.json`. Um die ABI zu verwenden, müssen wir den Inhalt auslesen, indem wir die folgenden Codezeilen zu unserer `interact.js`-Datei hinzufügen:
+
+```javascript
+// interact.js
+const contract = require("../artifacts/contracts/HelloWorld.sol/HelloWorld.json")
+```
+
+Wenn Sie die ABI sehen möchten, können Sie sie auf Ihrer Konsole ausgeben:
+
+```javascript
+console.log(JSON.stringify(contract.abi))
+```
+
+Um Ihre ABI in der Konsole ausgedruckt zu sehen, navigieren Sie zu Ihrem Terminal und führen Sie aus:
+
+```bash
+npx hardhat run scripts/interact.js
+```
+
+### Eine Instanz Ihres Vertrags erstellen {#create-an-instance-of-your-contract}
+
+Um mit unserem Vertrag zu interagieren, müssen wir eine Vertragsinstanz in unserem Code erstellen. Um dies mit Ethers.js zu tun, müssen wir mit drei Konzepten arbeiten:
+
+1. Provider – ein Node-Provider, der Ihnen Lese- und Schreibzugriff auf die Blockchain gibt
+2. Signer – repräsentiert ein Ethereum-Konto, das Transaktionen signieren kann
+3. Contract – ein Ethers.js-Objekt, das einen bestimmten onchain bereitgestellten Vertrag darstellt
+
+Wir verwenden die Vertrags-ABI aus dem vorherigen Schritt, um unsere Instanz des Vertrags zu erstellen:
+
+```javascript
+// interact.js
+
+// Provider
+const alchemyProvider = new ethers.providers.AlchemyProvider(
+ (network = "goerli"),
+ API_KEY
+)
+
+// Signer
+const signer = new ethers.Wallet(PRIVATE_KEY, alchemyProvider)
+
+// Contract
+const helloWorldContract = new ethers.Contract(
+ CONTRACT_ADDRESS,
+ contract.abi,
+ signer
+)
+```
+
+Erfahren Sie mehr über Provider, Signer und Contracts in der [ethers.js-Dokumentation](https://docs.ethers.io/v5/).
+
+### Lesen Sie die init-Nachricht {#read-the-init-message}
+
+Erinnern Sie sich, als wir unseren Vertrag mit `initMessage = "Hello world!"` bereitgestellt haben? Wir werden nun diese Nachricht, die in unserem Smart Contract gespeichert ist, lesen und in der Konsole ausgeben.
+
+In JavaScript werden asynchrone Funktionen verwendet, wenn mit Netzwerken interagiert wird. Um mehr über asynchrone Funktionen zu erfahren, [lesen Sie diesen Medium-Artikel](https://blog.bitsrc.io/understanding-asynchronous-javascript-the-event-loop-74cd408419ff).
+
+Verwenden Sie den folgenden Code, um die `message`-Funktion in unserem Smart Contract aufzurufen und die init-Nachricht zu lesen:
+
+```javascript
+// interact.js
+
+// ...
+
+async function main() {
+ const message = await helloWorldContract.message()
+ console.log("The message is: " + message)
+}
+main()
+```
+
+Nachdem wir die Datei mit `npx hardhat run scripts/interact.js` im Terminal ausgeführt haben, sollten wir diese Antwort sehen:
+
+```
+Die Nachricht ist: Hallo Welt!
+```
+
+Glückwunsch! Sie haben gerade erfolgreich Smart-Contract-Daten von der Ethereum-Blockchain gelesen, gut gemacht!
+
+### Die Nachricht aktualisieren {#update-the-message}
+
+Anstatt nur die Nachricht zu lesen, können wir auch die in unserem Smart Contract gespeicherte Nachricht mithilfe der `update`-Funktion aktualisieren! Ziemlich cool, oder?
+
+Um die Nachricht zu aktualisieren, können wir die `update`-Funktion direkt auf unserem instanziierten Vertrags-Objekt aufrufen:
+
+```javascript
+// interact.js
+
+// ...
+
+async function main() {
+ const message = await helloWorldContract.message()
+ console.log("Die Nachricht ist: " + message)
+
+ console.log("Aktualisiere die Nachricht...")
+ const tx = await helloWorldContract.update("Dies ist die neue Nachricht.")
+ await tx.wait()
+}
+main()
+```
+
+Beachten Sie, dass wir in Zeile 11 einen Aufruf von `.wait()` auf dem zurückgegebenen Transaktionsobjekt machen. Dies stellt sicher, dass unser Skript wartet, bis die Transaktion auf der Blockchain gemined ist, bevor die Funktion beendet wird. Wenn der `.wait()`-Aufruf nicht enthalten ist, sieht das Skript möglicherweise nicht den aktualisierten `message`-Wert im Vertrag.
+
+### Die neue Nachricht lesen {#read-the-new-message}
+
+Sie sollten in der Lage sein, den [vorherigen Schritt](#read-the-init-message) zu wiederholen, um den aktualisierten `message`-Wert zu lesen. Nehmen Sie sich einen Moment Zeit und sehen Sie, ob Sie die notwendigen Änderungen vornehmen können, um diesen neuen Wert auszugeben!
+
+Wenn Sie einen Hinweis benötigen, hier ist, wie Ihre `interact.js`-Datei an dieser Stelle aussehen sollte:
+
+```javascript
+// interact.js
+
+const API_KEY = process.env.API_KEY
+const PRIVATE_KEY = process.env.PRIVATE_KEY
+const CONTRACT_ADDRESS = process.env.CONTRACT_ADDRESS
+
+const contract = require("../artifacts/contracts/HelloWorld.sol/HelloWorld.json")
+
+// provider - Alchemy
+const alchemyProvider = new ethers.providers.AlchemyProvider(
+ (network = "goerli"),
+ API_KEY
+)
+
+// signer - Sie
+const signer = new ethers.Wallet(PRIVATE_KEY, alchemyProvider)
+
+// Vertragsinstanz
+const helloWorldContract = new ethers.Contract(
+ CONTRACT_ADDRESS,
+ contract.abi,
+ signer
+)
+
+async function main() {
+ const message = await helloWorldContract.message()
+ console.log("Die Nachricht ist: " + message)
+
+ console.log("Aktualisiere die Nachricht...")
+ const tx = await helloWorldContract.update("Dies ist die neue Nachricht")
+ await tx.wait()
+
+ const newMessage = await helloWorldContract.message()
+ console.log("Die neue Nachricht ist: " + newMessage)
+}
+
+main()
+```
+
+Führen Sie nun einfach das Skript aus und Sie sollten die alte Nachricht, den Aktualisierungsstatus und die neue Nachricht in Ihrem Terminal ausgegeben sehen!
+
+`npx hardhat run scripts/interact.js --network goerli`
+
+```
+Die Nachricht ist: Hallo Welt!
+Aktualisiere die Nachricht...
+Die neue Nachricht ist: Dies ist die neue Nachricht.
+```
+
+Während der Ausführung dieses Skripts werden Sie vielleicht feststellen, dass der Schritt `Aktualisiere die Nachricht...` eine Weile zum Laden braucht, bevor die neue Nachricht geladen wird. Dies liegt am Mining-Prozess; wenn Sie neugierig sind, Transaktionen während des Minings zu verfolgen, besuchen Sie den [Alchemy-Mempool](https://dashboard.alchemyapi.io/mempool), um den Status einer Transaktion zu sehen. Wenn die Transaktion verworfen wird, ist es auch hilfreich, [Goerli Etherscan](https://goerli.etherscan.io) zu überprüfen und nach Ihrem Transaktions-Hash zu suchen.
+
+## Teil 3: Veröffentlichen Sie Ihren Smart Contract auf Etherscan {#part-3-publish-your-smart-contract-to-etherscan}
+
+Sie haben die ganze harte Arbeit geleistet, um Ihren Smart Contract zum Leben zu erwecken; jetzt ist es an der Zeit, ihn mit der Welt zu teilen!
+
+Durch die Verifizierung Ihres Smart Contracts auf Etherscan kann jeder Ihren Quellcode einsehen und mit Ihrem Smart Contract interagieren. Legen wir los!
+
+### Schritt 1: Generieren Sie einen API-Schlüssel in Ihrem Etherscan-Konto {#step-1-generate-an-api-key-on-your-etherscan-account}
+
+Ein Etherscan-API-Schlüssel ist notwendig, um zu verifizieren, dass Sie der Eigentümer des Smart Contracts sind, den Sie veröffentlichen möchten.
+
+Wenn Sie noch kein Etherscan-Konto haben, [registrieren Sie sich für ein Konto](https://etherscan.io/register).
+
+Nach dem Einloggen finden Sie Ihren Benutzernamen in der Navigationsleiste, fahren Sie mit der Maus darüber und wählen Sie die Schaltfläche **Mein Profil**.
+
+Auf Ihrer Profilseite sollten Sie eine seitliche Navigationsleiste sehen. Wählen Sie in der seitlichen Navigationsleiste **API-Schlüssel**. Drücken Sie als Nächstes die Schaltfläche „Hinzufügen“, um einen neuen API-Schlüssel zu erstellen, benennen Sie Ihre App **hello-world** und drücken Sie die Schaltfläche **Neuen API-Schlüssel erstellen**.
+
+Ihr neuer API-Schlüssel sollte in der API-Schlüssel-Tabelle erscheinen. Kopieren Sie den API-Schlüssel in Ihre Zwischenablage.
+
+Als Nächstes müssen wir den Etherscan-API-Schlüssel zu unserer `.env`-Datei hinzufügen.
+
+Nachdem Sie ihn hinzugefügt haben, sollte Ihre `.env`-Datei so aussehen:
+
+```javascript
+API_URL = "https://eth-goerli.alchemyapi.io/v2/your-api-key"
+PUBLIC_KEY = "your-public-account-address"
+PRIVATE_KEY = "your-private-account-address"
+CONTRACT_ADDRESS = "your-contract-address"
+ETHERSCAN_API_KEY = "your-etherscan-key"
+```
+
+### Hardhat-bereitgestellte Smart Contracts {#hardhat-deployed-smart-contracts}
+
+#### Installieren Sie hardhat-etherscan {#install-hardhat-etherscan}
+
+Das Veröffentlichen Ihres Vertrags auf Etherscan mit Hardhat ist unkompliziert. Sie müssen zuerst das `hardhat-etherscan`-Plugin installieren, um zu beginnen. `hardhat-etherscan` wird automatisch den Quellcode und die ABI des Smart Contracts auf Etherscan verifizieren. Um dies hinzuzufügen, führen Sie im `hello-world`-Verzeichnis Folgendes aus:
+
+```text
+npm install --save-dev @nomiclabs/hardhat-etherscan
+```
+
+Nach der Installation fügen Sie die folgende Anweisung am Anfang Ihrer `hardhat.config.js` ein und fügen Sie die Etherscan-Konfigurationsoptionen hinzu:
+
+```javascript
+// hardhat.config.js
+
+require("dotenv").config()
+require("@nomiclabs/hardhat-ethers")
+require("@nomiclabs/hardhat-etherscan")
+
+const { API_URL, PRIVATE_KEY, ETHERSCAN_API_KEY } = process.env
+
+module.exports = {
+ solidity: "0.7.3",
+ defaultNetwork: "goerli",
+ networks: {
+ hardhat: {},
+ goerli: {
+ url: API_URL,
+ accounts: [`0x${PRIVATE_KEY}`],
+ },
+ },
+ etherscan: {
+ // Ihr API-Schlüssel für Etherscan
+ // Erhalten Sie einen unter https://etherscan.io/
+ apiKey: ETHERSCAN_API_KEY,
+ },
+}
+```
+
+#### Verifizieren Sie Ihren Smart Contract auf Etherscan {#verify-your-smart-contract-on-etherscan}
+
+Stellen Sie sicher, dass alle Dateien gespeichert und alle `.env`-Variablen korrekt konfiguriert sind.
+
+Führen Sie die `verify`-Aufgabe aus, indem Sie die Vertragsadresse und das Netzwerk übergeben, in dem sie bereitgestellt ist:
+
+```text
+npx hardhat verify --network goerli DEPLOYED_CONTRACT_ADDRESS 'Hello World!'
+```
+
+Stellen Sie sicher, dass `DEPLOYED_CONTRACT_ADDRESS` die Adresse Ihres bereitgestellten Smart Contracts im Goerli-Testnet ist. Außerdem muss das letzte Argument (`'Hello World!'`) derselbe String-Wert sein, der [während des Bereitstellungsschritts in Teil 1](#write-our-deploy-script) verwendet wurde.
+
+Wenn alles gut geht, sehen Sie die folgende Nachricht in Ihrem Terminal:
+
+```text
+Quellcode für Vertrag erfolgreich übermittelt
+contracts/HelloWorld.sol:HelloWorld unter 0xdeployed-contract-address
+zur Verifizierung auf Etherscan. Warte auf Verifizierungsergebnis...
+
+
+Vertrag HelloWorld auf Etherscan erfolgreich verifiziert.
+https://goerli.etherscan.io/address/#contracts
+```
+
+Glückwunsch! Ihr Smart-Contract-Code ist auf Etherscan!
+
+### Schauen Sie sich Ihren Smart Contract auf Etherscan an! {#check-out-your-smart-contract-on-etherscan}
+
+Wenn Sie dem in Ihrem Terminal bereitgestellten Link folgen, sollten Sie in der Lage sein, Ihren Smart-Contract-Code und Ihre ABI auf Etherscan veröffentlicht zu sehen!
+
+**Wuhuu – du hast es geschafft, Champion! Jetzt kann jeder Ihren Smart Contract aufrufen oder in ihn schreiben! Wir können es kaum erwarten zu sehen, was Sie als Nächstes bauen!**
+
+## Teil 4 – Integrieren Ihres Smart Contracts in das Frontend {#part-4-integrating-your-smart-contract-with-the-frontend}
+
+Am Ende dieses Tutorials werden Sie wissen, wie Sie:
+
+- Eine MetaMask-Wallet mit Ihrer Dapp verbinden
+- Daten aus Ihrem Smart Contract mit der [Alchemy Web3](https://docs.alchemy.com/alchemy/documentation/alchemy-web3) API lesen
+- Ethereum-Transaktionen mit MetaMask signieren
+
+Für diese Dapp werden wir [React](https://react.dev/) als unser Frontend-Framework verwenden; es ist jedoch wichtig zu beachten, dass wir nicht viel Zeit damit verbringen werden, dessen Grundlagen zu erläutern, da wir uns hauptsächlich darauf konzentrieren werden, Web3-Funktionalität in unser Projekt zu bringen.
+
+Als Voraussetzung sollten Sie ein grundlegendes Verständnis von React haben. Wenn nicht, empfehlen wir, das offizielle [Intro zu React-Tutorial](https://react.dev/learn) abzuschließen.
+
+### Die Starter-Dateien klonen {#clone-the-starter-files}
+
+Gehen Sie zunächst zum [hello-world-part-four GitHub-Repository](https://github.com/alchemyplatform/hello-world-part-four-tutorial), um die Starter-Dateien für dieses Projekt zu erhalten, und klonen Sie dieses Repository auf Ihren lokalen Rechner.
+
+Öffnen Sie das geklonte Repository lokal. Beachten Sie, dass es zwei Ordner enthält: `starter-files` und `completed`.
+
+- `starter-files` – **wir werden in diesem Verzeichnis arbeiten**, wir werden die Benutzeroberfläche mit Ihrer Ethereum-Wallet und dem Smart Contract verbinden, den wir in [Teil 3](#part-3) auf Etherscan veröffentlicht haben.
+- `completed` enthält das gesamte abgeschlossene Tutorial und sollte nur als Referenz verwendet werden, wenn Sie nicht weiterkommen.
+
+Öffnen Sie als Nächstes Ihre Kopie von `starter-files` in Ihrem bevorzugten Code-Editor und navigieren Sie dann in den `src`-Ordner.
+
+Der gesamte Code, den wir schreiben werden, befindet sich im Ordner `src`. Wir werden die `HelloWorld.js`-Komponente und die `util/interact.js`-JavaScript-Dateien bearbeiten, um unserem Projekt Web3-Funktionalität zu verleihen.
+
+### Sehen Sie sich die Starter-Dateien an {#check-out-the-starter-files}
+
+Bevor wir mit dem Codieren beginnen, lassen Sie uns untersuchen, was uns in den Starter-Dateien zur Verfügung gestellt wird.
+
+#### Dein React-Projekt zum Laufen bringen {#get-your-react-project-running}
+
+Beginnen wir damit, das React-Projekt in unserem Browser auszuführen. Das Schöne an React ist, dass alle Änderungen, die wir speichern, live in unserem Browser aktualisiert werden, sobald unser Projekt im Browser läuft.
+
+Um das Projekt zum Laufen zu bringen, navigieren Sie zum Stammverzeichnis des `starter-files`-Ordners und führen Sie `npm install` in Ihrem Terminal aus, um die Abhängigkeiten des Projekts zu installieren:
+
+```bash
+cd starter-files
+npm install
+```
+
+Sobald die Installation abgeschlossen ist, führe `npm start` in deinem Terminal aus:
+
+```bash
+npm start
+```
+
+Dadurch sollte [http://localhost:3000/](http://localhost:3000/) in Ihrem Browser geöffnet werden, wo Sie das Frontend für unser Projekt sehen. Es sollte aus einem Feld (einem Ort zum Aktualisieren der in Ihrem Smart Contract gespeicherten Nachricht), einer Schaltfläche „Wallet verbinden“ und einer Schaltfläche „Aktualisieren“ bestehen.
+
+Wenn Sie versuchen, auf eine der beiden Schaltflächen zu klicken, werden Sie feststellen, dass sie nicht funktionieren – das liegt daran, dass wir ihre Funktionalität noch programmieren müssen.
+
+#### Die `HelloWorld.js`-Komponente {#the-helloworld-js-component}
+
+Kehren wir zum `src`-Ordner in unserem Editor zurück und öffnen Sie die `HelloWorld.js`-Datei. Es ist sehr wichtig, dass wir alles in dieser Datei verstehen, da es sich um die primäre React-Komponente handelt, an der wir arbeiten werden.
+
+Oben in dieser Datei werden Sie feststellen, dass wir mehrere Import-Anweisungen haben, die notwendig sind, um unser Projekt zum Laufen zu bringen, einschließlich der React-Bibliothek, useEffect- und useState-Hooks, einige Elemente aus `./util/interact.js` (wir werden sie bald genauer beschreiben!) und das Alchemy-Logo.
+
+```javascript
+// HelloWorld.js
+
+import React from "react"
+import { useEffect, useState } from "react"
+import {
+ helloWorldContract,
+ connectWallet,
+ updateMessage,
+ loadCurrentMessage,
+ getCurrentWalletConnected,
+} from "./util/interact.js"
+
+import alchemylogo from "./alchemylogo.svg"
+```
+
+Als Nächstes haben wir unsere Zustandsvariablen, die wir nach bestimmten Ereignissen aktualisieren werden.
+
+```javascript
+// HelloWorld.js
+
+//Zustandsvariablen
+const [walletAddress, setWallet] = useState("")
+const [status, setStatus] = useState("")
+const [message, setMessage] = useState("Keine Verbindung zum Netzwerk.")
+const [newMessage, setNewMessage] = useState("")
+```
+
+Hier ist, was jede der Variablen darstellt:
+
+- `walletAddress` - eine Zeichenfolge, die die Wallet-Adresse des Benutzers speichert
+- `status` – ein String, der eine hilfreiche Nachricht speichert, die den Benutzer bei der Interaktion mit der Dapp anleitet
+- `message` – ein String, der die aktuelle Nachricht im Smart Contract speichert
+- `newMessage` – ein String, der die neue Nachricht speichert, die in den Smart Contract geschrieben wird
+
+Nach den Zustandsvariablen sehen Sie fünf nicht implementierte Funktionen: `useEffect` ,`addSmartContractListener`, `addWalletListener` , `connectWalletPressed` und `onUpdatePressed`. Wir erklären unten, was sie tun:
+
+```javascript
+// HelloWorld.js
+
+//wird nur einmal aufgerufen
+useEffect(async () => {
+ //TODO: implement
+}, [])
+
+function addSmartContractListener() {
+ //TODO: implement
+}
+
+function addWalletListener() {
+ //TODO: implement
+}
+
+const connectWalletPressed = async () => {
+ //TODO: implement
+}
+
+const onUpdatePressed = async () => {
+ //TODO: implement
+}
+```
+
+- [`useEffect`](https://legacy.reactjs.org/docs/hooks-effect.html) – dies ist ein React-Hook, der aufgerufen wird, nachdem Ihre Komponente gerendert wurde. Da ihm ein leeres Array `[]` als Eigenschaft übergeben wird (siehe Zeile 4), wird er nur beim _ersten_ Rendern der Komponente aufgerufen. Hier laden wir die aktuelle Nachricht, die in unserem Smart Contract gespeichert ist, rufen unsere Smart-Contract- und Wallet-Listener auf und aktualisieren unsere Benutzeroberfläche, um anzuzeigen, ob eine Wallet bereits verbunden ist.
+- `addSmartContractListener` – diese Funktion richtet einen Listener ein, der auf das `UpdatedMessages`-Ereignis unseres HelloWorld-Vertrags achtet und unsere Benutzeroberfläche aktualisiert, wenn die Nachricht in unserem Smart Contract geändert wird.
+- `addWalletListener` – diese Funktion richtet einen Listener ein, der Änderungen im Zustand der MetaMask-Wallet des Benutzers erkennt, z. B. wenn der Benutzer seine Wallet trennt oder Adressen wechselt.
+- `connectWalletPressed` – diese Funktion wird aufgerufen, um die MetaMask-Wallet des Benutzers mit unserer Dapp zu verbinden.
+- `onUpdatePressed` – diese Funktion wird aufgerufen, wenn der Benutzer die im Smart Contract gespeicherte Nachricht aktualisieren möchte.
+
+Gegen Ende dieser Datei haben wir die Benutzeroberfläche unserer Komponente.
+
+```javascript
+// HelloWorld.js
+
+//die Benutzeroberfläche unserer Komponente
+return (
+
+ 
+
+
+ Aktuelle Nachricht:
+ {message}
+
+ Neue Nachricht:
+
+
+ setNewMessage(e.target.value)}
+ value={newMessage}
+ />
+ {status}
+
+
+
+
+)
+```
+
+Wenn Sie diesen Code sorgfältig scannen, werden Sie feststellen, wo wir unsere verschiedenen Zustandsvariablen in unserer Benutzeroberfläche verwenden:
+
+- In den Zeilen 6-12, wenn die Wallet des Benutzers verbunden ist (d. h. `walletAddress.length > 0`), zeigen wir eine gekürzte Version der Benutzer-`walletAddress` in der Schaltfläche mit der ID „walletButton“ an; andernfalls steht dort einfach „Wallet verbinden“.
+- In Zeile 17 zeigen wir die aktuelle Nachricht an, die im Smart Contract gespeichert ist und im `message`-String erfasst wird.
+- In den Zeilen 23–26 verwenden wir eine [kontrollierte Komponente](https://legacy.reactjs.org/docs/forms.html#controlled-components), um unsere `newMessage`-Zustandsvariable zu aktualisieren, wenn sich die Eingabe im Textfeld ändert.
+
+Zusätzlich zu unseren Zustandsvariablen sehen Sie auch, dass die Funktionen `connectWalletPressed` und `onUpdatePressed` aufgerufen werden, wenn die Schaltflächen mit den IDs `publishButton` bzw. `walletButton` geklickt werden.
+
+Lassen Sie uns schließlich klären, wo diese `HelloWorld.js`-Komponente hinzugefügt wird.
+
+Wenn Sie zur `App.js`-Datei gehen, die die Hauptkomponente in React ist und als Container für alle anderen Komponenten dient, werden Sie sehen, dass unsere `HelloWorld.js`-Komponente in Zeile 7 eingefügt wird.
+
+Zu guter Letzt wollen wir uns noch eine weitere für Sie bereitgestellte Datei ansehen, die `interact.js`-Datei.
+
+#### Die `interact.js`-Datei {#the-interact-js-file}
+
+Da wir uns an das [M-V-C](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller)-Paradigma halten wollen, benötigen wir eine separate Datei, die alle unsere Funktionen zur Verwaltung der Logik, Daten und Regeln unserer Dapp enthält, und diese Funktionen dann in unser Frontend (unsere `HelloWorld.js`-Komponente) exportieren können.
+
+👆🏽Dies ist genau der Zweck unserer `interact.js`-Datei!
+
+Navigieren Sie zum `util`-Ordner in Ihrem `src`-Verzeichnis, und Sie werden feststellen, dass wir eine Datei namens `interact.js` beigefügt haben, die alle unsere Smart-Contract-Interaktions- und Wallet-Funktionen und -Variablen enthalten wird.
+
+```javascript
+// interact.js
+
+//export const helloWorldContract;
+
+export const loadCurrentMessage = async () => {}
+
+export const connectWallet = async () => {}
+
+const getCurrentWalletConnected = async () => {}
+
+export const updateMessage = async (message) => {}
+```
+
+Sie werden am Anfang der Datei feststellen, dass wir das `helloWorldContract`-Objekt auskommentiert haben. Später in diesem Tutorial werden wir dieses Objekt entkommentieren und unseren Smart Contract in dieser Variable instanziieren, die wir dann in unsere `HelloWorld.js`-Komponente exportieren werden.
+
+Die vier nicht implementierten Funktionen nach unserem `helloWorldContract`-Objekt tun Folgendes:
+
+- `loadCurrentMessage` – diese Funktion behandelt die Logik zum Laden der aktuellen Nachricht, die im Smart Contract gespeichert ist. Es wird ein _Lese_-Aufruf an den Hallo-Welt-Smart-Contract über die [Alchemy Web3 API](https://github.com/alchemyplatform/alchemy-web3) gemacht.
+- `connectWallet` – diese Funktion verbindet die MetaMask des Benutzers mit unserer Dapp.
+- `getCurrentWalletConnected` – diese Funktion prüft, ob beim Laden der Seite bereits ein Ethereum-Konto mit unserer Dapp verbunden ist, und aktualisiert unsere Benutzeroberfläche entsprechend.
+- `updateMessage` – diese Funktion aktualisiert die im Smart Contract gespeicherte Nachricht. Es wird ein _Schreib_-Aufruf an den Hallo-Welt-Smart-Contract gemacht, sodass die MetaMask-Wallet des Benutzers eine Ethereum-Transaktion signieren muss, um die Nachricht zu aktualisieren.
+
+Jetzt, da wir verstehen, womit wir arbeiten, lassen Sie uns herausfinden, wie wir aus unserem Smart Contract lesen können!
+
+### Schritt 3: Lesen aus Ihrem Smart Contract {#step-3-read-from-your-smart-contract}
+
+Um aus Ihrem Smart Contract zu lesen, müssen Sie erfolgreich Folgendes einrichten:
+
+- Eine API-Verbindung zur Ethereum-Chain
+- Eine geladene Instanz Ihres Smart Contracts
+- Eine Funktion zum Aufrufen Ihrer Smart-Contract-Funktion
+- Ein Listener, der auf Aktualisierungen achtet, wenn sich die Daten, die Sie aus dem Smart Contract lesen, ändern
+
+Das mag nach vielen Schritten klingen, aber keine Sorge! Wir führen Sie Schritt für Schritt durch jeden einzelnen davon! :\)
+
+#### Eine API-Verbindung zur Ethereum-Chain herstellen {#establish-an-api-connection-to-the-ethereum-chain}
+
+Erinnern Sie sich, wie wir in Teil 2 dieses Tutorials unseren [Alchemy Web3-Schlüssel verwendet haben, um aus unserem Smart Contract zu lesen](https://docs.alchemy.com/alchemy/tutorials/hello-world-smart-contract/interacting-with-a-smart-contract#step-1-install-web3-library)? Sie benötigen auch einen Alchemy Web3-Schlüssel in Ihrer Dapp, um von der Chain zu lesen.
+
+Wenn Sie es noch nicht haben, installieren Sie zuerst [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3), indem Sie zum Stammverzeichnis Ihrer `starter-files` navigieren und Folgendes in Ihrem Terminal ausführen:
+
+```text
+npm install @alch/alchemy-web3
+```
+
+[Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) ist ein Wrapper um [Web3.js](https://docs.web3js.org/) und bietet erweiterte API-Methoden und andere entscheidende Vorteile, um dir das Leben als Web3-Entwickler zu erleichtern. Es ist so konzipiert, dass es eine minimale Konfiguration erfordert, sodass du es sofort in deiner App verwenden kannst!
+
+Installieren Sie dann das [dotenv](https://www.npmjs.com/package/dotenv)-Paket in Ihrem Projektverzeichnis, damit wir einen sicheren Ort haben, um unseren API-Schlüssel nach dem Abrufen zu speichern.
+
+```text
+npm install dotenv --save
+```
+
+Für unsere Dapp **werden wir unseren Websockets-API-Schlüssel** anstelle unseres HTTP-API-Schlüssels verwenden, da wir damit einen Listener einrichten können, der erkennt, wann sich die im Smart Contract gespeicherte Nachricht ändert.
+
+Sobald Sie Ihren API-Schlüssel haben, erstellen Sie eine `.env`-Datei in Ihrem Stammverzeichnis und fügen Sie Ihre Alchemy-Websockets-URL hinzu. Danach sollte Ihre `.env`-Datei so aussehen:
+
+```javascript
+REACT_APP_ALCHEMY_KEY = wss://eth-goerli.ws.alchemyapi.io/v2/
+```
+
+Jetzt sind wir bereit, unseren Alchemy Web3-Endpunkt in unserer Dapp einzurichten! Kehren wir zu unserer `interact.js` zurück, die in unserem `util`-Ordner verschachtelt ist, und fügen Sie den folgenden Code am Anfang der Datei hinzu:
+
+```javascript
+// interact.js
+
+require("dotenv").config()
+const alchemyKey = process.env.REACT_APP_ALCHEMY_KEY
+const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
+const web3 = createAlchemyWeb3(alchemyKey)
+
+//export const helloWorldContract;
+```
+
+Oben haben wir zuerst den Alchemy-Schlüssel aus unserer `.env`-Datei importiert und dann unseren `alchemyKey` an `createAlchemyWeb3` übergeben, um unseren Alchemy Web3-Endpunkt einzurichten.
+
+Mit diesem Endpunkt sind wir bereit, unseren Smart Contract zu laden!
+
+#### Ihren Hello World Smart Contract laden {#loading-your-hello-world-smart-contract}
+
+Um Ihren Hallo-Welt-Smart-Contract zu laden, benötigen Sie seine Vertragsadresse und ABI, die beide auf Etherscan zu finden sind, wenn Sie [Teil 3 dieses Tutorials abgeschlossen haben.](/developers/tutorials/hello-world-smart-contract-fullstack/#part-3-publish-your-smart-contract-to-etherscan-part-3-publish-your-smart-contract-to-etherscan)
+
+#### Wie Sie Ihre Vertrags-ABI von Etherscan erhalten {#how-to-get-your-contract-abi-from-etherscan}
+
+Wenn Sie Teil 3 dieses Tutorials übersprungen haben, können Sie den HelloWorld-Vertrag mit der Adresse [0x6f3f635A9762B47954229Ea479b4541eAF402A6A](https://goerli.etherscan.io/address/0x6f3f635a9762b47954229ea479b4541eaf402a6a#code) verwenden. Seine ABI finden Sie [hier](https://goerli.etherscan.io/address/0x6f3f635a9762b47954229ea479b4541eaf402a6a#code).
+
+Eine Vertrags-ABI ist notwendig, um festzulegen, welche Funktion ein Vertrag aufrufen wird, sowie um sicherzustellen, dass die Funktion Daten im erwarteten Format zurückgibt. Sobald wir unsere Vertrags-ABI kopiert haben, speichern wir sie als JSON-Datei namens `contract-abi.json` in Ihrem `src`-Verzeichnis.
+
+Ihre contract-abi.json sollte in Ihrem src-Ordner gespeichert sein.
+
+Bewaffnet mit unserer Vertragsadresse, ABI und dem Alchemy Web3-Endpunkt, können wir die [contract-Methode](https://docs.web3js.org/api/web3-eth-contract/class/Contract) verwenden, um eine Instanz unseres Smart Contracts zu laden. Importieren Sie Ihre Vertrags-ABI in die `interact.js`-Datei und fügen Sie Ihre Vertragsadresse hinzu.
+
+```javascript
+// interact.js
+
+const contractABI = require("../contract-abi.json")
+const contractAddress = "0x6f3f635A9762B47954229Ea479b4541eAF402A6A"
+```
+
+Wir können nun endlich unsere `helloWorldContract`-Variable entkommentieren und den Smart Contract mit unserem AlchemyWeb3-Endpunkt laden:
+
+```javascript
+// interact.js
+export const helloWorldContract = new web3.eth.Contract(
+ contractABI,
+ contractAddress
+)
+```
+
+Zusammenfassend sollten die ersten 12 Zeilen Ihrer `interact.js` jetzt so aussehen:
+
+```javascript
+// interact.js
+
+require("dotenv").config()
+const alchemyKey = process.env.REACT_APP_ALCHEMY_KEY
+const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
+const web3 = createAlchemyWeb3(alchemyKey)
+
+const contractABI = require("../contract-abi.json")
+const contractAddress = "0x6f3f635A9762B47954229Ea479b4541eAF402A6A"
+
+export const helloWorldContract = new web3.eth.Contract(
+ contractABI,
+ contractAddress
+)
+```
+
+Jetzt, da wir unseren Vertrag geladen haben, können wir unsere `loadCurrentMessage`-Funktion implementieren!
+
+#### Implementierung von `loadCurrentMessage` in Ihrer `interact.js`-Datei {#implementing-loadCurrentMessage-in-your-interact-js-file}
+
+Diese Funktion ist super einfach. Wir werden einen einfachen asynchronen web3-Aufruf machen, um aus unserem Vertrag zu lesen. Unsere Funktion wird die im Smart Contract gespeicherte Nachricht zurückgeben:
+
+Aktualisieren Sie die `loadCurrentMessage` in Ihrer `interact.js`-Datei auf Folgendes:
+
+```javascript
+// interact.js
+
+export const loadCurrentMessage = async () => {
+ const message = await helloWorldContract.methods.message().call()
+ return message
+}
+```
+
+Da wir diesen Smart Contract in unserer Benutzeroberfläche anzeigen möchten, aktualisieren wir die `useEffect`-Funktion in unserer `HelloWorld.js`-Komponente auf Folgendes:
+
+```javascript
+// HelloWorld.js
+
+//wird nur einmal aufgerufen
+useEffect(async () => {
+ const message = await loadCurrentMessage()
+ setMessage(message)
+}, [])
+```
+
+Beachten Sie, dass wir `loadCurrentMessage` nur einmal während des ersten Renderns der Komponente aufrufen wollen. Wir werden bald `addSmartContractListener` implementieren, um die Benutzeroberfläche automatisch zu aktualisieren, nachdem sich die Nachricht im Smart Contract geändert hat.
+
+Bevor wir uns mit unserem Listener befassen, schauen wir uns an, was wir bisher haben! Speichern Sie Ihre `HelloWorld.js`- und `interact.js`-Dateien und gehen Sie dann zu [http://localhost:3000/](http://localhost:3000/)
+
+Sie werden feststellen, dass die aktuelle Nachricht nicht mehr „Keine Verbindung zum Netzwerk“ lautet. Stattdessen spiegelt sie die im Smart Contract gespeicherte Nachricht wider. Klasse!
+
+#### Ihre Benutzeroberfläche sollte jetzt die im Smart Contract gespeicherte Nachricht widerspiegeln {#your-UI-should-now-reflect-the-message-stored-in-the-smart-contract}
+
+Apropos Listener...
+
+#### Implementieren Sie `addSmartContractListener` {#implement-addsmartcontractlistener}
+
+Wenn Sie an die `HelloWorld.sol`-Datei zurückdenken, die wir in [Teil 1 dieser Tutorial-Reihe](https://docs.alchemy.com/alchemy/tutorials/hello-world-smart-contract#step-10-write-our-contract) geschrieben haben, werden Sie sich daran erinnern, dass es ein Smart-Contract-Ereignis namens `UpdatedMessages` gibt, das ausgegeben wird, nachdem die `update`-Funktion unseres Smart Contracts aufgerufen wurde (siehe Zeilen 9 und 27):
+
+```javascript
+// HelloWorld.sol
+
+// Gibt die Version von Solidity an, unter Verwendung von semantischer Versionierung.
+// Mehr erfahren: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
+pragma solidity ^0.7.3;
+
+// Definiert einen Vertrag namens `HelloWorld`.
+// Ein Vertrag ist eine Sammlung von Funktionen und Daten (seinem Zustand). Nach der Bereitstellung befindet sich ein Vertrag an einer bestimmten Adresse auf der Ethereum-Blockchain. Mehr erfahren: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
+contract HelloWorld {
+
+ //Wird ausgegeben, wenn die update-Funktion aufgerufen wird
+ //Smart-Contract-Ereignisse sind eine Möglichkeit für Ihren Vertrag, Ihrer App-Frontend mitzuteilen, dass auf der Blockchain etwas passiert ist. Das Frontend kann auf bestimmte Ereignisse „hören“ und bei deren Eintreten Maßnahmen ergreifen.
+ event UpdatedMessages(string oldStr, string newStr);
+
+ // Deklariert eine Zustandsvariable `message` vom Typ `string`.
+ // Zustandsvariablen sind Variablen, deren Werte dauerhaft im Vertragsspeicher gespeichert werden. Das Schlüsselwort `public` macht Variablen von außerhalb eines Vertrags zugänglich und erstellt eine Funktion, die andere Verträge oder Clients aufrufen können, um auf den Wert zuzugreifen.
+ string public message;
+
+ // Ähnlich wie in vielen klassenbasierten objektorientierten Sprachen ist ein Konstruktor eine spezielle Funktion, die nur bei der Erstellung des Vertrags ausgeführt wird.
+ // Konstruktoren werden verwendet, um die Daten des Vertrags zu initialisieren. Mehr erfahren:https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
+ constructor(string memory initMessage) {
+
+ // Akzeptiert ein String-Argument `initMessage` und setzt den Wert in die Speichervariable `message` des Vertrags).
+ message = initMessage;
+ }
+
+ // Eine öffentliche Funktion, die ein String-Argument akzeptiert und die Speichervariable `message` aktualisiert.
+ function update(string memory newMessage) public {
+ string memory oldMsg = message;
+ message = newMessage;
+ emit UpdatedMessages(oldMsg, newMessage);
+ }
+}
+```
+
+Smart-Contract-Ereignisse sind eine Möglichkeit für Ihren Vertrag, Ihrer Frontend-Anwendung mitzuteilen, dass auf der Blockchain etwas passiert ist (d. h. es gab ein _Ereignis_), die auf bestimmte Ereignisse „hören“ und bei deren Eintreten Maßnahmen ergreifen kann.
+
+Die `addSmartContractListener`-Funktion wird speziell auf das `UpdatedMessages`-Ereignis unseres Hallo-Welt-Smart-Contracts lauschen und unsere Benutzeroberfläche aktualisieren, um die neue Nachricht anzuzeigen.
+
+Ändern Sie `addSmartContractListener` in Folgendes:
+
+```javascript
+// HelloWorld.js
+
+function addSmartContractListener() {
+ helloWorldContract.events.UpdatedMessages({}, (error, data) => {
+ if (error) {
+ setStatus("😥 " + error.message)
+ } else {
+ setMessage(data.returnValues[1])
+ setNewMessage("")
+ setStatus("🎉 Ihre Nachricht wurde aktualisiert!")
+ }
+ })
+}
+```
+
+Lassen Sie uns aufschlüsseln, was passiert, wenn der Listener ein Ereignis erkennt:
+
+- Wenn ein Fehler auftritt, wenn das Ereignis ausgegeben wird, wird dies in der Benutzeroberfläche über unsere `status`-Zustandsvariable angezeigt.
+- Andernfalls verwenden wir das zurückgegebene `data`-Objekt. Das `data.returnValues` ist ein bei Null indiziertes Array, bei dem das erste Element im Array die vorherige Nachricht und das zweite Element die aktualisierte speichert. Insgesamt werden wir bei einem erfolgreichen Ereignis unseren `message`-String auf die aktualisierte Nachricht setzen, den `newMessage`-String leeren und unsere `status`-Zustandsvariable aktualisieren, um anzuzeigen, dass eine neue Nachricht in unserem Smart Contract veröffentlicht wurde.
+
+Schließlich rufen wir unseren Listener in unserer `useEffect`-Funktion auf, damit er beim ersten Rendern der `HelloWorld.js`-Komponente initialisiert wird. Insgesamt sollte Ihre `useEffect`-Funktion so aussehen:
+
+```javascript
+// HelloWorld.js
+
+useEffect(async () => {
+ const message = await loadCurrentMessage()
+ setMessage(message)
+ addSmartContractListener()
+}, [])
+```
+
+Jetzt, da wir in der Lage sind, aus unserem Smart Contract zu lesen, wäre es großartig herauszufinden, wie wir auch in ihn schreiben können! Um jedoch in unsere Dapp zu schreiben, müssen wir zuerst eine Ethereum-Wallet damit verbunden haben.
+
+Als Nächstes werden wir uns also mit der Einrichtung unserer Ethereum-Wallet (MetaMask) befassen und sie dann mit unserer Dapp verbinden!
+
+### Schritt 4: Richten Sie Ihre Ethereum-Wallet ein {#step-4-set-up-your-ethereum-wallet}
+
+Um etwas in die Ethereum-Chain zu schreiben, müssen Benutzer Transaktionen mit den privaten Schlüsseln ihrer virtuellen Wallet signieren. Für dieses Tutorial verwenden wir [MetaMask](https://metamask.io/), eine virtuelle Wallet im Browser, die zur Verwaltung Ihrer Ethereum-Kontoadresse verwendet wird, da sie diese Transaktionssignierung für den Endbenutzer super einfach macht.
+
+Wenn Sie mehr darüber erfahren möchten, wie Transaktionen auf Ethereum funktionieren, sehen Sie sich [diese Seite](/developers/docs/transactions/) der Ethereum Foundation an.
+
+#### MetaMask herunterladen {#download-metamask}
+
+Sie können MetaMask [hier](https://metamask.io/download) kostenlos herunterladen und ein Konto erstellen. Wenn Sie ein Konto erstellen oder bereits eines haben, stellen Sie sicher, dass Sie oben rechts zum „Goerli Test Network“ wechseln (damit wir nicht mit echtem Geld arbeiten).
+
+#### Ether aus einem Faucet hinzufügen {#add-ether-from-a-faucet}
+
+Um eine Transaktion auf der Ethereum-Blockchain zu signieren, benötigen wir einige gefälschte Eth. Um Eth zu erhalten, können Sie zu [FaucETH](https://fauceth.komputing.org) gehen und Ihre Goerli-Kontoadresse eingeben, auf „Geld anfordern“ klicken, dann im Dropdown-Menü „Ethereum Testnet Goerli“ auswählen und schließlich erneut auf die Schaltfläche „Geld anfordern“ klicken. Kurz darauf solltest du ETH in deinem MetaMask-Konto sehen!
+
+#### Überprüfen Sie Ihr Guthaben {#check-your-balance}
+
+Um zu überprüfen, ob unser Guthaben vorhanden ist, machen wir eine [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance)-Anfrage mit dem [Composer-Tool von Alchemy](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D). Dies gibt den Betrag an ETH in unserer Wallet zurück. Nachdem Sie die Adresse Ihres MetaMask-Kontos eingegeben und auf “Send Request” (Anforderung senden) geklickt haben, sollten Sie eine Antwort ähnlich der Folgenden erhalten:
+
+```text
+{"jsonrpc": "2.0", "id": 0, "result": "0xde0b6b3a7640000"}
+```
+
+**HINWEIS:** Dieses Ergebnis ist in Wei, nicht in ETH. Wei ist die kleinste Einheit von Ether. Die Umrechnung von Wei in ETH ist: 1 ETH = 10¹⁸ Wei. Wenn wir also 0xde0b6b3a7640000 in eine Dezimalzahl umwandeln, erhalten wir 1\*10¹⁸, was 1 ETH entspricht.
+
+Puh! Unser Falschgeld ist da! 🤑
+
+### Schritt 5: MetaMask mit Ihrer Benutzeroberfläche verbinden {#step-5-connect-metamask-to-your-UI}
+
+Nachdem unsere MetaMask-Wallet nun eingerichtet ist, verbinden wir unsere Dapp damit!
+
+#### Die `connectWallet`-Funktion {#the-connectWallet-function}
+
+In unserer `interact.js`-Datei implementieren wir die `connectWallet`-Funktion, die wir dann in unserer `HelloWorld.js`-Komponente aufrufen können.
+
+Lassen Sie uns `connectWallet` wie folgt ändern:
+
+```javascript
+// interact.js
+
+export const connectWallet = async () => {
+ if (window.ethereum) {
+ try {
+ const addressArray = await window.ethereum.request({
+ method: "eth_requestAccounts",
+ })
+ const obj = {
+ status: "👆🏽 Schreiben Sie eine Nachricht in das Textfeld oben.",
+ address: addressArray[0],
+ }
+ return obj
+ } catch (err) {
+ return {
+ address: "",
+ status: "😥 " + err.message,
+ }
+ }
+ } else {
+ return {
+ address: "",
+ status: (
+
+
+ {" "}
+ 🦊
+ Sie müssen MetaMask, eine virtuelle Ethereum-Wallet, in Ihrem
+ Browser installieren.
+
+
+
+ ),
+ }
+ }
+}
+```
+
+Also, was macht dieser riesige Codeblock genau?
+
+Zuerst prüft er, ob `window.ethereum` in Ihrem Browser aktiviert ist.
+
+`window.ethereum` ist eine globale API, die von MetaMask und anderen Wallet-Anbietern eingeschleust wird und es Websites ermöglicht, die Ethereum-Konten von Benutzern anzufordern. Wenn genehmigt, kann es Daten von den Blockchains lesen, mit denen der Benutzer verbunden ist, und dem Benutzer vorschlagen, Nachrichten und Transaktionen zu signieren. Weitere Informationen findest du in der [MetaMask-Dokumentation](https://docs.metamask.io/guide/ethereum-provider.html#table-of-contents)!
+
+Wenn `window.ethereum` _nicht_ vorhanden ist, bedeutet das, dass MetaMask nicht installiert ist. Dies führt dazu, dass ein JSON-Objekt zurückgegeben wird, bei dem die zurückgegebene `address` eine leere Zeichenfolge ist und das `status`-JSX-Objekt meldet, dass der Benutzer MetaMask installieren muss.
+
+Wenn `window.ethereum` jedoch vorhanden _ist_, dann wird es interessant.
+
+Mithilfe einer try/catch-Schleife versuchen wir, eine Verbindung zu MetaMask herzustellen, indem wir [`window.ethereum.request({ method: "eth_requestAccounts" });`](https://docs.metamask.io/guide/rpc-api.html#eth-requestaccounts) aufrufen. Der Aufruf dieser Funktion öffnet MetaMask im Browser, woraufhin der Benutzer aufgefordert wird, seine Wallet mit deiner Dapp zu verbinden.
+
+- Wenn der Benutzer sich entscheidet, eine Verbindung herzustellen, gibt `method: "eth_requestAccounts"` ein Array zurück, das alle Konto-Adressen des Benutzers enthält, die mit der Dapp verbunden sind. Insgesamt gibt unsere `connectWallet`-Funktion ein JSON-Objekt zurück, das die _erste_ `address` in diesem Array (siehe Zeile 9) und eine `status`-Nachricht enthält, die den Benutzer auffordert, eine Nachricht an den Smart Contract zu schreiben.
+- Wenn der Benutzer die Verbindung ablehnt, enthält das JSON-Objekt eine leere Zeichenfolge für die zurückgegebene `address` und eine `status`-Nachricht, die widerspiegelt, dass der Benutzer die Verbindung abgelehnt hat.
+
+Nachdem wir diese `connectWallet`-Funktion geschrieben haben, ist der nächste Schritt, sie in unserer `HelloWorld.js`-Komponente aufzurufen.
+
+#### Die `connectWallet`-Funktion zu Ihrer `HelloWorld.js`-UI-Komponente hinzufügen {#add-the-connectWallet-function-to-your-HelloWorld-js-ui-component}
+
+Navigieren Sie zur `connectWalletPressed`-Funktion in `HelloWorld.js` und aktualisieren Sie sie wie folgt:
+
+```javascript
+// HelloWorld.js
+
+const connectWalletPressed = async () => {
+ const walletResponse = await connectWallet()
+ setStatus(walletResponse.status)
+ setWallet(walletResponse.address)
+}
+```
+
+Beachten Sie, wie der größte Teil unserer Funktionalität von unserer `HelloWorld.js`-Komponente aus der `interact.js`-Datei abstrahiert wird? Dies geschieht, damit wir dem M-V-C-Paradigma entsprechen!
+
+In `connectWalletPressed` machen wir einfach einen Await-Aufruf an unsere importierte `connectWallet`-Funktion, und mit ihrer Antwort aktualisieren wir unsere `status`- und `walletAddress`-Variablen über ihre State-Hooks.
+
+Lassen Sie uns nun beide Dateien (`HelloWorld.js` und `interact.js`) speichern und unsere bisherige Benutzeroberfläche testen.
+
+Öffnen Sie Ihren Browser auf der Seite [http://localhost:3000/](http://localhost:3000/) und drücken Sie die Schaltfläche „Wallet verbinden“ oben rechts auf der Seite.
+
+Wenn du MetaMask installiert hast, solltest du aufgefordert werden, deine Wallet mit deiner Dapp zu verbinden. Akzeptiere die Aufforderung, eine Verbindung herzustellen.
+
+Sie sollten sehen, dass die Wallet-Schaltfläche nun anzeigt, dass Ihre Adresse verbunden ist! Jaaaaa 🔥
+
+Als Nächstes versuche, die Seite neu zu laden ... Das ist seltsam. Unsere Wallet-Schaltfläche fordert uns auf, MetaMask zu verbinden, obwohl es bereits verbunden ist ...
+
+Aber keine Angst! Wir können das leicht adressieren (verstanden?) indem wir `getCurrentWalletConnected` implementieren, das prüft, ob eine Adresse bereits mit unserer Dapp verbunden ist, und unsere Benutzeroberfläche entsprechend aktualisiert!
+
+#### Die `getCurrentWalletConnected`-Funktion {#the-getcurrentwalletconnected-function}
+
+Aktualisieren Sie Ihre `getCurrentWalletConnected`-Funktion in der `interact.js`-Datei wie folgt:
+
+```javascript
+// interact.js
+
+export const getCurrentWalletConnected = async () => {
+ if (window.ethereum) {
+ try {
+ const addressArray = await window.ethereum.request({
+ method: "eth_accounts",
+ })
+ if (addressArray.length > 0) {
+ return {
+ address: addressArray[0],
+ status: "👆🏽 Schreiben Sie eine Nachricht in das Textfeld oben.",
+ }
+ } else {
+ return {
+ address: "",
+ status: "🦊 Verbinden Sie sich mit MetaMask über die Schaltfläche oben rechts.",
+ }
+ }
+ } catch (err) {
+ return {
+ address: "",
+ status: "😥 " + err.message,
+ }
+ }
+ } else {
+ return {
+ address: "",
+ status: (
+
+
+ {" "}
+ 🦊
+ Sie müssen MetaMask, eine virtuelle Ethereum-Wallet, in Ihrem
+ Browser installieren.
+
+
+
+ ),
+ }
+ }
+}
+```
+
+Dieser Code ist _sehr_ ähnlich der `connectWallet`-Funktion, die wir gerade im vorherigen Schritt geschrieben haben.
+
+Der Hauptunterschied besteht darin, dass wir anstelle der Methode `eth_requestAccounts`, die MetaMask für den Benutzer öffnet, um seine Wallet zu verbinden, hier die Methode `eth_accounts` aufrufen, die einfach ein Array zurückgibt, das die MetaMask-Adressen enthält, die derzeit mit unserer Dapp verbunden sind.
+
+Um diese Funktion in Aktion zu sehen, rufen wir sie in unserer `useEffect`-Funktion unserer `HelloWorld.js`-Komponente auf:
+
+```javascript
+// HelloWorld.js
+
+useEffect(async () => {
+ const message = await loadCurrentMessage()
+ setMessage(message)
+ addSmartContractListener()
+
+ const { address, status } = await getCurrentWalletConnected()
+ setWallet(address)
+ setStatus(status)
+}, [])
+```
+
+Beachte, dass wir die Antwort unseres Aufrufs an `getCurrentWalletConnected` verwenden, um unsere `walletAddress`- und `status`-Zustandsvariablen zu aktualisieren.
+
+Nachdem Sie diesen Code hinzugefügt haben, versuchen wir, unser Browserfenster zu aktualisieren.
+
+Nett! Die Schaltfläche sollte anzeigen, dass du verbunden bist, und eine Vorschau der Adresse deiner verbundenen Wallet anzeigen – auch nach dem Aktualisieren!
+
+#### Implementieren Sie `addWalletListener` {#implement-addwalletlistener}
+
+Der letzte Schritt in der Einrichtung unserer Dapp-Wallet ist die Implementierung des Wallet-Listeners, damit unsere Benutzeroberfläche aktualisiert wird, wenn sich der Zustand unserer Wallet ändert, z. B. wenn der Benutzer die Verbindung trennt oder das Konto wechselt.
+
+Ändern Sie in Ihrer `HelloWorld.js`-Datei Ihre `addWalletListener`-Funktion wie folgt:
+
+```javascript
+// HelloWorld.js
+
+function addWalletListener() {
+ if (window.ethereum) {
+ window.ethereum.on("accountsChanged", (accounts) => {
+ if (accounts.length > 0) {
+ setWallet(accounts[0])
+ setStatus("👆🏽 Schreiben Sie eine Nachricht in das Textfeld oben.")
+ } else {
+ setWallet("")
+ setStatus("🦊 Verbinden Sie sich mit MetaMask über die Schaltfläche oben rechts.")
+ }
+ })
+ } else {
+ setStatus(
+
+ {" "}
+ 🦊
+ Sie müssen MetaMask, eine virtuelle Ethereum-Wallet, in Ihrem Browser installieren.
+
+
+ )
+ }
+}
+```
+
+Ich wette, Sie brauchen an dieser Stelle nicht einmal mehr unsere Hilfe, um zu verstehen, was hier vor sich geht, aber aus Gründen der Vollständigkeit, lassen Sie es uns schnell aufschlüsseln:
+
+- Zuerst prüft unsere Funktion, ob `window.ethereum` aktiviert ist (d. h. MetaMask ist installiert).
+ - Wenn nicht, setzen wir einfach unsere `status`-Zustandsvariable auf eine JSX-Zeichenfolge, die den Benutzer auffordert, MetaMask zu installieren.
+ - Wenn es aktiviert ist, richten wir den Listener `window.ethereum.on("accountsChanged")` in Zeile 3 ein, der auf Zustandsänderungen in der MetaMask-Wallet lauscht. Dazu gehören, wenn der Benutzer ein zusätzliches Konto mit der Dapp verbindet, Konten wechselt oder ein Konto trennt. Wenn mindestens ein Konto verbunden ist, wird die Zustandsvariable `walletAddress` als das erste Konto im `accounts`-Array aktualisiert, das vom Listener zurückgegeben wird. Andernfalls wird `walletAddress` als leere Zeichenfolge festgelegt.
+
+Zu guter Letzt müssen wir sie in unserer `useEffect`-Funktion aufrufen:
+
+```javascript
+// HelloWorld.js
+
+useEffect(async () => {
+ const message = await loadCurrentMessage()
+ setMessage(message)
+ addSmartContractListener()
+
+ const { address, status } = await getCurrentWalletConnected()
+ setWallet(address)
+ setStatus(status)
+
+ addWalletListener()
+}, [])
+```
+
+Und das war's! Wir haben erfolgreich die gesamte Funktionalität unserer Wallet programmiert! Jetzt zu unserer letzten Aufgabe: die im Smart Contract gespeicherte Nachricht aktualisieren!
+
+### Schritt 6: Implementieren der `updateMessage`-Funktion {#step-6-implement-the-updateMessage-function}
+
+Also gut, Leute, wir sind auf der Zielgeraden! In `updateMessage` Ihrer `interact.js`-Datei werden wir Folgendes tun:
+
+1. Sicherstellen, dass die Nachricht, die wir in unserem Smart Contact veröffentlichen möchten, gültig ist
+2. Unsere Transaktion mit MetaMask signieren
+3. Diese Funktion aus unserer `HelloWorld.js`-Frontend-Komponente aufrufen
+
+Das wird nicht lange dauern; lassen Sie uns diese Dapp fertigstellen!
+
+#### Fehlerbehandlung bei der Eingabe {#input-error-handling}
+
+Natürlich ist es sinnvoll, am Anfang der Funktion eine Art Eingabefehlerbehandlung zu haben.
+
+Wir möchten, dass unsere Funktion frühzeitig zurückkehrt, wenn keine MetaMask-Erweiterung installiert ist, keine Wallet verbunden ist (d. h. die übergebene `address` ein leerer String ist) oder die `message` ein leerer String ist. Fügen wir die folgende Fehlerbehandlung zu `updateMessage` hinzu:
+
+```javascript
+// interact.js
+
+export const updateMessage = async (address, message) => {
+ if (!window.ethereum || address === null) {
+ return {
+ status:
+ "💡 Verbinden Sie Ihre MetaMask-Wallet, um die Nachricht auf der Blockchain zu aktualisieren.",
+ }
+ }
+
+ if (message.trim() === "") {
+ return {
+ status: "❌ Ihre Nachricht darf kein leerer String sein.",
+ }
+ }
+}
+```
+
+Jetzt, da wir eine ordnungsgemäße Eingabefehlerbehandlung haben, ist es Zeit, die Transaktion über MetaMask zu signieren!
+
+#### Unsere Transaktion signieren {#signing-our-transaction}
+
+Wenn Sie bereits mit traditionellen Web3-Ethereum-Transaktionen vertraut sind, wird Ihnen der Code, den wir als Nächstes schreiben, sehr bekannt vorkommen. Fügen Sie unterhalb Ihres Eingabefehlerbehandlungscodes Folgendes zu `updateMessage` hinzu:
+
+```javascript
+// interact.js
+
+//Transaktionsparameter einrichten
+const transactionParameters = {
+ to: contractAddress, // Erforderlich, außer bei der Veröffentlichung von Verträgen.
+ from: address, // muss mit der aktiven Adresse des Benutzers übereinstimmen.
+ data: helloWorldContract.methods.update(message).encodeABI(),
+}
+
+// Transaktion signieren
+try {
+ const txHash = await window.ethereum.request({
+ method: "eth_sendTransaction",
+ params: [transactionParameters],
+ })
+ return {
+ status: (
+
+ ✅{" "}
+
+ Sehen Sie sich den Status Ihrer Transaktion auf Etherscan an!
+
+
+ ℹ️ Sobald die Transaktion vom Netzwerk verifiziert ist, wird die Nachricht
+ automatisch aktualisiert.
+
+ ),
+ }
+} catch (error) {
+ return {
+ status: "😥 " + error.message,
+ }
+}
+```
+
+Schauen wir uns an, was hier passiert. Zuerst richten wir unsere Transaktionsparameter ein, wobei:
+
+- `to` gibt die Empfängeradresse an (unser Smart Contract)
+- `from` gibt den Unterzeichner der Transaktion an, die `address`-Variable, die wir in unsere Funktion übergeben haben
+- `data` enthält den Aufruf der `update`-Methode unseres Hallo-Welt-Smart-Contracts, der unsere `message`-String-Variable als Eingabe erhält
+
+Dann machen wir einen await-Aufruf, `window.ethereum.request`, bei dem wir MetaMask bitten, die Transaktion zu signieren. Beachten Sie, in den Zeilen 11 und 12 geben wir unsere eth-Methode `eth_sendTransaction` an und übergeben unsere `transactionParameters`.
+
+An diesem Punkt öffnet sich MetaMask im Browser und fordert den Benutzer auf, die Transaktion zu signieren oder abzulehnen.
+
+- Wenn die Transaktion erfolgreich ist, gibt die Funktion ein JSON-Objekt zurück, bei dem der `status`-JSX-String den Benutzer auffordert, Etherscan für weitere Informationen zu seiner Transaktion zu besuchen.
+- Wenn die Transaktion fehlschlägt, gibt die Funktion ein JSON-Objekt zurück, bei dem der `status`-String die Fehlermeldung weitergibt.
+
+Insgesamt sollte unsere `updateMessage`-Funktion so aussehen:
+
+```javascript
+// interact.js
+
+export const updateMessage = async (address, message) => {
+ //Eingabefehlerbehandlung
+ if (!window.ethereum || address === null) {
+ return {
+ status:
+ "💡 Verbinden Sie Ihre MetaMask-Wallet, um die Nachricht auf der Blockchain zu aktualisieren.",
+ }
+ }
+
+ if (message.trim() === "") {
+ return {
+ status: "❌ Ihre Nachricht darf kein leerer String sein.",
+ }
+ }
+
+ //Transaktionsparameter einrichten
+ const transactionParameters = {
+ to: contractAddress, // Erforderlich, außer bei der Veröffentlichung von Verträgen.
+ from: address, // muss mit der aktiven Adresse des Benutzers übereinstimmen.
+ data: helloWorldContract.methods.update(message).encodeABI(),
+ }
+
+ // Transaktion signieren
+ try {
+ const txHash = await window.ethereum.request({
+ method: "eth_sendTransaction",
+ params: [transactionParameters],
+ })
+ return {
+ status: (
+
+ ✅{" "}
+
+ Sehen Sie sich den Status Ihrer Transaktion auf Etherscan an!
+
+
+ ℹ️ Sobald die Transaktion vom Netzwerk verifiziert ist, wird die Nachricht
+ automatisch aktualisiert.
+
+ ),
+ }
+ } catch (error) {
+ return {
+ status: "😥 " + error.message,
+ }
+ }
+}
+```
+
+Zu guter Letzt müssen wir unsere `updateMessage`-Funktion mit unserer `HelloWorld.js`-Komponente verbinden.
+
+#### Verbinden Sie `updateMessage` mit dem `HelloWorld.js`-Frontend {#connect-updatemessage-to-the-helloworld-js-frontend}
+
+Unsere `onUpdatePressed`-Funktion sollte einen await-Aufruf an die importierte `updateMessage`-Funktion machen und die `status`-Zustandsvariable ändern, um anzuzeigen, ob unsere Transaktion erfolgreich war oder fehlgeschlagen ist:
+
+```javascript
+// HelloWorld.js
+
+const onUpdatePressed = async () => {
+ const { status } = await updateMessage(walletAddress, newMessage)
+ setStatus(status)
+}
+```
+
+Es ist super sauber und einfach. Und raten Sie mal... IHRE DAPP IST FERTIG!!!
+
+Probieren Sie die **Aktualisieren**-Schaltfläche aus!
+
+### Erstellen Sie Ihre eigene benutzerdefinierte Dapp {#make-your-own-custom-dapp}
+
+Wooooo, Sie haben es bis zum Ende des Tutorials geschafft! Zusammenfassend haben Sie gelernt, wie Sie:
+
+- Eine MetaMask-Wallet mit Ihrem Dapp-Projekt verbinden
+- Daten aus Ihrem Smart Contract mit der [Alchemy Web3](https://docs.alchemy.com/alchemy/documentation/alchemy-web3) API lesen
+- Ethereum-Transaktionen mit MetaMask signieren
+
+Jetzt sind Sie voll ausgestattet, um die Fähigkeiten aus diesem Tutorial anzuwenden, um Ihr eigenes benutzerdefiniertes Dapp-Projekt zu erstellen! Wie immer, wenn Sie Fragen haben, zögern Sie nicht, uns im [Alchemy Discord](https://discord.gg/gWuC7zB) um Hilfe zu bitten. 🧙♂️
+
+Sobald Sie dieses Tutorial abgeschlossen haben, lassen Sie uns wissen, wie Ihre Erfahrung war oder ob Sie Feedback haben, indem Sie uns auf Twitter [@alchemyplatform](https://twitter.com/AlchemyPlatform) taggen!
diff --git a/public/content/translations/de/developers/tutorials/hello-world-smart-contract/index.md b/public/content/translations/de/developers/tutorials/hello-world-smart-contract/index.md
index 1519d397971..e021dee6f14 100644
--- a/public/content/translations/de/developers/tutorials/hello-world-smart-contract/index.md
+++ b/public/content/translations/de/developers/tutorials/hello-world-smart-contract/index.md
@@ -1,68 +1,71 @@
---
title: Hello World-Smart Contract für Einsteiger
-description: Einführungstutorial zum Schreiben und Installieren eines einfachen Smart Contracts auf Ethereum
+description: Einführungstutorial zum Schreiben und Bereitstellen eines einfachen Smart Contracts auf Ethereum.
author: "elanh"
tags:
- - "Solidity"
- - "Hardhat"
- - "Alchemy"
- - "Smart Contracts"
- - "Erste Schritte"
- - "Bereitstellung"
+ [
+ "solidity",
+ "Hardhat",
+ "Alchemy",
+ "intelligente Verträge",
+ "Bereitstellung"
+ ]
skill: beginner
lang: de
published: 2021-03-31
---
-Wenn Sie neu in der Blockchain-Entwicklung sind und nicht wissen, wo Sie anfangen sollen, oder wenn Sie einfach nur verstehen wollen, wie man Smart Contracts einsetzt und mit ihnen interagiert, ist dieser Leitfaden genau das Richtige für Sie. Wir werden die Erstellung und den Einsatz eines einfachen Smart Contracts auf dem Ropsten-Testnet unter Verwendung einer virtuellen Wallet erläutern ([MetaMask](https://metamask.io/)), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org/) and [Alchemy](https://alchemyapi.io/eth) (Machen Sie sich keine Sorgen, wenn Sie noch nicht verstehen, was das alles bedeutet. Wir werden es Ihnen erklären).
+Wenn Sie neu in der Blockchain-Entwicklung sind und nicht wissen, wo Sie anfangen sollen, oder wenn Sie einfach nur verstehen wollen, wie man Smart Contracts einsetzt und mit ihnen interagiert, ist dieser Leitfaden genau das Richtige für Sie. Wir werden die Erstellung und Bereitstellung eines einfachen Smart Contracts im Sepolia-Testnetz durchgehen. Dabei verwenden wir eine virtuelle Wallet ([MetaMask](https://metamask.io/)), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org/) und [Alchemy](https://www.alchemy.com/eth) (keine Sorge, falls Sie noch nicht verstehen, was das alles bedeutet – wir werden es erklären).
-Im zweiten Teil dieses Tutorials werden wir erläutern, wie wir mit unserem Smart Contract interagieren können, sobald er bereitgestellt wurde. Im dritten Teil erläutern wir dann, wie er auf Etherscan veröffentlicht wird.
+In [Teil 2](https://docs.alchemy.com/docs/interacting-with-a-smart-contract) dieses Tutorials gehen wir durch, wie wir mit unserem Smart Contract interagieren können, sobald er bereitgestellt wurde. In [Teil 3](https://www.alchemy.com/docs/submitting-your-smart-contract-to-etherscan) behandeln wir dann, wie man ihn auf Etherscan veröffentlicht.
-Wenn Sie zu irgendeinem Zeitpunkt Fragen haben, dann können Sie sich im [Alchemy Discord](https://discord.gg/gWuC7zB) melden.
+Wenn Sie zu irgendeinem Zeitpunkt Fragen haben, können Sie sich gerne im [Alchemy Discord](https://discord.gg/gWuC7zB) melden!
-## Schritt 1: Verbindung mit dem Ethereum-Netzwerk {#step-1}
+## Schritt 1: Mit dem Ethereum-Netzwerk verbinden {#step-1}
-Es gibt viele Möglichkeiten, Anfragen an die Ethereum-Chain zu stellen. Der Einfachheit halber verwenden wir ein kostenloses Konto bei Alchemy, eine Blockchain-Entwicklerplattform und API, die es uns ermöglicht, mit der Ethereum-Chain zu kommunizieren, ohne dass wir unseren eigenen Node betreiben müssen. Die Plattform verfügt auch über Entwickler-Tools für die Überwachung und Analyse, die wir in diesem Tutorial nutzen werden, um zu verstehen, was unter der Haube der Smart-Contract-Bereitstellung vor sich geht. Wenn Sie noch kein Alchemy-Konto haben, [können Sie sich hier kostenlos anmelden](https://dashboard.alchemyapi.io/signup).
+Es gibt viele Möglichkeiten, Anfragen an die Ethereum-Chain zu stellen. Der Einfachheit halber verwenden wir ein kostenloses Konto bei Alchemy, eine Blockchain-Entwicklerplattform und API, die es uns ermöglicht, mit der Ethereum-Chain zu kommunizieren, ohne dass wir unsere eigenen Nodes betreiben müssen. Die Plattform verfügt auch über Entwickler-Tools für die Überwachung und Analyse, die wir in diesem Tutorial nutzen werden, um zu verstehen, was bei der Bereitstellung unseres Smart Contracts „unter der Haube“ passiert. Wenn Sie noch kein Alchemy-Konto haben, [können Sie sich hier kostenlos registrieren](https://dashboard.alchemy.com/signup).
-## Schritt 2: Anwendung (und den API-Schlüssel) erstellen {#step-2}
+## Schritt 2: Ihre App (und den API-Schlüssel) erstellen {#step-2}
-Sobald Sie ein Alchemy-Konto erstellt haben, können Sie einen API-Schlüssel generieren. Erstellen Sie dafür eine App. Darüber können wir Anfragen an das Ropsten-Testnet stellen. Wenn Sie mit Testnets nicht vertraut sind, lesen Sie [diese Seite](/developers/docs/networks/).
+Sobald Sie ein Alchemy-Konto erstellt haben, können Sie einen API-Schlüssel generieren. Erstellen Sie dafür eine App. Dies ermöglicht es uns, Anfragen an das Sepolia-Testnet zu senden. Wenn Sie mit Testnets nicht vertraut sind, sehen Sie sich [diese Seite](/developers/docs/networks/) an.
-1. Klicken Sie in Ihrem Alchemy-Dashboard in der Navigationsleiste unter "Apps" auf "Create App" (App erstellen), um auf die Seite "Create App" (App erstellen) zu gelangen.
+1. Navigieren Sie in Ihrem Alchemy-Dashboard zur Seite „Create new app“, indem Sie in der Navigationsleiste „Select an app“ auswählen und dann auf „Create new app“ klicken.
-
+
-2. Nennen Sie Ihre App "Hello World", geben Sie eine kurze Beschreibung an, wählen Sie "Staging" für die Umgebung (die für die Buchhaltung Ihrer App verwendet wird) und wählen Sie "Ropsten" als Netzwerk.
+2. Geben Sie Ihrer App den Namen „Hello World“, fügen Sie eine kurze Beschreibung hinzu und wählen Sie einen Anwendungsfall aus, z. B. „Infra & Tooling“. Suchen Sie als Nächstes nach „Ethereum“ und wählen Sie das Netzwerk aus.
-
+
-3. Klicken Sie auf “Create app” (App erstellen) und schon sind Sie fertig. Die App sollte in der untenstehenden Tabelle erscheinen.
+3. Klicken Sie zum Fortfahren auf „Next“, dann auf „Create app“ und das war's schon! Ihre App sollte im Dropdown-Menü der Navigationsleiste erscheinen, und ein API-Schlüssel steht zum Kopieren bereit.
## Schritt 3: Ethereum-Konto (Adresse) erstellen {#step-3}
-Wir benötigen ein Ethereum-Konto, um Transaktionen zu senden und zu empfangen. In diesem Tutorial verwenden wir MetaMask, eine virtuelle Wallet im Browser, mit der Sie Ihre Ethereum-Kontoadresse verwalten können. Weitere Informationen zu [Transaktionen](/developers/docs/transactions/).
+Zum Versenden und Empfangen von Transaktionen benötigen Sie ein Ethereum-Konto. In diesem Tutorial verwenden wir MetaMask, eine virtuelle Wallet im Browser, mit der Sie Ihre Ethereum-Kontoadresse verwalten können. Mehr zu [Transaktionen](/developers/docs/transactions/).
-Sie können MetaMask [hier](https://metamask.io/download) kostenlos herunterladen und ein Konto erstellen. Wenn Sie ein Konto erstellen oder wenn Sie bereits ein Konto haben, stellen Sie sicher, dass Sie oben rechts zum "Ropsten-Testnet" wechseln (damit wir nicht mit echtem Geld arbeiten).
+Sie können MetaMask herunterladen und [hier](https://metamask.io/download) kostenlos ein Ethereum-Konto erstellen. Wenn Sie ein Konto erstellen oder bereits eines haben, wechseln Sie über das Netzwerk-Dropdown-Menü unbedingt zum Testnetz „Sepolia“ (damit wir nicht mit echtem Geld arbeiten).
-
+Wenn Sepolia nicht aufgeführt ist, gehen Sie in das Menü, dann auf „Advanced“ und scrollen Sie nach unten, um „Show test networks“ zu aktivieren. Wählen Sie im Netzwerkauswahlmenü die Registerkarte „Custom“, um eine Liste von Testnets zu finden, und wählen Sie „Sepolia“ aus.
+
+
## Schritt 4: Ether von einem Faucet hinzufügen {#step-4}
-Um unseren Smart Contract im Testnet einzusetzen, benötigen wir einige Fake-ETH. Um ETH zu erhalten, können Sie auf den [Ropsten Faucet](https://faucet.dimensions.network/) gehen und Ihre Ropsten-Kontoadresse eingeben. Klicken Sie dann auf "Ropsten-ETH senden". Aufgrund des Netzwerkverkehrs kann es einige Zeit dauern, bis Sie Ihre Fake-ETH erhalten. Sie sollten kurz darauf ETH auf Ihrem MetaMask-Konto sehen.
+Um unseren Smart Contract im Testnetz bereitzustellen, benötigen wir etwas „Fake-ETH“. Um Sepolia-ETH zu erhalten, können Sie zu den [Details des Sepolia-Netzwerks](/developers/docs/networks/#sepolia) gehen, um eine Liste verschiedener Faucets anzuzeigen. Wenn einer nicht funktioniert, versuchen Sie einen anderen, da sie manchmal leer sein können. Aufgrund des Netzwerkverkehrs kann es einige Zeit dauern, bis Sie Ihre Fake-ETH erhalten. Sie sollten kurz darauf ETH auf Ihrem MetaMask-Konto sehen!
-## Schritt 5: Guthaben prüfen {#step-5}
+## Schritt 5: Ihr Guthaben überprüfen {#step-5}
-Um unser Guthaben zu überprüfen, müssen wir eine [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance)-Anfrage mit dem [dem Composer-Tool von Alchemy](https://composer.alchemyapi.io?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D) stellen. Dadurch wird der Betrag der ETH in unsere Wallet zurückgegeben. Nachdem Sie die Adresse Ihres MetaMask-Kontos eingegeben und auf "Anfrage senden" geklickt haben, sollten Sie eine Antwort wie diese erhalten:
+Um zu überprüfen, ob unser Guthaben vorhanden ist, stellen wir eine [eth_getBalance](/developers/docs/apis/json-rpc/#eth_getbalance)-Anfrage mit dem [Composer-Tool von Alchemy](https://sandbox.alchemy.com/?network=ETH_SEPOLIA&method=eth_getBalance&body.id=1&body.jsonrpc=2.0&body.method=eth_getBalance&body.params%5B0%5D=&body.params%5B1%5D=latest). Das gibt den ETH-Betrag in unserem Wallet wieder. Nachdem Sie die Adresse Ihres MetaMask-Kontos eingegeben und auf “Send Request” (Anforderung senden) geklickt haben, sollten Sie eine Antwort ähnlich der Folgenden erhalten:
```json
{ "jsonrpc": "2.0", "id": 0, "result": "0x2B5E3AF16B1880000" }
```
-> **HINWEIS:** Dieses Ergebnis ist in Wei und nicht in ETH. Wei ist die kleinste Einheit von Ether. Die Umrechnung von Wei auf ETH ist: 1 ETH = 1018 Wei. Wenn wir also 0x2B5E3AF16B1880000 in eine Dezimalzahl konvertieren, bekommen wir 5\*10¹⁸. Das entspricht 5 ETH.
+> **HINWEIS:** Dieses Ergebnis ist in Wei und nicht in ETH angegeben. Wei ist die kleinste Einheit von Ether. Die Umrechnung von Wei in ETH lautet: 1 ETH = 1018 Wei. Wenn wir also 0x2B5E3AF16B1880000 in eine Dezimalzahl umwandeln, erhalten wir 5\*10¹⁸, was 5 ETH entspricht.
>
-> Puh! Unser Falschgeld ist da
-Führen Sie keinen Commit für .env aus. Stellen Sie sicher, dass Sie Ihre .env-Datei niemals an andere weitergeben, denn damit würden Sie Ihre geheimen Daten weitergeben. Wenn Sie die Versionskontrolle verwenden, fügen Sie Ihre Env-Datei zu einer Datei gitignore hinzu.
+Führen Sie keinen Commit für .env aus! Bitte stellen Sie sicher, dass Sie Ihre .env-Datei niemals an Dritte weitergeben oder offenlegen, da Sie dadurch Ihre Geheimnisse preisgeben. Wenn Sie eine Versionskontrolle verwenden, fügen Sie Ihre .env-Datei einer gitignore-Datei hinzu.
## Schritt 12: Ethers.js installieren {#step-12-install-ethersjs}
-Ethers.js ist eine Bibliothek, die es einfacher macht, mit Ethereum zu interagieren und Anfragen zu stellen. Dafür schließt sie [Standard-JSON-RPC-Methoden](/developers/docs/apis/json-rpc/) in benutzerfreundlichere Methoden ein.
+Ethers.js ist eine Bibliothek, die die Interaktion und das Stellen von Anfragen an Ethereum erleichtert, indem sie [standardmäßige JSON-RPC-Methoden](/developers/docs/apis/json-rpc/) in benutzerfreundlichere Methoden verpackt.
-Hardhat macht es sehr einfach [Plug-ins](https://hardhat.org/plugins/) für zusätzliche Tools und erweiterte Funktionen zu integrieren. Wir werden das [Ethers-Plug-in](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers) für die Bereitstellung von Verträgen nutzen ([Ethers.js](https://github.com/ethers-io/ethers.js/) bietet einige sehr saubere Methoden zur Bereitstellung von Verträgen).
+Hardhat macht es sehr einfach, [Plugins](https://hardhat.org/plugins/) für zusätzliche Tools und erweiterte Funktionalität zu integrieren. Wir werden das [Ethers-Plugin](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers) für die Vertragsbereitstellung nutzen ([Ethers.js](https://github.com/ethers-io/ethers.js/) verfügt über einige sehr saubere Methoden zur Vertragsbereitstellung).
Geben Sie Folgendes in Ihrem Projektverzeichnis ein:
@@ -253,13 +254,13 @@ Geben Sie Folgendes in Ihrem Projektverzeichnis ein:
npm install --save-dev @nomiclabs/hardhat-ethers "ethers@^5.0.0"
```
-Im nächsten Schritt benötigen wir auch Ether in unserer `hardhat.config.js`.
+Im nächsten Schritt werden wir auch Ethers in unserer `hardhat.config.js` benötigen.
## Schritt 13: hardhat.config.js aktualisieren {#step-13-update-hardhatconfigjs}
-Wir haben bisher mehrere Abhängigkeiten und Plug-ins hinzugefügt. Jetzt müssen wir `hardhat.config.js` aktualisieren, damit unser Projekt über alle diese Abhängigkeiten informiert wird.
+Wir haben bisher mehrere Abhängigkeiten und Plugins hinzugefügt. Jetzt müssen wir `hardhat.config.js` aktualisieren, damit unser Projekt alle kennt.
-Aktualisieren Sie Ihre `hardhat.config.js` so, dass sie wie folgt aussieht:
+Aktualisieren Sie Ihre `hardhat.config.js`, sodass sie wie folgt aussieht:
```
require('dotenv').config();
@@ -272,10 +273,10 @@ const { API_URL, PRIVATE_KEY } = process.env;
*/
module.exports = {
solidity: "0.7.3",
- defaultNetwork: "ropsten",
+ defaultNetwork: "sepolia",
networks: {
hardhat: {},
- ropsten: {
+ sepolia: {
url: API_URL,
accounts: [`0x${PRIVATE_KEY}`]
}
@@ -283,9 +284,9 @@ module.exports = {
}
```
-## Schritt 14: Vertragszusammenstellung {#step-14-compile-our-contracts}
+## Schritt 14: Unseren Vertrag kompilieren {#step-14-compile-our-contracts}
-Um sicherzugehen, dass so weit alles funktioniert, sollten wir unseren Vertrag erstellen. Die Aufgabe `compile` ist eine der integrierten Hardhat-Aufgaben.
+Um sicherzugehen, dass so weit alles funktioniert, sollten wir unseren Vertrag erstellen. Der `compile`-Task ist einer der integrierten Hardhat-Tasks.
Führen Sie folgenden Befehl in der Befehlszeile aus:
@@ -293,19 +294,19 @@ Führen Sie folgenden Befehl in der Befehlszeile aus:
npx hardhat compile
```
-Möglicherweise erhalten Sie eine Warnung über `SPDX license identifier not provided in source file` (SPDX-Lizenzkennung nicht in Quelldatei angegeben), aber darüber brauchen Sie sich keine Sorgen zu machen. Alles andere sieht hoffentlich gut aus. Falls nicht, können Sie jederzeit eine Nachricht im [Alchemy Discord](https://discord.gg/u72VCg3) hinterlassen.
+Möglicherweise erhalten Sie eine Warnung `SPDX license identifier not provided in source file`, aber darüber müssen Sie sich keine Sorgen machen – hoffentlich sieht alles andere gut aus! Wenn nicht, können Sie jederzeit eine Nachricht im [Alchemy-Discord](https://discord.gg/u72VCg3) schreiben.
-## Schritt 15: Bereitstellungsskript schreiben {#step-15-write-our-deploy-scripts}
+## Schritt 15: Unser Bereitstellungsskript schreiben {#step-15-write-our-deploy-scripts}
Nun, da unser Vertrag geschrieben und unsere Konfigurationsdatei einsatzbereit ist, ist es an der Zeit, das Skript zur Bereitstellung des Vertrags zu schreiben.
-Navigieren Sie zum Ordner `scripts/` und erstellen Sie eine neue Datei namens `deploy.js`. Fügen Sie folgende Inhalte hinzu:
+Navigieren Sie zum Ordner `scripts/` und erstellen Sie eine neue Datei namens `deploy.js`, und fügen Sie ihr den folgenden Inhalt hinzu:
```
async function main() {
const HelloWorld = await ethers.getContractFactory("HelloWorld");
- // Start deployment, returning a promise that resolves to a contract object
+ // Startet die Bereitstellung und gibt ein Promise zurück, das in ein Vertragsobjekt aufgelöst wird
const hello_world = await HelloWorld.deploy("Hello World!");
console.log("Contract deployed to address:", hello_world.address);}
@@ -317,26 +318,26 @@ main()
});
```
-Hardhat erklärt in seinem [Vertragstutorial](https://hardhat.org/tutorial/testing-contracts.html#writing-tests) sehr gut, was die einzelnen Codezeilen bewirken. Wir haben diese Erklärungen hier übernommen.
+Hardhat erklärt in seinem [Contracts-Tutorial](https://hardhat.org/tutorial/testing-contracts.html#writing-tests) hervorragend, was jede dieser Codezeilen bewirkt; wir haben die Erklärungen hier übernommen.
```
const HelloWorld = await ethers.getContractFactory("HelloWorld");
```
-Eine `ContractFactory` in ethers.js ist eine Abstraktion, die dazu dient, neue Smart Contracts einzusetzen. So ist `HelloWorld` eine Factory for Instances von unseren hello world-Vertrag. Wenn Sie das `hardhat-ethers`-Plug-in verwenden, werden die Instanzen `ContractFactory` und `Contract` standardmäßig mit dem ersten Unterzeichner verbunden.
+Eine `ContractFactory` in ethers.js ist eine Abstraktion, die zur Bereitstellung neuer Smart Contracts verwendet wird. `HelloWorld` ist hier also eine Factory für Instanzen unseres Hello-World-Vertrags. Bei Verwendung des `hardhat-ethers`-Plugins sind die Instanzen `ContractFactory` und `Contract` standardmäßig mit dem ersten Unterzeichner verbunden.
```
const hello_world = await HelloWorld.deploy();
```
-Der Aufruf eines `deploy()` im `ContractFactory` startet die Bereitstellung und gibt einen `Promise` zurück, was zum `Contract` führt. Das ist das Objekt, das eine Methode für jede unserer Smart-Contract-Funktionen enthält.
+Der Aufruf von `deploy()` auf einer `ContractFactory` startet die Bereitstellung und gibt ein `Promise` zurück, das zu einem `Contract` aufgelöst wird. Das ist das Objekt, das eine Methode für jede unserer Smart-Contract-Funktionen enthält.
-## Schritt 16: Vertragsbereitstellung {#step-16-deploy-our-contract}
+## Schritt 16: Unseren Vertrag bereitstellen {#step-16-deploy-our-contract}
-Nun sind wir endlich bereit, unseren Smart Contract bereitzustellen. Navigieren Sie zur Befehlszeile und führen Sie folgenden Befehl aus:
+Nun sind wir endlich bereit, unseren Smart Contract bereitzustellen. Navigieren Sie zur Befehlszeile und führen Sie Folgendes aus:
```
-npx hardhat run scripts/deploy.js --network ropsten
+npx hardhat run scripts/deploy.js --network sepolia
```
Sie sollten dann etwas sehen wie:
@@ -345,20 +346,22 @@ Sie sollten dann etwas sehen wie:
Contract deployed to address: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570
```
-Wenn wir den [Ropsten etherscan](https://ropsten.etherscan.io/) aufrufen und nach unserer Vertragsadresse suchen, sollten wir sehen können, dass sie erfolgreich bereitgestellt wurde. Das Ergebnis sollte etwa wie folgt aussehen:
+Wenn wir zu [Sepolia Etherscan](https://sepolia.etherscan.io/) gehen und nach unserer Vertragsadresse suchen, sollten wir sehen können, dass sie erfolgreich bereitgestellt wurde. Die Transaktion wird ungefähr so aussehen:
-Die `From`-Adresse sollte mit Ihrer MetaMask-Kontoadresse übereinstimmen und für die To-Adresse wird “Contract Creation” (Vertragserstellung) angezeigt. Doch wenn Sie die Transaktion aufrufen, erkennen Sie unsere Vertragsadresse im `To`-Feld:
+Die `From`-Adresse sollte mit Ihrer MetaMask-Kontoadresse übereinstimmen und die `To`-Adresse lautet „Contract Creation“. Wenn wir jedoch auf die Transaktion klicken, sehen wir unsere Vertragsadresse im `To`-Feld:
-Herzlichen Glückwunsch! Sie haben gerade einen Smart Contract in der Ethereum.Chain hinzugefügt 🎉.
+Glückwunsch! Sie haben gerade einen Smart Contract in der Ethereum-Chain bereitgestellt 🎉
-Um zu verstehen, was im Verborgenen vor sich geht, navigieren wir zur Explorer-Registerkarte in unserem [Alchemy-Dashboard](https://dashboard.alchemyapi.io/explorer). Wenn Sie mehrere Alchemy-Anwendungen haben, stellen Sie sicher, dass Sie nach Anwendungen filtern und "Hello World" auswählen. 
+Um zu verstehen, was unter der Haube vor sich geht, navigieren wir zum Explorer-Tab in unserem [Alchemy-Dashboard](https://dashboard.alchemyapi.io/explorer). Wenn Sie mehrere Alchemy-Apps haben, stellen Sie sicher, dass Sie nach App filtern und „Hello World“ auswählen.
+
-Hier sehen Sie eine Handvoll JSON-RPC-Befehle, die Hardhat/Ethers implementiert hat, als wir die `.deploy()`-Funktion aufgerufen haben. Zwei wichtige Befehle, die wir hier vorstellen möchten, sind [`eth_sendRawTransaction`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_sendrawtransaction), das ist die Aufforderung unseren Vertrag in die Ropsten-Chain zu schreiben, und [`eth_getTransactionByHash`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_gettransactionbyhash), was eine Anfrage ist, Informationen über unsere Transaktion anhand des Hashs zu lesen (ein typisches Muster bei Transaktionen). Wenn Sie mehr über das Senden von Transaktionen erfahren möchten, lesen Sie dieses Tutorial über das [Senden von Transaktionen mit Web3](/developers/tutorials/sending-transactions-using-web3-and-alchemy/)
+Hier sehen Sie eine Handvoll JSON-RPC-Aufrufe, die Hardhat/Ethers für uns „unter der Haube“ gemacht hat, als wir die `.deploy()`-Funktion aufgerufen haben. Zwei wichtige, die hier zu nennen sind, sind [`eth_sendRawTransaction`](https://www.alchemy.com/docs/node/abstract/abstract-api-endpoints/eth-send-raw-transaction), also die Anfrage, unseren Vertrag tatsächlich in die Sepolia-Chain zu schreiben, und [`eth_getTransactionByHash`](https://www.alchemy.com/docs/node/abstract/abstract-api-endpoints/eth-get-transaction-by-hash), eine Anfrage zum Lesen von Informationen über unsere Transaktion anhand des Hash (ein typisches Muster bei
+Transaktionen). Um mehr über das Senden von Transaktionen zu erfahren, sehen Sie sich dieses Tutorial zum [Senden von Transaktionen mit Web3](/developers/tutorials/sending-transactions-using-web3-and-alchemy/) an.
-Damit sind wir am Ende des ersten Teils von diesem Tutorial. Im zweiten Teil werden wir [mit unserem Smart Contract interagieren](https://docs.alchemyapi.io/alchemy/tutorials/hello-world-smart-contract#part-2-interact-with-your-smart-contract). Dafür aktualisieren wir unsere anfängliche Nachricht. Im dritten Teil werden wir [unseren Smart Contract auf Etherscan veröffentlichen](https://docs.alchemyapi.io/alchemy/tutorials/hello-world-smart-contract#optional-part-3-publish-your-smart-contract-to-etherscan), damit jeder weiß, wie man mit ihm interagiert.
+Das ist alles für Teil 1 dieses Tutorials. In Teil 2 werden wir tatsächlich [mit unserem Smart Contract interagieren](https://www.alchemy.com/docs/interacting-with-a-smart-contract), indem wir unsere ursprüngliche Nachricht aktualisieren, und in Teil 3 werden wir [unseren Smart Contract auf Etherscan veröffentlichen](https://www.alchemy.com/docs/submitting-your-smart-contract-to-etherscan), damit jeder weiß, wie man mit ihm interagiert.
-**Möchten Sie mehr über Alchemy erfahren? Besuchen Sie unsere [Website](https://alchemyapi.io/eth). Sie möchten kein Update verpassen? Dann abonnieren Sie [hier](https://www.alchemyapi.io/newsletter) unseren Newsletter. Folgen Sie uns auf [Twitter](https://twitter.com/alchemyplatform) und treten Sie unserer Community in [Discord](https://discord.com/invite/u72VCg3)** bei.
+**Möchten Sie mehr über Alchemy erfahren? Besuchen Sie unsere [Website](https://www.alchemy.com/eth). Möchten Sie nie ein Update verpassen? Abonnieren Sie unseren Newsletter [hier](https://www.alchemy.com/newsletter)! Treten Sie auch unserem [Discord](https://discord.gg/u72VCg3) bei.**.
diff --git a/public/content/translations/de/developers/tutorials/how-to-implement-an-erc721-market/index.md b/public/content/translations/de/developers/tutorials/how-to-implement-an-erc721-market/index.md
new file mode 100644
index 00000000000..4c06bc4de5c
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/how-to-implement-an-erc721-market/index.md
@@ -0,0 +1,145 @@
+---
+title: Wie man einen ERC-721 Markt implementiert
+description: Wie man tokenisierte Assets auf einer dezentralen Pinnwand zum Verkauf anbietet
+author: "Alberto Cuesta Cañada"
+tags: [ "Smart Contracts", "erc-721", "Solidity", "Token" ]
+skill: intermediate
+lang: de
+published: 2020-03-19
+source: Hackernoon
+sourceUrl: https://hackernoon.com/how-to-implement-an-erc721-market-1e1a32j9
+---
+
+In diesem Artikel werde ich dir zeigen, wie du Craigslist für die Ethereum Blockchain programmieren kannst.
+
+Vor Ebay, Craigslist und Gumtree waren Kleinanzeigen vor allem aus Kork oder Papier gemacht. Es gab Kleinanzeigen in Schulkorridoren, Zeitungen, an Straßenbeleuchtungen und Schaufenstern.
+
+All das änderte sich mit dem Internet. Die Anzahl der Personen, die eine bestimmte Kleinanzeige sehen konnten, multiplizierte sich um ein Vielfaches. Damit wurden die Märkte, die sie repräsentieren, viel effizienter und skalierter auf globale Größe. Ebay ist ein massives Geschäft, dessen Ursprünge auf diese physikalischen Kleinanzeiger zurückgehen.
+
+Angesichts der Blockchain werden sich diese Märkte erneut ändern, lass mich dir zeigen, wie.
+
+## Monetisierung {#monetization}
+
+Das Geschäftsmodell einer öffentlichen Blockchain-Kleinanzeige muss sich von dem von Ebay und Unternehmen unterscheiden.
+
+Zuerst gibt es [den Dezentralisierungsaspekt](/developers/docs/web2-vs-web3/). Bestehende Plattformen müssen ihre eigenen Server unterhalten. Eine dezentrale Plattform wird von ihren Benutzern verwaltet, so dass die Kosten für den Betrieb der Kernplattform für die Plattform-Besitzer auf Null sinken.
+
+Dann gibt es das Front-End, die Website oder Schnittstelle, den Zugriff auf die Plattform. Hier gibt es viele Möglichkeiten. Die Besitzer der Plattform können den Zugang einschränken und jeden zwingen, ihr Interface zu verwenden und eine Gebühr zu verlangen. Die Plattformeigentümer können sich auch dazu entscheiden, den Zugang zu öffnen (Alle Macht dem Volk!) und jeden Schnittstellen zur Plattform bauen zu lassen. Oder die Eigentümer könnten sich bei jedem Ansatz für die Mitte dieser Extreme entscheiden.
+
+_Geschäftsführer mit mehr Vision als ich, wissen, wie man dies monetarisieren kann. Ich sehe lediglich, dass dies anders ist als der Status quo und wahrscheinlich gewinnbringend._
+
+Darüber hinaus gibt es den Automatisierungs- und Zahlungsverkehrsblickwinkel. Manche Dinge können sehr [effektiv tokenisiert](https://hackernoon.com/tokenization-of-digital-assets-g0ffk3v8s?ref=hackernoon.com) und auf einer Kleinanzeigen-Plattform gehandelt werden. Tokenisierte Assets werden einfach in einer Blockchain übertragen. Hochkomplexe Zahlungsmethoden lassen sich in einer Blockchain einfach umsetzen.
+
+Ich rieche hier nur eine Geschäftsgelegenheit. Eine Kleinanzeige ohne laufende Kosten lässt sich problemlos umsetzen, wobei bei jeder Transaktion komplexe Zahlungswege enthalten sind. Ich bin mir sicher, dass jemand eine gute Idee haben wird, wofür er dies nutzen sollte.
+
+Ich bin nur glücklich, es zu entwickeln. Werfen wir einen Blick auf den Code.
+
+## Implementierung {#implementation}
+
+Vor einiger Zeit haben wir ein [Open-Source-Repository](https://github.com/HQ20/contracts?ref=hackernoon.com) mit Implementierungsbeispielen für Geschäftsszenarien und anderen Goodies gestartet, schau es dir bitte an.
+
+Der Code für dieses [Ethereum Classifieds Board](https://github.com/HQ20/contracts/tree/master/contracts/classifieds?ref=hackernoon.com) ist dort zu finden, bitte benutze ihn und tobe dich damit aus. Sei dir bewusst, dass der Code noch nicht geprüft wurde und du deine Sorgfaltspflicht erledigen musst, bevor du Geld in den Code steckst.
+
+Die Grundlagen des Boards sind nicht komplex. Alle Anzeigen im Board werden nur ein Struct mit ein paar Feldern sein:
+
+```solidity
+struct Trade {
+ address poster;
+ uint256 item;
+ uint256 price;
+ bytes32 status; // Open, Executed, Cancelled
+}
+```
+
+Es gibt jemanden, der die Anzeige veröffentlicht. Ein Artikel zum Verkauf. Ein Preis für diesen Artikel. Der Status des Handels, der geöffnet, ausgeführt oder aufgehoben werden kann.
+
+Alle diese Geschäfte werden in einer Kartierung aufbewahrt. Weil alles in Solidity ein Mapping zu sein scheint. Auch weil es bequem ist.
+
+```solidity
+mapping(uint256 => Trade) public trades;
+```
+
+Die Verwendung eines Mappings bedeutet lediglich, dass wir eine ID für jedes Inserat erstellen müssen, bevor wir es veröffentlichen und wir werden die ID einer Anzeige wissen müssen, bevor wir daran arbeiten können. Es gibt mehrere Möglichkeiten, dies entweder im Smart-Contract oder im Front-end zu lösen. Bitte frage dich, ob du Pointer benötigst.
+
+Als nächstes stellt sich die Frage, mit welcher Währung wir uns befassen und mit welcher Währung wir die Transaktion finanzieren.
+
+Für die Gegenstände fordern wir lediglich, dass sie die [ERC-721](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/IERC721.sol?ref=hackernoon.com)-Schnittstelle implementieren, was eigentlich nur eine Methode ist, um reale Gegenstände in einer Blockchain darzustellen, obwohl sie am besten [mit digitalen Vermögenswerten funktioniert](https://hackernoon.com/tokenization-of-digital-assets-g0ffk3v8s?ref=hackernoon.com). Wir werden unseren eigenen ERC721 Vertrag im Konstrukteur spezifizieren, was bedeutet, dass alle Vermögenswerte in unserem Kleinanzeigen-Board vorher tokenisiert werden müssen.
+
+Für die Zahlungen werden wir etwas Ähnliches machen. Die meisten Blockchain-Projekte definieren ihre eigene [ERC-20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol?ref=hackernoon.com) Kryptowährung. Einige andere ziehen es vor, eine Mainstream-Währung wie den DAI zu verwenden. In diesem Kleinanzeigen-Board musst du im Konstruktor über die Währung entscheiden. Einfach.
+
+```solidity
+constructor (
+ address _currencyTokenAddress, address _itemTokenAddress
+) public {
+ currencyToken = IERC20(_currencyTokenAddress);
+ itemToken = IERC721(_itemTokenAddress);
+ tradeCounter = 0;
+}
+```
+
+Wir haben es fast geschafft. Wir haben Werbung, Artikel für den Handel und eine Währung für Zahlungen. Eine Anzeige zu machen bedeutet, einen Gegenstand in das Treuhandkontol zu legen und zu zeigen, dass du ihn nicht zweimal gepostet hast, möglicherweise in einem anderen Board.
+
+Der folgende Code tut genau das. Legt den Gegenstand in escrow, erstellt die Werbung, macht ein wenig den Haushalt.
+
+```solidity
+function openTrade(uint256 _item, uint256 _price)
+ public
+{
+ itemToken.transferFrom(msg.sender, address(this), _item);
+ trades[tradeCounter] = Trade({
+ poster: msg.sender,
+ item: _item,
+ price: _price,
+ status: "Open"
+ });
+ tradeCounter += 1;
+ emit TradeStatusChange(tradeCounter - 1, "Open");
+}
+```
+
+Den Handel zu akzeptieren bedeutet, wähle eine Anzeige (Handel), zahle den Preis, erhalte den Artikel. Der untenstehende Code ruft einen Handel auf. Überprüft, ob er verfügbar ist. Bezahlt den Artikel. Erhält den Artikel. Aktualisiert die Anzeige.
+
+```solidity
+function executeTrade(uint256 _trade)
+ public
+{
+ Trade memory trade = trades[_trade];
+ require(trade.status == "Open", "Trade is not Open.");
+ currencyToken.transferFrom(msg.sender, trade.poster, trade.price);
+ itemToken.transferFrom(address(this), msg.sender, trade.item);
+ trades[_trade].status = "Executed";
+ emit TradeStatusChange(_trade, "Executed");
+}
+```
+
+Schließlich haben wir die Möglichkeit für Verkäufer, von einem Handel zurückzutreten, bevor ein Käufer ihn annimmt. In einigen Modellen würden Anzeigen statt dessen eine Zeitspanne lang live sein, bevor sie ablaufen. Deine Wahl, abhängig vom Design Ihres Marktes.
+
+Der Code ist sehr ähnlich wie bei der Handelsausführung nur dass keine Währung wechselt wird und der Artikel zurück zum Verkäufer geht.
+
+```solidity
+function cancelTrade(uint256 _trade)
+ public
+{
+ Trade memory trade = trades[_trade];
+ require(
+ msg.sender == trade.poster,
+ "Der Handel kann nur vom Ersteller storniert werden."
+ );
+ require(trade.status == "Open", "Der Handel ist nicht offen.");
+ itemToken.transferFrom(address(this), trade.poster, trade.item);
+ trades[_trade].status = "Cancelled";
+ emit TradeStatusChange(_trade, "Cancelled");
+}
+```
+
+Das wars. Du hast es bis zum Ende der Umsetzung geschafft. Es ist ziemlich überraschend, wie kompakt einige Geschäftskonzepte sind, wenn sie im Code ausgedrückt werden, und das ist einer dieser Fälle. Sieh dir den vollständigen Vertrag [in unserem Repo](https://github.com/HQ20/contracts/blob/master/contracts/classifieds/Classifieds.sol) an.
+
+## Fazit {#conclusion}
+
+Kleinanzeigen sind eine gemeinsame Marktkonfiguration, die massiv mit dem Internet skaliert wurde und zu einem sehr beliebten Geschäftsmodell mit ein paar monopolistischen Gewinnern geworden ist.
+
+Kleinanzeigen sind auch ein einfaches Werkzeug zum Nachahmen in einer Blockchain-Umgebung mit sehr spezifischen Merkmalen, die eine Herausforderung für die bestehenden Marktführer ermöglichen.
+
+In diesem Artikel habe ich den Versuch unternommen, die Geschäftswirklichkeit eines Kleinanzeigen-Business mit der technologischen Umsetzung zu verbinden. Dieses Wissen sollte dir helfen, eine Vision und einen Fahrplan für die Umsetzung zu erstellen, wenn du über die richtigen Fähigkeiten verfügst.
+
+Wie immer gilt: Wenn du etwas Lustiges bauen willst und einen Ratschlag gebrauchen könntest, [schreib mir einfach eine Nachricht](https://albertocuesta.es/)! Ich helfe immer gerne.
diff --git a/public/content/translations/de/developers/tutorials/how-to-mint-an-nft/index.md b/public/content/translations/de/developers/tutorials/how-to-mint-an-nft/index.md
index a9b9884c8d5..e411d70a1ee 100644
--- a/public/content/translations/de/developers/tutorials/how-to-mint-an-nft/index.md
+++ b/public/content/translations/de/developers/tutorials/how-to-mint-an-nft/index.md
@@ -1,39 +1,42 @@
---
-title: So prägen Sie einen NFT (Teil 2/3 der NFT-Tutorialreihe)
-description: In diesem Tutorial wird beschrieben, wie Sie ein NFT auf der Ethereum-Blockchain mit unserem Smart Contract und Web3 prägen können
+title: Wie man einen NFT prägt (Teil 2/3 der NFT-Tutorial-Reihe)
+description: In diesem Tutorial wird beschrieben, wie Sie einen NFT auf der Ethereum-Blockchain mit unserem Smart Contract und Web3 prägen können.
author: "Sumi Mudgil"
tags:
- - "NFTs"
- - "ERC-721"
- - "Alchemy"
- - "Solidity"
- - "Smart Contracts"
+ [
+ "ERC-721",
+ "Alchemy",
+ "solidity",
+ "intelligente Verträge"
+ ]
skill: beginner
lang: de
published: 2021-04-22
---
-[Beeple](https://www.nytimes.com/2021/03/11/arts/design/nft-auction-christies-beeple.html): 69 Millionen USD [3LAU](https://www.forbes.com/sites/abrambrown/2021/03/03/3lau-nft-nonfungible-tokens-justin-blau/?sh=5f72ef64643b): 11 Millionen USD [Grimes](https://www.theguardian.com/music/2021/mar/02/grimes-sells-digital-art-collection-non-fungible-tokens): 6 Millionen USD
+[Beeple](https://www.nytimes.com/2021/03/11/arts/design/nft-auction-christies-beeple.html): 69 Millionen Dollar
+[3LAU](https://www.forbes.com/sites/abrambrown/2021/03/03/3lau-nft-nonfungible-tokens-justin-blau/?sh=5f72ef64643b): 11 Millionen Dollar
+[Grimes](https://www.theguardian.com/music/2021/mar/02/grimes-sells-digital-art-collection-non-fungible-tokens): 6 Millionen Dollar
Sie alle haben ihre NFTs mit der leistungsstarken API von Alchemy geprägt. In diesem Tutorial zeigen wir Ihnen, wie das in \<10 Minuten geht.
-"NFTs prägen" – ist die Veröffentlichung einer einzigartigen Instanz Ihres ERC-721-Tokens auf der Blockchain. Mit unserem Smart Contract aus [Teil 1 dieser NFT-Tutorialserie](/developers/tutorials/how-to-write-and-deploy-an-nft/) möchten wir unsere Web3-Fähigkeiten unter Beweis stellen und einen NFT prägen. Am Ende dieses Tutorials sind Sie selbst in der Lage, so viele NFTs zu prägen, wie Ihr Herz (und Ihr Wallet) begehrt.
+Das „Prägen eines NFT“ ist der Akt der Veröffentlichung einer einzigartigen Instanz Ihres ERC-721-Tokens auf der Blockchain. Nutzen wir unseren Smart Contract aus [Teil 1 dieser NFT-Tutorial-Reihe](/developers/tutorials/how-to-write-and-deploy-an-nft/), um unsere Web3-Fähigkeiten unter Beweis zu stellen und einen NFT zu prägen. Am Ende dieses Tutorials werden Sie in der Lage sein, so viele NFTs zu prägen, wie Ihr Herz (und Ihr Wallet) begehrt!
-Los gehts!
+Legen wir los!
## Schritt 1: Web3 installieren {#install-web3}
-Wenn Sie das erste Tutorial zur Erstellung Ihres NFT-Smart Contracts verfolgt haben, haben Sie bereits Erfahrung mit Ethers.js gesammelt. Web3 ist ähnlich wie Ethers eine Bibliothek, die das Erstellen von Anfragen an die Ethereum-Blockchain erleichtert. In diesem Tutorial verwenden wir [Alchemy Web3](https://docs.alchemyapi.io/alchemy/documentation/alchemy-web3), eine erweiterte Web3-Bibliothek, die automatische Wiederholungen und ausgereifte WebSocket-Unterstützung bietet.
+Wenn Sie dem ersten Tutorial zur Erstellung Ihres NFT-Smart-Contracts gefolgt sind, haben Sie bereits Erfahrung mit der Verwendung von Ethers.js. Web3 ist ähnlich wie Ethers eine Bibliothek, die das Erstellen von Anfragen an die Ethereum-Blockchain erleichtert. In diesem Tutorial verwenden wir [Alchemy Web3](https://docs.alchemyapi.io/alchemy/documentation/alchemy-web3), eine erweiterte Web3-Bibliothek, die automatische Wiederholungsversuche und robuste WebSocket-Unterstützung bietet.
-Führen Sie folgenden Befehl im Startverzeichnis Ihres Projekts aus:
+Führen Sie im Stammverzeichnis Ihres Projekts Folgendes aus:
```
npm install @alch/alchemy-web3
```
-## Schritt 2: `mint-nft.js`-Datei erstellen {#create-mintnftjs}
+## Schritt 2: Eine `mint-nft.js`-Datei erstellen {#create-mintnftjs}
-Erstellen Sie die Datei `mint-nft.js` in Ihrem Skriptverzeichnis und fügen Sie die folgenden Codezeilen hinzu:
+Erstellen Sie in Ihrem Skriptverzeichnis eine `mint-nft.js`-Datei und fügen Sie die folgenden Codezeilen hinzu:
```js
require("dotenv").config()
@@ -42,123 +45,123 @@ const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
const web3 = createAlchemyWeb3(API_URL)
```
-## Schritt 3: Vertrags-ABI öffnen {#contract-abi}
+## Schritt 3: Die Vertrags-ABI abrufen {#contract-abi}
-Unsere Vertrags-ABI (Application Binary Interface) ist die Schnittstelle, über die die Interaktion mit unserem Smart Contract erfolgt. [Hier](https://docs.alchemyapi.io/alchemy/guides/eth_getlogs#what-are-ab-is) erfahren Sie mehr über Vertrags-ABIs. Hardhat generiert automatisch eine ABI für uns und speichert sie in der Datei `MyNFT.json`. Um das zu nutzen, müssen wir den Inhalt auslesen. Dafür fügen wir die folgenden Codezeilen in unsere `mint-nft.js`-Datei ein:
+Die ABI unseres Vertrags (Application Binary Interface) ist die Schnittstelle für die Interaktion mit unserem Smart-Contract. Mehr über Vertrags-ABIs erfahren Sie [hier](https://docs.alchemyapi.io/alchemy/guides/eth_getlogs#what-are-ab-is). Hardhat generiert automatisch eine ABI für uns und speichert sie in der Datei `MyNFT.json`. Um dies zu verwenden, müssen wir den Inhalt parsen, indem wir die folgenden Codezeilen zu unserer `mint-nft.js`-Datei hinzufügen:
```js
const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
```
-Wenn Sie die ABI anzeigen möchten, können Sie sie auf Ihrer Konsole anzeigen:
+Wenn Sie die ABI sehen möchten, können Sie sie auf Ihrer Konsole ausgeben:
```js
console.log(JSON.stringify(contract.abi))
```
-Um `mint-nft.js` auszuführen und die ABI auf der Konsole anzuzeigen, navigieren Sie zu Ihrem Terminal und führen folgenden befehl aus:
+Um `mint-nft.js` auszuführen und Ihre ABI auf der Konsole ausgeben zu sehen, navigieren Sie zu Ihrem Terminal und führen Sie Folgendes aus:
```js
node scripts/mint-nft.js
```
-## Schritt 4: Metadaten für den NFT mit IPFS konfigurieren {#config-meta}
+## Schritt 4: Metadaten für Ihren NFT mit IPFS konfigurieren {#config-meta}
-Wenn Sie sich an den ersten Teil unseres Tutorials erinnern, nimmt unsere `mintNFT`-Smart-Contract-Funktion einen tokenURI-Parameter entgegen, der in ein JSON-Dokument aufgelöst werden sollte, das die Metadaten des NFT beschreibt. Das ist es, was einen NFT wirklich zum Leben erweckt und ermöglicht, konfigurierbare Eigenschaften wie einen Namen, eine Beschreibung, ein Bild und andere Attribute zu haben.
+Wenn Sie sich an unser Tutorial in Teil 1 erinnern, nimmt unsere `mintNFT`-Smart-Contract-Funktion einen tokenURI-Parameter entgegen, der zu einem JSON-Dokument aufgelöst werden sollte, das die Metadaten des NFT beschreibt – was den NFT erst richtig zum Leben erweckt und ihm konfigurierbare Eigenschaften wie Name, Beschreibung, Bild und andere Attribute verleiht.
-> _Interplanetary File System (IPFS) ist ein dezentralisiertes Protokoll und Peer-to-Peer-Netzwerk, um Informationen in verteilten Dateisystemen zu speichern und zu teilen._
+> _Interplanetary File System (IPFS) ist ein dezentrales Protokoll und ein Peer-to-Peer-Netzwerk zum Speichern und Teilen von Daten in einem verteilten Dateisystem._
-Wir nutzen Pinata, eine praktische IPFS-API und ein Toolkit zum Speichern unserer NFT-Assets und Metadaten, um sicherzustellen, dass unser NFT wirklich dezentralisiert ist. Falls Sie noch kein Pinata-Konto haben, können Sie ein kostenloses Konto [hier](https://app.pinata.cloud) erstellen. Zur Vervollständigung müssen Sie anschließend noch Ihre E-Mail-Adresse verifizieren.
+Wir werden Pinata, eine praktische IPFS-API und ein Toolkit, verwenden, um unser NFT-Asset und unsere Metadaten zu speichern und sicherzustellen, dass unser NFT wirklich dezentral ist. Wenn Sie kein Pinata-Konto haben, registrieren Sie sich [hier](https://app.pinata.cloud) für ein kostenloses Konto und führen Sie die Schritte zur Verifizierung Ihrer E-Mail-Adresse aus.
Sobald Sie ein Konto erstellt haben:
-- Navigieren Sie zur Seite "Files" (Dateien) und klicken Sie auf die blaue Schaltfläche "Upload" (Hochladen) oben links auf der Seite.
+- Navigieren Sie zur Seite „Dateien“ und klicken Sie oben links auf die blaue Schaltfläche „Hochladen“.
-- Laden Sie ein Bild bei Pinata hoch — diese Bild-Datei wird für Ihren NFT benötigt. Sie können die Datei beliebig benennen.
+- Laden Sie ein Bild auf Pinata hoch – dies wird das Bild-Asset für Ihren NFT sein. Sie können das Asset benennen, wie Sie möchten.
-- Nach dem Hochladen sehen Sie die Dateiinformationen in der Tabelle auf der Seite "Files" (Dateien). Zudem sehen Sie auch die Spalte "CID". Sie können die CID kopieren, indem Sie auf die Kopierschaltfläche direkt daneben klicken. Sie können ihren Upload einsehen unter: `https://gateway.pinata.cloud/ipfs/`. Das Bild, das wir auf IPFS verwendet haben, finden Sie zum Beispiel [hier](https://gateway.pinata.cloud/ipfs/QmarPqdEuzh5RsWpyH2hZ3qSXBCzC5RyK3ZHnFkAsk7u2f).
+- Nach dem Hochladen sehen Sie die Datei-Informationen in der Tabelle auf der Seite „Dateien“. Sie werden auch eine CID-Spalte sehen. Sie können die CID kopieren, indem Sie auf die Schaltfläche zum Kopieren daneben klicken. Sie können Ihren Upload unter `https://gateway.pinata.cloud/ipfs/` ansehen. Das von uns verwendete Bild finden Sie zum Beispiel auf IPFS [hier](https://gateway.pinata.cloud/ipfs/QmZdd5KYdCFApWn7eTZJ1qgJu18urJrP9Yh1TZcZrZxxB5).
-Für visuell Lernende sind die oben genannten Schritte hier zusammengefasst:
+Für die eher visuell Lernenden sind die obigen Schritte hier zusammengefasst:
-
+
-Jetzt laden wir ein weiteres Dokument in Pinata hoch. Doch bevor wir das machen, müssen wir es erst erstellen.
+Jetzt wollen wir noch ein weiteres Dokument auf Pinata hochladen. Aber bevor wir das tun, müssen wir es erstellen!
-Erstellen Sie in Ihrem Stammverzeichnis eine neue Datei namens `nft-metadata.json` und fügen Sie den folgenden json-Code hinzu:
+Erstellen Sie in Ihrem Stammverzeichnis eine neue Datei mit dem Namen `nft-metadata.json` und fügen Sie den folgenden JSON-Code hinzu:
```json
{
"attributes": [
{
- "trait_type": "Breed",
+ "trait_type": "Rasse",
"value": "Maltipoo"
},
{
- "trait_type": "Eye color",
- "value": "Mocha"
+ "trait_type": "Augenfarbe",
+ "value": "Mokka"
}
],
- "description": "The world's most adorable and sensitive pup.",
+ "description": "Der bezauberndste und sensibelste Welpe der Welt.",
"image": "ipfs://QmWmvTJmJU3pozR9ZHFmQC2DNDwi2XJtf3QGyYiiagFSWb",
"name": "Ramses"
}
```
-Sie können die Daten in der json-Datei gerne ändern. Sie können den Attributabschnitt entfernen oder hinzufügen. Vergewissern Sie sich vor allem, dass das Bildfeld auf den Speicherort Ihres IPFS-Bildes verweist – andernfalls wird Ihr NFT ein Foto eines (sehr niedlichen!) Hundes enthalten.
+Sie können die Daten in der JSON-Datei beliebig ändern. Sie können den Abschnitt mit den Attributen entfernen oder erweitern. Am wichtigsten ist, dass das Bildfeld auf den Speicherort Ihres IPFS-Bildes verweist – andernfalls enthält Ihr NFT ein Foto von einem (sehr süßen!) Hund.
-Wenn Sie mit der Bearbeitung der JSON-Datei fertig sind, speichern Sie sie und laden Sie sie auf Pinata hoch. Führen Sie dafür die gleichen Schritte wie beim Hochladen des Bildes aus.
+Wenn Sie mit der Bearbeitung der JSON-Datei fertig sind, speichern Sie sie und laden Sie sie auf Pinata hoch. Befolgen Sie dabei die gleichen Schritte wie beim Hochladen des Bildes.
-
+
-## Schritt 5: Vertragsinstanz erstellen {#instance-contract}
+## Schritt 5: Eine Instanz Ihres Vertrags erstellen {#instance-contract}
-Um nun mit unserem Vertrag zu interagieren, müssen wir eine Instanz davon in unserem Code erstellen. Dazu benötigen wir unsere Vertragsadresse, die wir über die Bereitstellung oder [Etherscan](https://ropsten.etherscan.io/) erhalten können. Dafür fragen wir die Adresse ab, die Sie für die Bereitstellung des Vertrags verwendet haben.
+Um mit unserem Vertrag zu interagieren, müssen wir nun eine Instanz davon in unserem Code erstellen. Dazu benötigen wir unsere Vertragsadresse, die wir bei der Bereitstellung oder von [Blockscout](https://eth-sepolia.blockscout.com/) erhalten können, indem wir die Adresse nachschlagen, die Sie zur Bereitstellung des Vertrags verwendet haben.
-
+
-Im obigen Beispiel lautet unsere Vertragsadresse 0x81c587EB0fE773404c42c1d2666b5f557C470eED.
+Im obigen Beispiel lautet unsere Vertragsadresse 0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778.
-Als Nächstes werden wir die Web3-[Vertragsmethode](https://docs.web3js.org/api/web3-eth-contract/class/Contract) verwenden, um unseren Vertrag unter Verwendung der ABI und der Adresse zu erstellen. Fügen Sie in der Datei `mint-nft.js` Folgendes hinzu:
+Als Nächstes verwenden wir die Web3-[Vertragsmethode](https://docs.web3js.org/api/web3-eth-contract/class/Contract), um unseren Vertrag mithilfe der ABI und der Adresse zu erstellen. Fügen Sie in Ihrer `mint-nft.js`-Datei Folgendes hinzu:
```js
-const contractAddress = "0x81c587EB0fE773404c42c1d2666b5f557C470eED"
+const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
```
-## Schritt 6: `.env`-Datei aktualisieren {#update-env}
+## Schritt 6: Die `.env`-Datei aktualisieren {#update-env}
-Um nun Transaktionen zu erstellen und an die Ethereum-Chain zu senden, verwenden wir Ihre öffentliche Ethereum-Kontoadresse, um die Konto-Nonce zu erhalten (wird unten erklärt).
+Um Transaktionen zu erstellen und an die Ethereum-Kette zu senden, verwenden wir nun Ihre öffentliche Ethereum-Kontoadresse, um die Konto-Nonce zu erhalten (Erklärung folgt unten).
-Fügen Sie Ihren öffentlichen Schlüssel zu Ihrer `.env-`Datei hinzu. Wenn Sie den ersten Teil des Tutorials abgeschlossen haben, sollte die `.env`-Datei nun wie folgt aussehen:
+Fügen Sie Ihren öffentlichen Schlüssel zu Ihrer `.env`-Datei hinzu – wenn Sie Teil 1 des Tutorials abgeschlossen haben, sollte unsere `.env`-Datei jetzt so aussehen:
```js
-API_URL = "https://eth-ropsten.alchemyapi.io/v2/your-api-key"
+API_URL = "https://eth-sepolia.g.alchemy.com/v2/your-api-key"
PRIVATE_KEY = "your-private-account-address"
PUBLIC_KEY = "your-public-account-address"
```
-## Schritt 7: Transaktion erstellen {#create-txn}
+## Schritt 7: Ihre Transaktion erstellen {#create-txn}
-Als Erstes definieren wir eine Funktion mit dem Namen `mintNFT(tokenData)` und erstellen dann wie folgt unsere Transaktion:
+Definieren wir zunächst eine Funktion namens `mintNFT(tokenData)` und erstellen wir unsere Transaktion, indem wir Folgendes tun:
-1. Nehmen Sie den _PRIVATE_KEY_ und _PUBLIC_KEY_ aus der `.env`-Datei.
+1. Holen Sie sich Ihren _PRIVATE_KEY_ und _PUBLIC_KEY_ aus der `.env`-Datei.
-1. Als Nächstes müssen wir die Konto-Nonce in Erfahrung bringen. Die Nonce-Spezifikation wird verwendet, um die Anzahl der von Ihrer Adresse aus gesendeten Transaktionen zu verfolgen. Das ist aus Sicherheitsgründen und zur Verhinderung von [Replay-Angriffen](https://docs.alchemyapi.io/resources/blockchain-glossary#account-nonce) erforderlich. Um die Anzahl der von Ihrer Adresse aus gesendeten Transaktionen in Erfahrung zu bringen, nutzen wir [getTransactionCount](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc#eth_gettransactioncount).
+2. Als Nächstes müssen wir die Konto-Nonce ermitteln. Die Nonce-Spezifikation wird verwendet, um die Anzahl der von Ihrer Adresse gesendeten Transaktionen zu verfolgen – was wir aus Sicherheitsgründen und zur Verhinderung von [Replay-Angriffen](https://docs.alchemyapi.io/resources/blockchain-glossary#account-nonce) benötigen. Um die Anzahl der von Ihrer Adresse gesendeten Transaktionen zu erhalten, verwenden wir [getTransactionCount](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc#eth_gettransactioncount).
-1. Abschließend richten wir eine Transaktion mit der folgenden Information ein:
+3. Schließlich richten wir unsere Transaktion mit den folgenden Informationen ein:
-- `'from': PUBLIC_KEY` – Der Ursprung der Transaktion ist unsere öffentliche Adresse
+- `'from': PUBLIC_KEY` — Der Ursprung unserer Transaktion ist unsere öffentliche Adresse
-- `'to': contractAddress` – Der Vertrag, mit dem wir interagieren und dem wir die Transaktion senden möchten
+- `'to': contractAddress` — Der Vertrag, mit dem wir interagieren und an den wir die Transaktion senden wollen
-- `'nonce': nonce` – Die Konto-Nonce mit der Anzahl der Transaktionen, die von unserer Adresse gesendet wurden
+- `'nonce': nonce` — Die Konto-Nonce mit der Anzahl der von unserer Adresse gesendeten Transaktionen
-- `'gas': estimatedGas` – Die geschätzten Ressourcen, die zum Abschließen der Transaktion erforderlich sind
+- `'gas': estimatedGas` — Das geschätzte Gas, das für den Abschluss der Transaktion benötigt wird
-- `'data': nftContract.methods.mintNFT(PUBLIC_KEY, md).encodeABI()` – Die Berechnung, die wir in dieser Transaktion durchführen wollen, in diesem Fall das Prägen eines NFT.
+- `'data': nftContract.methods.mintNFT(PUBLIC_KEY, md).encodeABI()` — Die Berechnung, die wir in dieser Transaktion durchführen wollen — in diesem Fall das Prägen eines NFT
-Unser mint-nft.js Datei sollte dann so aussehen:
+Ihre `mint-nft.js`-Datei sollte jetzt so aussehen:
```js
require('dotenv').config();
@@ -170,13 +173,13 @@ Unser mint-nft.js Datei sollte dann so aussehen:
const web3 = createAlchemyWeb3(API_URL);
const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json");
- const contractAddress = "0x81c587EB0fE773404c42c1d2666b5f557C470eED";
+ const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778";
const nftContract = new web3.eth.Contract(contract.abi, contractAddress);
async function mintNFT(tokenURI) {
- const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, 'latest'); //get latest nonce
+ const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, 'latest'); //letzte Nonce holen
- //the transaction
+ //die Transaktion
const tx = {
'from': PUBLIC_KEY,
'to': contractAddress,
@@ -187,11 +190,11 @@ Unser mint-nft.js Datei sollte dann so aussehen:
}
```
-## Schritt 8: Transaktion signieren {#sign-txn}
+## Schritt 8: Die Transaktion signieren {#sign-txn}
-Jetzt, da wir unsere Transaktion erstellt haben, müssen wir sie signieren, um sie abzusenden. Dafür verwenden wir den privaten Schlüssel.
+Nachdem wir unsere Transaktion erstellt haben, müssen wir sie signieren, um sie zu versenden. Hier werden wir unseren privaten Schlüssel verwenden.
-`web3.eth.sendSignedTransaction` liefert uns den Transaktions-Hash, mit dem wir sicherstellen können, dass die Transaktion verarbeitet und nicht vom Netzwerk gelöscht wurde. Sie werden feststellen, dass wir im Abschnitt zur Transaktionssignierung eine Fehlerprüfung hinzugefügt haben, damit wir wissen, ob unsere Transaktion erfolgreich durchgeführt wurde.
+`web3.eth.sendSignedTransaction` gibt uns den Transaktions-Hash, mit dem wir sicherstellen können, dass unsere Transaktion gemined und nicht vom Netzwerk verworfen wurde. Sie werden feststellen, dass wir im Abschnitt zur Signierung der Transaktion eine Fehlerprüfung hinzugefügt haben, damit wir wissen, ob unsere Transaktion erfolgreich war.
```js
require("dotenv").config()
@@ -203,13 +206,13 @@ const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
const web3 = createAlchemyWeb3(API_URL)
const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
-const contractAddress = "0x81c587EB0fE773404c42c1d2666b5f557C470eED"
+const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
async function mintNFT(tokenURI) {
- const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //get latest nonce
+ const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //letzte Nonce holen
- //the transaction
+ //die Transaktion
const tx = {
from: PUBLIC_KEY,
to: contractAddress,
@@ -226,13 +229,13 @@ async function mintNFT(tokenURI) {
function (err, hash) {
if (!err) {
console.log(
- "The hash of your transaction is: ",
+ "Der Hash Ihrer Transaktion ist: ",
hash,
- "\nCheck Alchemy's Mempool to view the status of your transaction!"
+ "\nÜberprüfen Sie den Mempool von Alchemy, um den Status Ihrer Transaktion anzuzeigen!"
)
} else {
console.log(
- "Something went wrong when submitting your transaction:",
+ "Beim Senden Ihrer Transaktion ist ein Fehler aufgetreten:",
err
)
}
@@ -240,24 +243,24 @@ async function mintNFT(tokenURI) {
)
})
.catch((err) => {
- console.log(" Promise failed:", err)
+ console.log(" Promise fehlgeschlagen:", err)
})
}
```
-## Schritt 9: `mintNFT` aufrufen und Node-`mint-nft.js` ausführen {#call-mintnft-fn}
+## Schritt 9: `mintNFT` aufrufen und `node mint-nft.js` ausführen {#call-mintnft-fn}
-Erinnern Sie sich noch an die Datei `metadata.json`, die Sie in Pinata hochgeladen haben? Holen Sie sich den Hashcode von Pinata und übermitteln Sie die Parameter an die `mintNFT`-Funktion: `https://gateway.pinata.cloud/ipfs/`
+Erinnern Sie sich an die `metadata.json`, die Sie auf Pinata hochgeladen haben? Holen Sie sich den Hashcode von Pinata und übergeben Sie Folgendes als Parameter an die Funktion `mintNFT`: `https://gateway.pinata.cloud/ipfs/`
So erhalten Sie den Hashcode:
-_So bekommen Sie Ihren NFT-Metadata-Hashcode auf Pinata_
+_So erhalten Sie den Hashcode Ihrer NFT-Metadaten auf Pinata_
-> Überprüfen Sie den Hashcode, den Sie zu Ihrer **metadata.json** verlinkt haben, indem Sie `https://gateway.pinata.cloud/ipfs/` in einem separaten Fenster öffnen. Die Seite sollte ähnlich wie der untenstehende Screenshot aussehen:
+> Überprüfen Sie, ob der von Ihnen kopierte Hashcode auf Ihre **metadata.json** verweist, indem Sie `https://gateway.pinata.cloud/ipfs/` in einem separaten Fenster laden. Die Seite sollte ähnlich wie im folgenden Screenshot aussehen:
-_Ihre Seite sollte die json-Metadaten anzeigen_
+_Ihre Seite sollte die JSON-Metadaten anzeigen_
-Alles in allem sollte Ihr Code etwa wie folgt aussehen:
+Insgesamt sollte Ihr Code etwa so aussehen:
```js
require("dotenv").config()
@@ -269,13 +272,13 @@ const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
const web3 = createAlchemyWeb3(API_URL)
const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
-const contractAddress = "0x81c587EB0fE773404c42c1d2666b5f557C470eED"
+const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
async function mintNFT(tokenURI) {
- const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //get latest nonce
+ const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //letzte Nonce holen
- //the transaction
+ //die Transaktion
const tx = {
from: PUBLIC_KEY,
to: contractAddress,
@@ -292,13 +295,13 @@ async function mintNFT(tokenURI) {
function (err, hash) {
if (!err) {
console.log(
- "The hash of your transaction is: ",
+ "Der Hash Ihrer Transaktion ist: ",
hash,
- "\nCheck Alchemy's Mempool to view the status of your transaction!"
+ "\nÜberprüfen Sie den Mempool von Alchemy, um den Status Ihrer Transaktion anzuzeigen!"
)
} else {
console.log(
- "Something went wrong when submitting your transaction:",
+ "Beim Senden Ihrer Transaktion ist ein Fehler aufgetreten:",
err
)
}
@@ -306,25 +309,27 @@ async function mintNFT(tokenURI) {
)
})
.catch((err) => {
- console.log("Promise failed:", err)
+ console.log("Promise fehlgeschlagen:", err)
})
}
mintNFT("ipfs://QmYueiuRNmL4MiA2GwtVMm6ZagknXnSpQnB3z2gWbz36hP")
```
-Führen Sie nun `node scripts/mint-nft.js` aus, um Ihren NFT bereitzustellen. Nach ein paar Sekunden sollten Sie eine Antwort wie diese in Ihrem Terminal sehen:
+Führen Sie nun `node scripts/mint-nft.js` aus, um Ihren NFT zu prägen. Nach einigen Sekunden sollten Sie eine Antwort wie diese in Ihrem Terminal sehen:
- The hash of your transaction is: 0x10e5062309de0cd0be7edc92e8dbab191aa2791111c44274483fa766039e0e00
+ ```
+ Der Hash Ihrer Transaktion lautet: 0x301791fdf492001fcd9d5e5b12f3aa1bbbea9a88ed24993a8ab2cdae2d06e1e8
+
+ Überprüfen Sie den Mempool von Alchemy, um den Status Ihrer Transaktion anzuzeigen!
+ ```
- Check Alchemy's Mempool to view the status of your transaction!
+Besuchen Sie als Nächstes Ihren [Alchemy-Mempool](https://dashboard.alchemyapi.io/mempool), um den Status Ihrer Transaktion zu sehen (ob sie ausstehend ist, gemined wurde oder vom Netzwerk verworfen wurde). Wenn Ihre Transaktion verworfen wurde, ist es auch hilfreich, [Blockscout](https://eth-sepolia.blockscout.com/) zu überprüfen und nach Ihrem Transaktions-Hash zu suchen.
-Als Nächstes gehen Sie zu Ihrem [Alchemy-Mempool](https://dashboard.alchemyapi.io/mempool), um den Status Ihrer Transaktion zu sehen (ob sie ausstehend ist, geprägt oder vom Netzwerk abgebrochen wurde). Wenn Ihre Transaktion abgebrochen wurde, ist es auch hilfreich, [Ropsten-Etherscan](https://ropsten.etherscan.io/) zu überprüfen und nach Ihrem Transaktionshash zu suchen.
+_Ihren NFT-Transaktions-Hash auf Etherscan anzeigen_
-_NFT-Transaktionshash auf Etherscan ansehen_
+Und das war's! Sie haben nun einen NFT auf der Ethereum-Blockchain bereitgestellt UND geprägt
-
-
-Führen Sie keinen Commit für .env aus. Stellen Sie sicher, dass Sie Ihre .env-Datei niemals an andere weitergeben, denn damit würden Sie Ihre geheimen Daten weitergeben. Wenn Sie die Versionskontrolle verwenden, fügen Sie Ihre Env-Datei zu einer Datei gitignore hinzu.
-
-
-
+`](https://any.site/ipfs/bafybeifqka2odrne5b6l5guthqvbxu4pujko2i6rx2zslvr3qxs6u5o7im) gehen und Sie erhalten diesen Inhalt auf dezentralisierte Weise.
+
+## Nachteile {#drawbacks}
+
+Sie können IPFS-Dateien nicht zuverlässig löschen. Solange Sie also Ihre Benutzeroberfläche ändern, ist es wahrscheinlich am besten, sie entweder zentralisiert zu belassen oder das [Interplanetary Name System (IPNS)](https://docs.ipfs.tech/concepts/ipns/#mutability-in-ipfs) zu verwenden, ein System, das Veränderbarkeit auf IPFS bietet. Natürlich kann alles, was veränderbar ist, zensiert werden, im Fall von IPNS, indem man die Person unter Druck setzt, die den zugehörigen privaten Schlüssel besitzt.
+
+Außerdem haben einige Pakete ein Problem mit IPFS. Wenn Ihre Website also sehr kompliziert ist, ist das möglicherweise keine gute Lösung. Und natürlich kann alles, was auf Server-Integration angewiesen ist, nicht dezentralisiert werden, nur weil die Client-Seite auf IPFS liegt.
+
+## Fazit {#conclusion}
+
+So wie Ethereum es Ihnen ermöglicht, die Datenbank- und Geschäftslogikaspekte Ihrer Dapp zu dezentralisieren, ermöglicht IPFS die Dezentralisierung der Benutzeroberfläche. Damit können Sie einen weiteren Angriffsvektor gegen Ihre Dapp ausschalten.
+
+[Hier finden Sie mehr von meiner Arbeit](https://cryptodocguy.pro/).
diff --git a/public/content/translations/de/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md b/public/content/translations/de/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md
new file mode 100644
index 00000000000..e9232251e92
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md
@@ -0,0 +1,111 @@
+---
+title: Starte deine Dapp-Frontend-Entwicklung mit create-eth-app
+description: Ein Überblick über die Verwendung und Funktionen von create-eth-app
+author: "Markus Waas"
+tags:
+ [
+ "Frontend",
+ "javascript",
+ "ethers.js",
+ "the graph",
+ "defi"
+ ]
+skill: beginner
+lang: de
+published: 2020-04-27
+source: soliditydeveloper.com
+sourceUrl: https://soliditydeveloper.com/create-eth-app
+---
+
+Zuletzt haben wir uns [das große Ganze von Solidity](https://soliditydeveloper.com/solidity-overview-2020) angesehen und bereits [create-eth-app](https://github.com/PaulRBerg/create-eth-app) erwähnt. Jetzt erfährst du, wie du sie verwenden kannst, welche Funktionen integriert sind und wie du sie weiter ausbauen kannst. Diese App, die von Paul Razvan Berg, dem Gründer von [Sablier](http://sablier.com/), gestartet wurde, wird deine Frontend-Entwicklung in Schwung bringen und bietet mehrere optionale Integrationen zur Auswahl.
+
+## Installation {#installation}
+
+Die Installation erfordert Yarn 0.25 oder höher (`npm install yarn --global`). Die Ausführung ist denkbar einfach:
+
+```bash
+yarn create eth-app my-eth-app
+cd my-eth-app
+yarn react-app:start
+```
+
+Es verwendet [create-react-app](https://github.com/facebook/create-react-app) unter der Haube. Um deine App zu sehen, öffne `http://localhost:3000/`. Wenn du bereit für den Einsatz in der Produktion bist, erstelle mit yarn build ein minifiziertes Bundle. Eine einfache Möglichkeit, dies zu hosten, wäre [Netlify](https://www.netlify.com/). Du kannst ein GitHub-Repo erstellen, es zu Netlify hinzufügen, den Build-Befehl einrichten und schon bist du fertig! Deine App wird gehostet und ist für alle nutzbar. Und all das kostenlos.
+
+## Funktionen {#features}
+
+### React & create-react-app {#react--create-react-app}
+
+Zunächst einmal das Herzstück der App: React und all die zusätzlichen Funktionen, die mit _create-react-app_ kommen. Die alleinige Nutzung ist eine gute Option, wenn du Ethereum nicht integrieren möchtest. [React](https://react.dev/) selbst macht die Erstellung interaktiver UIs wirklich einfach. Es mag nicht so einsteigerfreundlich sein wie [Vue](https://vuejs.org/), aber es wird immer noch am häufigsten verwendet, hat mehr Funktionen und, was am wichtigsten ist, es stehen Tausende von zusätzlichen Bibliotheken zur Auswahl. Die _create-react-app_ macht den Einstieg ebenfalls sehr einfach und umfasst:
+
+- Unterstützung für React-, JSX-, ES6-, TypeScript- und Flow-Syntax.
+- Spracherweiterungen über ES6 hinaus, wie der Object-Spread-Operator.
+- CSS mit automatischen Präfixen, sodass du keine -webkit- oder andere Präfixe benötigst.
+- Ein schneller, interaktiver Unit-Test-Runner mit integrierter Unterstützung für Coverage-Reporting.
+- Ein Live-Entwicklungsserver, der vor häufigen Fehlern warnt.
+- Ein Build-Skript zum Bündeln von JS, CSS und Bildern für die Produktion, mit Hashes und Sourcemaps.
+
+Die _create-eth-app_ macht insbesondere von den neuen [Hooks-Effekten](https://legacy.reactjs.org/docs/hooks-effect.html) Gebrauch. Eine Methode, um leistungsstarke und dennoch sehr kleine sogenannte funktionale Komponenten zu schreiben. Wie sie in _create-eth-app_ verwendet werden, steht im folgenden Abschnitt über Apollo.
+
+### Yarn Workspaces {#yarn-workspaces}
+
+[Yarn Workspaces](https://classic.yarnpkg.com/en/docs/workspaces/) ermöglichen es, mehrere Pakete zu haben, diese aber alle vom Stammverzeichnis aus zu verwalten und die Abhängigkeiten für alle auf einmal mit `yarn install` zu installieren. Dies ist vor allem bei kleineren Zusatzpaketen wie dem Management von Smart-Contract-Adressen/ABIs (die Information darüber, wo man welche Smart Contracts eingesetzt hat und wie man mit ihnen kommuniziert) oder der Graph-Integration sinnvoll, die beide Teil von `create-eth-app` sind.
+
+### ethers.js {#ethersjs}
+
+Obwohl [Web3](https://docs.web3js.org/) immer noch am häufigsten verwendet wird, hat [ethers.js](https://docs.ethers.io/) im letzten Jahr als Alternative viel Anklang gefunden und ist in _create-eth-app_ integriert. Du kannst damit arbeiten, zu Web3 wechseln oder ein Upgrade auf [ethers.js v5](https://docs.ethers.org/v5/) in Erwägung ziehen, das fast die Beta-Phase abgeschlossen hat.
+
+### The Graph {#the-graph}
+
+[GraphQL](https://graphql.org/) ist im Vergleich zu einer [RESTful-API](https://restfulapi.net/) eine alternative Methode für den Umgang mit Daten. Sie haben mehrere Vorteile gegenüber RESTful-APIs, insbesondere für dezentrale Blockchain-Daten. Wenn du an der Begründung dafür interessiert bist, schau dir [GraphQL Will Power the Decentralized Web](https://medium.com/graphprotocol/graphql-will-power-the-decentralized-web-d7443a69c69a) an.
+
+Normalerweise würdest du Daten direkt von deinem Smart Contract abrufen. Willst du die Zeit des letzten Handels auslesen? Rufe einfach `MyContract.methods.latestTradeTime().call()` auf, was die Daten von einem Ethereum-Node in deine Dapp holt. Aber was ist, wenn du Hunderte verschiedener Datenpunkte benötigst? Das würde zu Hunderten von Datenabrufen beim Node führen, die jedes Mal eine [RTT](https://wikipedia.org/wiki/Round-trip_delay_time) erfordern, was deine Dapp langsam und ineffizient machen würde. Eine Problemumgehung könnte eine Abruffunktion in deinem Contract sein, die mehrere Daten auf einmal zurückgibt. Das ist aber nicht immer ideal.
+
+Und dann bist du vielleicht auch an historischen Daten interessiert. Du willst nicht nur die Zeit des letzten Handels wissen, sondern die Zeiten aller Handelsgeschäfte, die du jemals selbst getätigt hast. Verwende das Subgraph-Paket von _create-eth-app_, lies die [Dokumentation](https://thegraph.com/docs/en/subgraphs/developing/creating/starting-your-subgraph) und passe es an deine eigenen Contracts an. Wenn du nach beliebten Smart Contracts suchst, gibt es möglicherweise sogar bereits einen Subgraph. Sieh dir den [Subgraph-Explorer](https://thegraph.com/explorer/) an.
+
+Sobald du einen Subgraph hast, kannst du eine einfache Abfrage in deiner Dapp schreiben, die alle wichtigen Blockchain-Daten, einschließlich historischer Daten, die du benötigst, abruft; dafür ist nur ein Abruf erforderlich.
+
+### Apollo {#apollo}
+
+Dank der [Apollo Boost](https://www.apollographql.com/docs/react/get-started/)-Integration kannst du den Graphen einfach in deine React-Dapp integrieren. Besonders bei der Verwendung von React Hooks und Apollo ist das Abrufen von Daten so einfach wie das Schreiben einer einzigen GraphQL-Abfrage in deiner Komponente:
+
+```js
+const { loading, error, data } = useQuery(myGraphQlQuery)
+
+React.useEffect(() => {
+ if (!loading && !error && data) {
+ console.log({ data })
+ }
+}, [loading, error, data])
+```
+
+## Vorlagen {#templates}
+
+Darüber hinaus kannst du aus verschiedenen Vorlagen wählen. Bisher kannst du eine Aave-, Compound-, UniSwap- oder Sablier-Integration verwenden. Sie alle fügen wichtige Smart-Contract-Adressen für Dienste zusammen mit vorgefertigten Subgraph-Integrationen hinzu. Füge einfach die Vorlage zum Erstellungsbefehl hinzu, wie `yarn create eth-app my-eth-app --with-template aave`.
+
+### Aave {#aave}
+
+[Aave](https://aave.com/) ist ein dezentraler Geldleihmarkt. Die Einleger stellen dem Markt Liquidität zur Verfügung, um passives Einkommen zu generieren, während Kreditnehmer sich mithilfe von Sicherheiten Geld leihen können. Eine einzigartige Funktion von Aave sind die [Flash Loans](https://aave.com/docs/developers/flash-loans), die es dir ermöglichen, Geld ohne jegliche Sicherheiten zu leihen, solange du das Darlehen innerhalb einer einzigen Transaktion zurückzahlst. Das kann zum Beispiel nützlich sein, um zusätzliches Geld für das Arbitrage-Trading zu erhalten.
+
+Gehandelte Token, die dir Zinsen einbringen, werden _aTokens_ genannt.
+
+Wenn du dich für die Integration von Aave mit _create-eth-app_ entscheidest, erhältst du eine [Subgraph-Integration](https://docs.aave.com/developers/getting-started/using-graphql). Aave verwendet The Graph und stellt dir bereits mehrere einsatzbereite Subgraphs auf [Ropsten](https://thegraph.com/explorer/subgraph/aave/protocol-ropsten) und [Mainnet](https://thegraph.com/explorer/subgraph/aave/protocol) in [roher](https://thegraph.com/explorer/subgraph/aave/protocol-raw) oder [formatierter](https://thegraph.com/explorer/subgraph/aave/protocol) Form zur Verfügung.
+
+
+
+### Compound {#compound}
+
+[Compound](https://compound.finance/) ist ähnlich wie Aave. Die Integration enthält bereits den neuen [Compound v2 Subgraph](https://medium.com/graphprotocol/https-medium-com-graphprotocol-compound-v2-subgraph-highlight-a5f38f094195). Die zinsbringenden Token werden hier überraschenderweise _cTokens_ genannt.
+
+### Uniswap {#uniswap}
+
+[Uniswap](https://uniswap.exchange/) ist eine dezentralisierte Börse (DEX). Liquiditätsanbieter können Gebühren verdienen, indem sie die erforderlichen Token oder Ether für beide Seiten eines Handels bereitstellen. Es ist weit verbreitet und hat daher eine der höchsten Liquiditäten für eine sehr breite Palette von Token. Du kannst es einfach in deine Dapp integrieren, um beispielsweise Benutzern zu ermöglichen, ihre ETH gegen DAI zu tauschen.
+
+Leider ist die Integration zum Zeitpunkt der Erstellung dieses Artikels nur für Uniswap v1 und nicht für die [gerade veröffentlichte v2](https://uniswap.org/blog/uniswap-v2/) möglich.
+
+### Sablier {#sablier}
+
+[Sablier](https://sablier.com/) ermöglicht Benutzern das Streamen von Geldzahlungen. Anstelle eines einzelnen Zahltages erhältst du dein Geld nach der anfänglichen Einrichtung kontinuierlich und ohne weitere Verwaltung. Die Integration umfasst einen [eigenen Subgraph](https://thegraph.com/explorer/subgraph/sablierhq/sablier).
+
+## Was kommt als Nächstes? {#whats-next}
+
+Wenn du Fragen zu _create-eth-app_ hast, besuche den [Sablier Community-Server](https://discord.gg/bsS8T47), wo du mit den Autoren von _create-eth-app_ in Kontakt treten kannst. Als erste nächste Schritte könntest du ein UI-Framework wie [Material UI](https://mui.com/material-ui/) integrieren, GraphQL-Abfragen für die Daten schreiben, die du tatsächlich benötigst, und das Deployment einrichten.
diff --git a/public/content/translations/de/developers/tutorials/learn-foundational-ethereum-topics-with-sql/index.md b/public/content/translations/de/developers/tutorials/learn-foundational-ethereum-topics-with-sql/index.md
new file mode 100644
index 00000000000..8872be138ea
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/learn-foundational-ethereum-topics-with-sql/index.md
@@ -0,0 +1,269 @@
+---
+title: Grundlegende Ethereum-Themen mit SQL lernen
+description: Dieses Tutorial hilft Lesern, grundlegende Ethereum-Konzepte wie Transaktionen, Blöcke und Gas zu verstehen, indem sie On-Chain-Daten mit der Structured Query Language (SQL) abfragen.
+author: "Paul Apivat"
+tags: [ "SQL", "Abfragen", "Transaktionen" ]
+skill: beginner
+lang: de
+published: 2021-05-11
+source: paulapivat.com
+sourceUrl: https://paulapivat.com/post/query_ethereum/
+---
+
+Viele Ethereum-Tutorials richten sich an Entwickler, aber es mangelt an Lernressourcen für Datenanalysten oder für Leute, die On-Chain-Daten einsehen möchten, ohne einen Client oder einen Knoten zu betreiben.
+
+Dieses Tutorial hilft Lesern, grundlegende Ethereum-Konzepte wie Transaktionen, Blöcke und Gas zu verstehen, indem sie On-Chain-Daten mit der Structured Query Language (SQL) über eine von [Dune Analytics](https://dune.com/) bereitgestellte Schnittstelle abfragen.
+
+On-Chain-Daten können uns helfen, Ethereum, das Netzwerk und seine Wirtschaftlichkeit in Bezug auf die Rechenleistung zu verstehen. Sie sollten als Grundlage für das Verständnis der Herausforderungen dienen, mit denen Ethereum heute konfrontiert ist (z. B. steigende Gaspreise) und, was noch wichtiger ist, für Diskussionen über Skalierungslösungen.
+
+### Transaktionen {#transactions}
+
+Die Reise eines Nutzers auf Ethereum beginnt mit der Initialisierung eines nutzergesteuerten Kontos oder einer Entität mit einem ETH-Guthaben. Es gibt zwei Kontotypen – benutzergesteuert oder ein Smart Contract (siehe [ethereum.org](/developers/docs/accounts/)).
+
+Jedes Konto kann in einem Block-Explorer wie [Etherscan](https://etherscan.io/) oder [Blockscout](https://eth.blockscout.com/) eingesehen werden. Block-Explorer sind ein Portal zu den Daten von Ethereum. Sie zeigen in Echtzeit Daten zu Blöcken, Transaktionen, Minern, Konten und anderen On-Chain-Aktivitäten an (siehe [hier](/developers/docs/data-and-analytics/block-explorers/)).
+
+Ein Benutzer möchte die Daten jedoch möglicherweise direkt abfragen, um die von externen Block-Explorern bereitgestellten Informationen abzugleichen. [Dune Analytics](https://dune.com/) bietet diese Möglichkeit jedem, der über SQL-Kenntnisse verfügt.
+
+Als Referenz kann das Smart-Contract-Konto der Ethereum Foundation (EF) auf [Blockscout](https://eth.blockscout.com/address/0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe) eingesehen werden.
+
+Es ist zu beachten, dass alle Konten, einschließlich desjenigen der EF, eine öffentliche Adresse haben, die zum Senden und Empfangen von Transaktionen verwendet werden kann.
+
+Der Kontostand auf Etherscan umfasst reguläre Transaktionen und interne Transaktionen. Interne Transaktionen sind, trotz des Namens, keine _tatsächlichen_ Transaktionen, die den Zustand der Chain ändern. Es handelt sich um Wertübertragungen, die durch die Ausführung eines Vertrags initiiert werden ([Quelle](https://ethereum.stackexchange.com/questions/3417/how-to-get-contract-internal-transactions)). Da interne Transaktionen keine Signatur haben, sind sie **nicht** in der Blockchain enthalten und können nicht mit Dune Analytics abgefragt werden.
+
+Daher wird sich dieses Tutorial auf reguläre Transaktionen konzentrieren. Dies kann wie folgt abgefragt werden:
+
+```sql
+WITH temp_table AS (
+SELECT
+ hash,
+ block_number,
+ block_time,
+ "from",
+ "to",
+ value / 1e18 AS ether,
+ gas_used,
+ gas_price / 1e9 AS gas_price_gwei
+FROM ethereum."transactions"
+WHERE "to" = '\xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'
+ORDER BY block_time DESC
+)
+SELECT
+ hash,
+ block_number,
+ block_time,
+ "from",
+ "to",
+ ether,
+ (gas_used * gas_price_gwei) / 1e9 AS txn_fee
+FROM temp_table
+```
+
+Dies liefert die gleichen Informationen wie auf der Transaktionsseite von Etherscan. Zum Vergleich, hier die beiden Quellen:
+
+#### Etherscan {#etherscan}
+
+
+
+[Vertragsseite der EF auf Blockscout.](https://eth.blockscout.com/address/0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe)
+
+#### Dune Analytics {#dune-analytics}
+
+
+
+Das Dashboard finden Sie [hier](https://dune.com/paulapivat/Learn-Ethereum). Klicken Sie auf die Tabelle, um die Abfrage zu sehen (siehe auch oben).
+
+### Transaktionen im Detail {#breaking_down_transactions}
+
+Eine übermittelte Transaktion enthält mehrere Informationen, darunter ([Quelle](/developers/docs/transactions/)):
+
+- **Empfänger**: Die Empfangsadresse (abgefragt als „to“)
+- **Signatur**: Während die privaten Schlüssel eines Absenders eine Transaktion signieren, können wir mit SQL die öffentliche Adresse eines Absenders abfragen („from“).
+- **Wert**: Dies ist der Betrag an transferiertem ETH (siehe Spalte `ether`).
+- **Daten**: Das sind beliebige Daten, die gehasht wurden (siehe Spalte `data`)
+- **gasLimit** – die maximale Menge an Gaseinheiten, die von der Transaktion verbraucht werden kann. Gaseinheiten stellen Rechenschritte dar.
+- **maxPriorityFeePerGas** – die maximale Gasmenge, die als Trinkgeld für den Miner enthalten sein soll
+- **maxFeePerGas** – die maximale Menge an Gas, die für die Transaktion gezahlt werden soll (einschließlich baseFeePerGas und maxPriorityFeePerGas)
+
+Wir können diese spezifischen Informationen für Transaktionen an die öffentliche Adresse der Ethereum Foundation abfragen:
+
+```sql
+SELECT
+ "to",
+ "from",
+ value / 1e18 AS ether,
+ data,
+ gas_limit,
+ gas_price / 1e9 AS gas_price_gwei,
+ gas_used,
+ ROUND(((gas_used / gas_limit) * 100),2) AS gas_used_pct
+FROM ethereum."transactions"
+WHERE "to" = '\xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'
+ORDER BY block_time DESC
+```
+
+### Blöcke {#blocks}
+
+Jede Transaktion ändert den Zustand der Ethereum Virtual Machine ([EVM](/developers/docs/evm/)) ([Quelle](/developers/docs/transactions/)). Transaktionen werden an das Netzwerk gesendet, um verifiziert und in einen Block aufgenommen zu werden. Jede Transaktion ist mit einer Blocknummer verknüpft. Um die Daten zu sehen, können wir eine bestimmte Blocknummer abfragen: 12396854 (der jüngste Block der Ethereum-Foundation-Transaktionen zum Zeitpunkt des Schreibens dieses Tutorials am 5.11.2021).
+
+Wenn wir die nächsten beiden Blöcke abfragen, können wir außerdem sehen, dass jeder Block den Hash des vorherigen Blocks (d. h. den übergeordneten Hash) enthält, was zeigt, wie die Blockchain aufgebaut ist.
+
+Jeder Block enthält einen Verweis auf seinen übergeordneten Block. Dies wird unten zwischen den Spalten `hash` und `parent_hash` gezeigt ([Quelle](/developers/docs/blocks/)):
+
+
+
+Hier ist die [Abfrage](https://dune.com/queries/44856/88292) auf Dune Analytics:
+
+```sql
+SELECT
+ time,
+ number,
+ hash,
+ parent_hash,
+ nonce
+FROM ethereum."blocks"
+WHERE "number" = 12396854 OR "number" = 12396855 OR "number" = 12396856
+LIMIT 10
+```
+
+Wir können einen Block untersuchen, indem wir Zeit, Blocknummer, Schwierigkeitsgrad, Hash, übergeordneten Hash und die Nonce abfragen.
+
+Das Einzige, was diese Abfrage nicht abdeckt, ist die _Liste der Transaktionen_, die eine separate Abfrage unten erfordert, und der _State-Root_. Ein Full- oder Archiv-Node speichert alle Transaktionen und Zustandsübergänge, sodass Clients den Zustand der Chain jederzeit abfragen können. Da dies viel Speicherplatz erfordert, können wir Chain-Daten von Zustandsdaten trennen:
+
+- Chain-Daten (Liste von Blöcken, Transaktionen)
+- Zustandsdaten (Ergebnis des Zustandsübergangs jeder Transaktion)
+
+Der State-Root fällt unter Letzteres und ist _implizite_ Daten (nicht on-chain gespeichert), während Chain-Daten explizit sind und auf der Chain selbst gespeichert werden ([Quelle](https://ethereum.stackexchange.com/questions/359/where-is-the-state-data-stored)).
+
+In diesem Tutorial konzentrieren wir uns auf On-Chain-Daten, die mit SQL über Dune Analytics abgefragt werden _können_.
+
+Wie oben erwähnt, enthält jeder Block eine Liste von Transaktionen. Wir können diese abfragen, indem wir nach einem bestimmten Block filtern. Wir versuchen es mit dem letzten Block, 12396854:
+
+```sql
+SELECT * FROM ethereum."transactions"
+WHERE block_number = 12396854
+ORDER BY block_time DESC`
+```
+
+Hier ist die SQL-Ausgabe auf Dune:
+
+
+
+Dieser einzelne Block, der der Chain hinzugefügt wird, ändert den Zustand der Ethereum Virtual Machine ([EVM](/developers/docs/evm/)). Dutzende, manchmal Hunderte von Transaktionen werden auf einmal verifiziert. In diesem speziellen Fall waren 222 Transaktionen enthalten.
+
+Um zu sehen, wie viele tatsächlich erfolgreich waren, fügen wir einen weiteren Filter hinzu, um erfolgreiche Transaktionen zu zählen:
+
+```sql
+WITH temp_table AS (
+ SELECT * FROM ethereum."transactions"
+ WHERE block_number = 12396854 AND success = true
+ ORDER BY block_time DESC
+)
+SELECT
+ COUNT(success) AS num_successful_txn
+FROM temp_table
+```
+
+Für Block 12396854 wurden von insgesamt 222 Transaktionen 204 erfolgreich verifiziert:
+
+
+
+Transaktionsanfragen kommen Dutzende Male pro Sekunde vor, aber Blöcke werden etwa alle 15 Sekunden committet ([Quelle](/developers/docs/blocks/)).
+
+Um zu sehen, dass ungefähr alle 15 Sekunden ein Block produziert wird, können wir die Anzahl der Sekunden pro Tag (86.400) durch 15 teilen, um eine geschätzte durchschnittliche Anzahl von Blöcken pro Tag (~ 5.760) zu erhalten.
+
+Das Diagramm der täglich erzeugten Ethereum-Blöcke (2016 – heute) ist:
+
+
+
+Die durchschnittliche Anzahl der in diesem Zeitraum täglich produzierten Blöcke beträgt ~5.874:
+
+
+
+Die Abfragen lauten:
+
+```sql
+# Abfrage zur Visualisierung der täglich produzierten Blöcke seit 2016
+
+SELECT
+ DATE_TRUNC('day', time) AS dt,
+ COUNT(*) AS block_count
+FROM ethereum."blocks"
+GROUP BY dt
+OFFSET 1
+
+# durchschnittliche Anzahl der pro Tag produzierten Blöcke
+
+WITH temp_table AS (
+SELECT
+ DATE_TRUNC('day', time) AS dt,
+ COUNT(*) AS block_count
+FROM ethereum."blocks"
+GROUP BY dt
+OFFSET 1
+)
+SELECT
+ AVG(block_count) AS avg_block_count
+FROM temp_table
+```
+
+Die durchschnittliche Anzahl der seit 2016 pro Tag produzierten Blöcke liegt mit 5.874 leicht über diesem Wert. Alternativ ergeben 86.400 Sekunden geteilt durch 5.874 durchschnittliche Blöcke 14,7 Sekunden oder ungefähr einen Block alle 15 Sekunden.
+
+### Gas {#gas}
+
+Blöcke sind in ihrer Größe begrenzt. Die maximale Blockgröße ist dynamisch und variiert je nach Netzwerknachfrage zwischen 12.500.000 und 25.000.000 Einheiten. Limits sind erforderlich, um zu verhindern, dass willkürlich große Blöcke die Full Nodes in Bezug auf Speicherplatz- und Geschwindigkeitsanforderungen belasten ([Quelle](/developers/docs/blocks/)).
+
+Eine Möglichkeit, sich das Block-Gaslimit vorzustellen, ist, es als das **Angebot** an verfügbarem Blockspace zu betrachten, in dem Transaktionen gebündelt werden. Das Block-Gaslimit kann von 2016 bis heute abgefragt und visualisiert werden:
+
+
+
+```sql
+SELECT
+ DATE_TRUNC('day', time) AS dt,
+ AVG(gas_limit) AS avg_block_gas_limit
+FROM ethereum."blocks"
+GROUP BY dt
+OFFSET 1
+```
+
+Dann gibt es das tatsächlich täglich verwendete Gas, um für Berechnungen auf der Ethereum-Chain zu bezahlen (d. h. das Senden von Transaktionen, das Aufrufen eines Smart Contracts, das Prägen eines NFT). Dies ist die **Nachfrage** nach verfügbarem Ethereum-Blockspace:
+
+
+
+```sql
+SELECT
+ DATE_TRUNC('day', time) AS dt,
+ AVG(gas_used) AS avg_block_gas_used
+FROM ethereum."blocks"
+GROUP BY dt
+OFFSET 1
+```
+
+Wir können diese beiden Diagramme auch einander gegenüberstellen, um zu sehen, wie sich **Angebot und Nachfrage** beeinflussen:
+
+
+
+Daher können wir Gaspreise als eine Funktion der Nachfrage nach Ethereum-Blockspace bei gegebenem Angebot verstehen.
+
+Schließlich möchten wir vielleicht die durchschnittlichen täglichen Gaspreise für die Ethereum-Chain abfragen. Dies würde jedoch zu einer besonders langen Abfragezeit führen, also filtern wir unsere Abfrage auf die durchschnittliche Gasmenge, die von der Ethereum Foundation pro Transaktion bezahlt wird.
+
+
+
+Wir können die Gaspreise sehen, die über die Jahre für alle an die Adresse der Ethereum Foundation getätigten Transaktionen gezahlt wurden. Hier ist die Abfrage:
+
+```sql
+SELECT
+ block_time,
+ gas_price / 1e9 AS gas_price_gwei,
+ value / 1e18 AS eth_sent
+FROM ethereum."transactions"
+WHERE "to" = '\xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'
+ORDER BY block_time DESC
+```
+
+### Zusammenfassung {#summary}
+
+Mit diesem Tutorial verstehen wir grundlegende Ethereum-Konzepte und wie die Ethereum-Blockchain funktioniert, indem wir On-Chain-Daten abfragen und ein Gefühl für sie bekommen.
+
+Das Dashboard mit dem gesamten in diesem Tutorial verwendeten Code finden Sie [hier](https://dune.com/paulapivat/Learn-Ethereum).
+
+Für weitere Datennutzung zur Erkundung von Web3 [finden Sie mich auf Twitter](https://twitter.com/paulapivat).
diff --git a/public/content/translations/de/developers/tutorials/logging-events-smart-contracts/index.md b/public/content/translations/de/developers/tutorials/logging-events-smart-contracts/index.md
new file mode 100644
index 00000000000..12a4ea98838
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/logging-events-smart-contracts/index.md
@@ -0,0 +1,68 @@
+---
+title: Protokollierung von Daten aus Smart Contracts mit Ereignissen
+description: Eine Einführung in Smart-Contract-Ereignisse und wie Sie diese zur Datenprotokollierung verwenden können
+author: "jdourlens"
+tags:
+ [
+ "intelligente Verträge",
+ "remix",
+ "solidity",
+ "ereignisse"
+ ]
+skill: intermediate
+lang: de
+published: 2020-04-03
+source: EthereumDev
+sourceUrl: https://ethereumdev.io/logging-data-with-events/
+address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
+---
+
+In Solidity sind [Ereignisse](/developers/docs/smart-contracts/anatomy/#events-and-logs) Signale, die von Smart Contracts ausgegeben werden können. Dapps oder alles, was mit der JSON-RPC-API von Ethereum verbunden ist, können auf diese Ereignisse lauschen und entsprechend reagieren. Ein Ereignis kann auch indiziert werden, sodass der Ereignisverlauf später durchsuchbar ist.
+
+## Ereignisse {#events}
+
+Das häufigste Ereignis auf der Ethereum-Blockchain ist zum Zeitpunkt der Erstellung dieses Artikels das Transfer-Ereignis, das von ERC20-Tokens ausgegeben wird, wenn jemand Token überträgt.
+
+```solidity
+event Transfer(address indexed from, address indexed to, uint256 value);
+```
+
+Die Ereignissignatur wird innerhalb des Vertragscodes deklariert und kann mit dem Schlüsselwort emit ausgegeben werden. Zum Beispiel protokolliert das Transfer-Ereignis, wer die Übertragung gesendet hat (_from_), an wen (_to_) und wie viele Token übertragen wurden (_value_).
+
+Wenn wir zu unserem Counter-Smart-Contract zurückkehren und beschließen, jedes Mal zu protokollieren, wenn der Wert geändert wird. Da dieser Vertrag nicht zur Bereitstellung gedacht ist, sondern als Grundlage für die Erstellung eines anderen Vertrags durch Erweiterung dient, wird er als abstrakter Vertrag bezeichnet. Im Fall unseres Counter-Beispiels würde es so aussehen:
+
+```solidity
+pragma solidity 0.5.17;
+
+contract Counter {
+
+ event ValueChanged(uint oldValue, uint256 newValue);
+
+ // Private Variable vom Typ unsigned int zur Speicherung der Anzahl der Zählungen
+ uint256 private count = 0;
+
+ // Funktion, die unseren Zähler inkrementiert
+ function increment() public {
+ count += 1;
+ emit ValueChanged(count - 1, count);
+ }
+
+ // Getter zum Abrufen des Zählwerts
+ function getCount() public view returns (uint256) {
+ return count;
+ }
+
+}
+```
+
+Beachten Sie Folgendes:
+
+- **Zeile 5**: Wir deklarieren unser Ereignis und was es enthält: den alten Wert und den neuen Wert.
+
+- **Zeile 13**: Wenn wir unsere Zählvariable inkrementieren, geben wir das Ereignis aus.
+
+Wenn wir nun den Vertrag bereitstellen und die increment-Funktion aufrufen, sehen wir, dass Remix es automatisch anzeigt, wenn Sie auf die neue Transaktion in einem Array namens logs klicken.
+
+
+
+Logs sind sehr nützlich für das Debugging Ihrer Smart Contracts, aber sie sind auch wichtig, wenn Sie Anwendungen erstellen, die von verschiedenen Personen genutzt werden. Sie erleichtern die Analyse, um zu verfolgen und zu verstehen, wie Ihr Smart Contract genutzt wird. Die durch Transaktionen erzeugten Logs werden in gängigen Block-Explorern angezeigt und Sie können sie beispielsweise auch verwenden, um Off-Chain-Skripte zu erstellen, die auf bestimmte Ereignisse lauschen und bei deren Auftreten Maßnahmen ergreifen.
diff --git a/public/content/translations/de/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md b/public/content/translations/de/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md
new file mode 100644
index 00000000000..a592da5e65d
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md
@@ -0,0 +1,249 @@
+---
+title: Merkle-Beweise für Offline Datenintegrität
+description: Sicherstellung der Datenintegrität onchain für Daten, die größtenteils offchain gespeichert sind
+author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+tags: [ "Speicher" ]
+skill: advanced
+lang: de
+published: 2021-12-30
+---
+
+## Einführung {#introduction}
+
+Idealerweise möchten wir alles in einem Ethereum Speicher ablegen, der auf Tausenden von Computern gespeichert ist und eine extrem hohe Verfügbarkeit (die Daten können nicht zensiert werden) und Integrität (die Daten können nicht unbefugt verändert werden) aufweist, aber die Speicherung eines 32-Byte-Wortes kostet normalerweise 20.000 Gas. Während ich das schreibe, entsprechen
+diese Kosten 6,60 USD. Mit 21 Cent pro Byte ist das für viele Anwendungen zu teuer.
+
+Um dieses Problem zu lösen, hat das Ethereum-Ökosystem viele alternative Wege entwickelt, um Daten dezentral
+zu speichern. In der Regel muss dabei ein Kompromiss zwischen Verfügbarkeit und Preis eingegangen werden. Die Integrität ist jedoch in der Regel gewährleistet.
+
+In diesem Artikel erfahren Sie, **wie** Sie die Datenintegrität gewährleisten, ohne die Daten auf der Blockchain zu speichern, indem Sie
+[Merkle-Beweise](https://computersciencewiki.org/index.php/Merkle_proof) verwenden.
+
+## Wie funktioniert das? {#how-does-it-work}
+
+Theoretisch könnten wir einfach den Hash der Daten onchain speichern und alle Daten in Transaktionen senden, die sie benötigen. Allerdings ist das immer noch zu teuer. Ein Byte Daten zu einer Transaktion kostet etwa 16 Gas, derzeit etwa einen halben Cent, oder etwa 5 USD pro Kilobyte. Mit 5000 USD pro Megabyte ist dies für viele Anwendungen immer noch zu teuer, selbst ohne die zusätzlichen Kosten für das Hashing der Daten.
+
+Die Lösung ist, verschiedene Teilmengen der Daten wiederholt zu hashen, so dass Sie für die Daten, die Sie nicht zu senden brauchen, nur einen Hash senden können. Dazu verwenden Sie einen Merkle Tree, eine Baum Datenstruktur, bei der jeder Knoten ein Hash der darunter liegenden Knoten ist:
+
+
+
+Der Root-Hash ist der einzige Teil, der onchain gespeichert werden muss. Um einen bestimmten Wert zu beweisen, geben Sie alle Hashes an, die damit kombiniert werden müssen, um die Wurzel (Hash-Root) zu erhalten. Um zum Beispiel `C` zu beweisen, stellen Sie `D`, `H(A-B)` und `H(E-H)` zur Verfügung.
+
+
+
+## Implementierung {#implementation}
+
+[Der Beispielcode wird hier zur Verfügung gestellt](https://github.com/qbzzt/merkle-proofs-for-offline-data-integrity).
+
+### Offchain-Code {#offchain-code}
+
+In diesem Artikel verwenden wir JavaScript für die Offchain-Berechnungen. Die meisten dezentralisierten Anwendungen haben ihre Offchain-Komponente in JavaScript.
+
+#### Erstellen der Merkle-Root {#creating-the-merkle-root}
+
+Als erstes müssen wir die Merkle-Wurzel für die Chain bereitstellen.
+
+```javascript
+const ethers = require("ethers")
+```
+
+[Wir verwenden die Hash-Funktion aus dem Ethers-Paket](https://docs.ethers.io/v5/api/utils/hashing/#utils-keccak256).
+
+```javascript
+// Die Rohdaten, deren Integrität wir überprüfen müssen. Die ersten beiden Bytes
+// sind eine Benutzerkennung, und die letzten beiden Bytes sind die Menge der Tokens, die
+// der Benutzer derzeit besitzt.
+const dataArray = [
+ 0x0bad0010, 0x60a70020, 0xbeef0030, 0xdead0040, 0xca110050, 0x0e660060,
+ 0xface0070, 0xbad00080, 0x060d0091,
+]
+```
+
+Die Kodierung jedes Eintrags in eine einzelne 256-Bit-Integerzahl führt zu weniger lesbarem Code als z. B. die Verwendung von JSON. Allerdings bedeutet dies einen deutlich geringeren Verarbeitungsaufwand für die Abfrage der Vertragsdaten und damit deutlich niedrigere Gaskosten. [Man kann JSON onchain lesen](https://github.com/chrisdotn/jsmnSol), es ist nur eine schlechte Idee, wenn es vermeidbar ist.
+
+```javascript
+// Das Array der Hash-Werte als BigInts
+const hashArray = dataArray
+```
+
+In diesem Fall handelt es sich bei unseren Daten um 256 Bit-Werte, so dass keine Verarbeitung erforderlich ist. Wenn wir eine kompliziertere Datenstruktur verwenden, wie z. B. Strings, müssen wir sicherstellen, dass wir die Daten zuerst hashen, um ein Array von Hashes zu erhalten. Das liegt auch daran, weil es uns nicht interessiert, ob Benutzer die Informationen anderer Benutzer kennen. Andernfalls hätten wir einen Hash verwenden müssen, damit Benutzer 1 den Wert für Benutzer 0 nicht kennt, Benutzer 2 den Wert für Benutzer 3 nicht kennt usw.
+
+```javascript
+// Konvertieren zwischen dem String, den die Hash-Funktion erwartet, und dem
+// BigInt, das wir überall sonst verwenden.
+const hash = (x) =>
+ BigInt(ethers.utils.keccak256("0x" + x.toString(16).padStart(64, 0)))
+```
+
+Die Ethers-Hash-Funktion erwartet einen JavaScript-String mit einer hexadezimalen Zahl, wie z. B. `0x60A7`, und gibt einen anderen String mit der gleichen Struktur zurück. Für den Rest des Codes ist es jedoch einfacher, `BigInt` zu verwenden, also konvertieren wir es in einen hexadezimalen String und wieder zurück.
+
+```javascript
+// Symmetrischer Hash eines Paares, sodass die umgekehrte Reihenfolge keine Rolle spielt.
+const pairHash = (a, b) => hash(hash(a) ^ hash(b))
+```
+
+Diese Funktion ist symmetrisch (Hash von a [xor](https://en.wikipedia.org/wiki/Exclusive_or) b). Das bedeutet, dass wir uns bei der Überprüfung des Merkle-Beweises keine Gedanken darüber machen müssen, ob wir den Wert aus dem Beweis vor oder nach dem berechneten Wert setzen sollen. Die Überprüfung von Merkle-Beweisen wird onchain durchgeführt. Je weniger wir dort tun müssen, desto besser.
+
+Warnung:
+Kryptographie ist schwieriger als es aussieht.
+Die ursprüngliche Version dieses Artikels hatte die Hash-Funktion `hash(a^b)`.
+Das war eine **schlechte** Idee, denn es bedeutete, dass man, wenn man die legitimen Werte von `a` und `b` kannte, `b' = a^b^a'` verwenden konnte, um einen beliebigen `a'`-Wert zu beweisen.
+Mit dieser Funktion müsste man `b'` so berechnen, dass `hash(a') ^ hash(b')` gleich einem bekannten Wert ist (der nächste Zweig auf dem Weg zur Root), was viel schwieriger ist.
+
+```javascript
+// Der Wert, der anzeigt, dass ein bestimmter Zweig leer ist und keinen
+// Wert hat
+const empty = 0n
+```
+
+Wenn die Anzahl der Werte keine ganzzahlige Zweierpotenz ist, müssen wir leere Zweige behandeln. Bei diesem Programm wird die Null als Platzhalter eingesetzt.
+
+
+
+```javascript
+// Berechnet eine Ebene im Baum eines Hash-Arrays, indem der Hash
+// jedes Paares in der Sequenz genommen wird
+const oneLevelUp = (inputArray) => {
+ var result = []
+ var inp = [...inputArray] // Um das Überschreiben der Eingabe zu vermeiden // Fügt bei Bedarf einen leeren Wert hinzu (wir benötigen alle Blätter // als Paare)
+
+ if (inp.length % 2 === 1) inp.push(empty)
+
+ for (var i = 0; i < inp.length; i += 2)
+ result.push(pairHash(inp[i], inp[i + 1]))
+
+ return result
+} // oneLevelUp
+```
+
+Diese Funktion "klettert" eine Ebene im Merkle-Baum hoch, indem sie die Wertepaare auf der aktuellen Ebene hasht. Beachten Sie, dass dies nicht die effizienteste Implementierung ist. Wir hätten das Kopieren der Eingabe vermeiden und einfach `hashEmpty` an der entsprechenden Stelle in der Schleife hinzufügen können, aber dieser Code ist auf Lesbarkeit optimiert.
+
+```javascript
+const getMerkleRoot = (inputArray) => {
+ var result
+
+ result = [...inputArray] // Klettere den Baum hinauf, bis es nur noch einen Wert gibt, das ist die // Root. // // Wenn eine Ebene eine ungerade Anzahl von Einträgen hat, fügt der // Code in oneLevelUp einen leeren Wert hinzu. Wenn wir also zum Beispiel // 10 Blätter haben, haben wir 5 Zweige in der zweiten Ebene, 3 // Zweige in der dritten, 2 in der vierten und die Root ist die fünfte
+
+ while (result.length > 1) result = oneLevelUp(result)
+
+ return result[0]
+}
+```
+
+Um die Wurzel zu bekommen, mache so lange, bis nur noch ein Wert übrig ist.
+
+#### Erstellen eines Merkle-Beweises {#creating-a-merkle-proof}
+
+Ein Merkle-Beweis besteht aus den Werten, die zusammen mit dem zu beweisenden Wert gehasht werden müssen, um die Merkle-Wurzel zu erhalten. Der zu beweisende Wert ist oft aus anderen Daten verfügbar, daher ziehe ich es vor, ihn separat und nicht als Teil des Codes bereitzustellen.
+
+```javascript
+// Ein Merkle-Beweis besteht aus dem Wert der Liste der Einträge, mit denen
+// gehasht werden soll. Da wir eine symmetrische Hash-Funktion verwenden, benötigen wir
+// den Speicherort des Elements nicht, um den Beweis zu verifizieren, sondern nur, um ihn zu erstellen
+const getMerkleProof = (inputArray, n) => {
+ var result = [], currentLayer = [...inputArray], currentN = n
+
+ // Bis wir die Spitze erreichen
+ while (currentLayer.length > 1) {
+ // Keine Ebenen mit ungerader Länge
+ if (currentLayer.length % 2)
+ currentLayer.push(empty)
+
+ result.push(currentN % 2
+ // Wenn currentN ungerade ist, füge den Wert davor zum Beweis hinzu
+ ? currentLayer[currentN-1]
+ // Wenn es gerade ist, füge den Wert danach hinzu
+ : currentLayer[currentN+1])
+
+```
+
+Wir hashen `(v[0],v[1])`, `(v[2],v[3])` usw. Für gerade Werte benötigen wir also den nächsten, für ungerade Werte den vorherigen Wert.
+
+```javascript
+ // Auf die nächste Ebene aufsteigen
+ currentN = Math.floor(currentN/2)
+ currentLayer = oneLevelUp(currentLayer)
+ } // while currentLayer.length > 1
+
+ return result
+} // getMerkleProof
+```
+
+### Onchain-Code {#onchain-code}
+
+Schließlich haben wir den Code, der den Beweis überprüft. Der Onchain-Code ist in [Solidity](https://docs.soliditylang.org/en/v0.8.11/) geschrieben. Die Optimierung ist hier sehr viel wichtiger, weil Gas relativ teuer ist.
+
+```solidity
+//SPDX-License-Identifier: Public Domain
+pragma solidity ^0.8.0;
+
+import "hardhat/console.sol";
+```
+
+Ich habe dies mit der [Hardhat-Entwicklungsumgebung](https://hardhat.org/) geschrieben, die es uns ermöglicht, während der Entwicklung [Konsolenausgaben von Solidity](https://hardhat.org/docs/cookbook/debug-logs) zu haben.
+
+```solidity
+
+contract MerkleProof {
+ uint merkleRoot;
+
+ function getRoot() public view returns (uint) {
+ return merkleRoot;
+ }
+
+ // Äußerst unsicher, im Produktionscode muss der Zugriff auf
+ // diese Funktion STRENG limitiert sein, wahrscheinlich auf einen
+ // Besitzer
+ function setRoot(uint _merkleRoot) external {
+ merkleRoot = _merkleRoot;
+ } // setRoot
+```
+
+Set- und Get-Funktionen für die Merkle-Wurzel. Jeden die Merkle-Root aktualisieren zu lassen, ist eine _extrem schlechte Idee_ in einem Produktionssystem. Ich tue es hier der Einfachheit halber für den Beispielcode. **Tun Sie das nicht auf einem System, bei dem die Datenintegrität wirklich wichtig ist**.
+
+```solidity
+ function hash(uint _a) internal pure returns(uint) {
+ return uint(keccak256(abi.encode(_a)));
+ }
+
+ function pairHash(uint _a, uint _b) internal pure returns(uint) {
+ return hash(hash(_a) ^ hash(_b));
+ }
+```
+
+Diese Funktion erzeugt einen Paar-Hash. Es ist nur die Solidity-Übersetzung des JavaScript-Codes für `hash` und `pairHash`.
+
+**Hinweis:** Dies ist ein weiterer Fall der Optimierung auf Lesbarkeit. Basierend auf [der Funktionsdefinition](https://www.tutorialspoint.com/solidity/solidity_cryptographic_functions.htm) wäre es möglich, die Daten als [`bytes32`](https://docs.soliditylang.org/en/v0.5.3/types.html#fixed-size-byte-arrays)-Wert zu speichern und die Konvertierungen zu vermeiden.
+
+```solidity
+ // Überprüfen eines Merkle-Beweises
+ function verifyProof(uint _value, uint[] calldata _proof)
+ public view returns (bool) {
+ uint temp = _value;
+ uint i;
+
+ for(i=0; i<_proof.length; i++) {
+ temp = pairHash(temp, _proof[i]);
+ }
+
+ return temp == merkleRoot;
+ }
+
+} // MarkleProof
+```
+
+In mathematischer Notation sieht die Verifizierung eines Merkle-Beweises so aus: `H(proof_n, H(proof_n-1, H(proof_n-2, ...` H(proof_1, H(proof_0, value))...)))\`. Dieser Code implementiert sie.
+
+## Merkle-Beweise und Rollups vertragen sich nicht {#merkle-proofs-and-rollups}
+
+Merkle-Beweise funktionieren nicht gut mit [Rollups](/developers/docs/scaling/#rollups). Der Grund dafür ist, dass Rollups alle Transaktionsdaten auf L1 schreiben, aber auf L2 verarbeiten. Die Kosten für die Übermittlung eines Merkle-Beweises mit einer Transaktion belaufen sich auf durchschnittlich 638 Gas pro Ebene (derzeit kostet ein Byte in Call Data 16 Gas, wenn es nicht Null ist, und 4, wenn es Null ist). Bei einer Datenmenge von 1024 Wörtern sind für einen Merkle-Beweis zehn Ebenen erforderlich, also insgesamt 6380 Gas.
+
+Wenn man sich zum Beispiel [Optimism](https://public-grafana.optimism.io/d/9hkhMxn7z/public-dashboard?orgId=1&refresh=5m) ansieht, kostet das Schreiben von L1-Gas etwa 100 Gwei und L2-Gas 0,001 Gwei (das ist der normale Preis, er kann bei Überlastung steigen). Für die Kosten von einem L1 Gas können wir also hunderttausend Gas für die L2 Verarbeitung ausgeben. Wenn wir davon ausgehen, dass wir den Speicher nicht überschreiben, bedeutet das, dass wir für den Preis von einem L1 Gas etwa fünf Wörter in den L2 Speicher schreiben können. Für einen einzelnen Merkle-Beweis können wir die gesamten 1024 Wörter in den Speicher schreiben (vorausgesetzt, sie können von Anfang an onchain berechnet werden, anstatt in einer Transaktion bereitgestellt zu werden) und haben immer noch den größten Teil des Gases übrig.
+
+## Fazit {#conclusion}
+
+Im echten Leben werden Sie Merkle-Bäume vielleicht nie selbst implementieren. Es gibt bekannte und geprüfte Bibliotheken, die Sie verwenden können, wobei es im Allgemeinen nicht ratsam ist, kryptographische Primitive selbst zu implementieren. Aber ich hoffe, dass Sie jetzt die Merkle-Beweise besser verstehen und entscheiden können, wann es sich lohnt, sie einzusetzen.
+
+Beachten Sie, dass Merkle-Beweise zwar die _Integrität_, nicht aber die _Verfügbarkeit_ erhalten. Zu wissen, dass niemand sonst Ihre Assets nehmen kann, ist ein schwacher Trost, wenn der Datenspeicher beschließt, den Zugriff zu verweigern, und Sie auch keinen Merkle-Baum erstellen können, um darauf zuzugreifen. Merkle-Bäume werden daher am besten mit einer Art dezentralem Speicher wie IPFS verwendet.
+
+[Hier finden Sie mehr von meiner Arbeit](https://cryptodocguy.pro/).
diff --git a/public/content/translations/de/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/index.md b/public/content/translations/de/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/index.md
new file mode 100644
index 00000000000..7f1a167d61d
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/index.md
@@ -0,0 +1,151 @@
+---
+title: Überwachung von Geth mit InfluxDB und Grafana
+description: Richten Sie die Überwachung für Ihren Geth-Node mit InfluxDB und Grafana ein, um die Leistung zu verfolgen und Probleme zu identifizieren.
+author: "Mario Havel"
+tags: [ "Clients", "Nodes" ]
+skill: intermediate
+lang: de
+published: 2021-01-13
+---
+
+Dieses Tutorial hilft Ihnen dabei, die Überwachung für Ihren Geth-Node einzurichten, damit Sie dessen Leistung besser verstehen und potenzielle Probleme erkennen können.
+
+## Voraussetzungen {#prerequisites}
+
+- Sie sollten bereits eine Instanz von Geth ausführen.
+- Die meisten Schritte und Beispiele sind für eine Linux-Umgebung, grundlegende Terminalkenntnisse sind dabei hilfreich.
+- Sehen Sie sich diesen Videoüberblick über die Metrik-Suite von Geth an: [Monitoring an Ethereum infrastructure by Péter Szilágyi](https://www.youtube.com/watch?v=cOBab8IJMYI).
+
+## Überwachungs-Stack {#monitoring-stack}
+
+Ein Ethereum-Client sammelt eine Menge Daten, die in Form einer chronologischen Datenbank gelesen werden können. Um die Überwachung zu erleichtern, können Sie diese in eine Datenvisualisierungssoftware einspeisen. Es gibt mehrere verfügbare Optionen:
+
+- [Prometheus](https://prometheus.io/) (Pull-Modell)
+- [InfluxDB](https://www.influxdata.com/get-influxdb/) (Push-Modell)
+- [Telegraf](https://www.influxdata.com/get-influxdb/)
+- [Grafana](https://www.grafana.com/)
+- [Datadog](https://www.datadoghq.com/)
+- [Chronograf](https://www.influxdata.com/time-series-platform/chronograf/)
+
+Es gibt auch [Geth Prometheus Exporter](https://github.com/hunterlong/gethexporter), eine mit InfluxDB und Grafana vorkonfigurierte Option.
+
+In diesem Tutorial richten wir Ihren Geth-Client ein, um Daten an InfluxDB zur Erstellung einer Datenbank zu senden und mit Grafana eine Diagrammvisualisierung der Daten zu erstellen. Die manuelle Durchführung wird Ihnen helfen, den Prozess besser zu verstehen, ihn zu ändern und in verschiedenen Umgebungen bereitzustellen.
+
+## Einrichten von InfluxDB {#setting-up-influxdb}
+
+Lassen Sie uns zunächst InfluxDB herunterladen und installieren. Verschiedene Download-Optionen finden Sie auf der [Influxdata-Release-Seite](https://portal.influxdata.com/downloads/). Wählen Sie die für Ihre Umgebung passende aus.
+Sie können es auch aus einem [Repository](https://repos.influxdata.com/) installieren. Zum Beispiel in einer Debian-basierten Distribution:
+
+```
+curl -tlsv1.3 --proto =https -sL https://repos.influxdata.com/influxdb.key | sudo apt-key add
+source /etc/lsb-release
+echo "deb https://repos.influxdata.com/${DISTRIB_ID,,} ${DISTRIB_CODENAME} stable" | sudo tee /etc/apt/sources.list.d/influxdb.list
+sudo apt update
+sudo apt install influxdb -y
+sudo systemctl enable influxdb
+sudo systemctl start influxdb
+sudo apt install influxdb-client
+```
+
+Nach der erfolgreichen Installation von InfluxDB, stellen Sie sicher, dass es im Hintergrund läuft. Standardmäßig ist es unter `localhost:8086` erreichbar.
+Bevor Sie den `Influx`-Client verwenden, müssen Sie einen neuen Benutzer mit Administratorrechten erstellen. Dieser Benutzer dient der übergeordneten Verwaltung, der Erstellung von Datenbanken und Benutzern.
+
+```
+curl -XPOST "http://localhost:8086/query" --data-urlencode "q=CREATE USER username WITH PASSWORD 'password' WITH ALL PRIVILEGES"
+```
+
+Jetzt können Sie den Influx-Client verwenden, um mit diesem Benutzer die [InfluxDB-Shell](https://docs.influxdata.com/influxdb/v1.8/tools/shell/) zu betreten.
+
+```
+influx -username 'username' -password 'password'
+```
+
+Indem Sie direkt mit InfluxDB in seiner Shell kommunizieren, können Sie eine Datenbank und einen Benutzer für Geth-Metriken erstellen.
+
+```
+create database geth
+create user geth with password choosepassword
+```
+
+Überprüfen Sie die erstellten Einträge mit:
+
+```
+show databases
+show users
+```
+
+Verlassen Sie die InfluxDB-Shell.
+
+```
+exit
+```
+
+InfluxDB läuft und ist konfiguriert, um Metriken von Geth zu speichern.
+
+## Geth vorbereiten {#preparing-geth}
+
+Nachdem die Datenbank eingerichtet ist, müssen wir die Metrikerfassung in Geth aktivieren. Achten Sie auf `METRICS AND STATS OPTIONS` in `geth --help`. Dort finden Sie mehrere Optionen, in diesem Fall möchten wir, dass Geth Daten in InfluxDB pusht.
+Die Grundeinrichtung gibt den Endpunkt an, an dem InfluxDB erreichbar ist, und die Authentifizierung für die Datenbank.
+
+```
+geth --metrics --metrics.influxdb --metrics.influxdb.endpoint "http://0.0.0.0:8086" --metrics.influxdb.username "geth" --metrics.influxdb.password "chosenpassword"
+```
+
+Diese Flags können an einen Befehl zum Starten des Clients angehängt oder in der Konfigurationsdatei gespeichert werden.
+
+Sie können überprüfen, ob Geth erfolgreich Daten pusht, indem Sie zum Beispiel die Metriken in der Datenbank auflisten. In der InfluxDB-Shell:
+
+```
+use geth
+show measurements
+```
+
+## Einrichten von Grafana {#setting-up-grafana}
+
+Der nächste Schritt ist die Installation von Grafana, das die Daten grafisch interpretieren wird. Folgen Sie dem Installationsprozess für Ihre Umgebung in der Grafana-Dokumentation. Stellen Sie sicher, dass Sie die OSS-Version installieren, wenn nicht anders gewünscht.
+Beispielhafte Installationsschritte für Debian-Distributionen unter Verwendung des Repositorys:
+
+```
+curl -tlsv1.3 --proto =https -sL https://packages.grafana.com/gpg.key | sudo apt-key add -
+echo "deb https://packages.grafana.com/oss/deb stable main" | sudo tee -a /etc/apt/sources.list.d/grafana.list
+sudo apt update
+sudo apt install grafana
+sudo systemctl enable grafana-server
+sudo systemctl start grafana-server
+```
+
+Wenn Grafana läuft, sollte es unter `localhost:3000` erreichbar sein.
+Verwenden Sie Ihren bevorzugten Browser, um auf diesen Pfad zuzugreifen, und melden Sie sich dann mit den Standard-Anmeldeinformationen an (Benutzer: `admin` und Passwort: `admin`). Wenn Sie dazu aufgefordert werden, ändern Sie das Standardpasswort und speichern Sie es.
+
+
+
+Sie werden zur Grafana-Startseite weitergeleitet. Richten Sie zunächst Ihre Quelldaten ein. Klicken Sie auf das Konfigurationssymbol in der linken Leiste und wählen Sie "Datenquellen" aus.
+
+
+
+Es sind noch keine Datenquellen erstellt worden. Klicken Sie auf "Datenquelle hinzufügen", um eine zu definieren.
+
+
+
+Wählen Sie für dieses Setup "InfluxDB" aus und fahren Sie fort.
+
+
+
+Die Konfiguration der Datenquelle ist ziemlich einfach, wenn Sie die Tools auf demselben Rechner ausführen. Sie müssen die InfluxDB-Adresse und die Details für den Zugriff auf die Datenbank festlegen. Beachten Sie die Abbildung unten.
+
+
+
+Wenn alles vollständig ist und InfluxDB erreichbar ist, klicken Sie auf "Speichern und testen" und warten Sie, bis die Bestätigung erscheint.
+
+
+
+Grafana ist jetzt so eingerichtet, dass es Daten aus InfluxDB lesen kann. Jetzt müssen Sie ein Dashboard erstellen, das sie interpretiert und anzeigt. Dashboard-Eigenschaften sind in JSON-Dateien kodiert, die von jedermann erstellt und einfach importiert werden können. Klicken Sie in der linken Leiste auf "Erstellen und Importieren".
+
+
+
+Für ein Geth-Überwachungs-Dashboard kopieren Sie die ID von [diesem Dashboard](https://grafana.com/grafana/dashboards/13877/) und fügen Sie sie auf der "Importseite" in Grafana ein. Nach dem Speichern des Dashboards sollte es so aussehen:
+
+
+
+Sie können Ihre Dashboards ändern. Jedes Panel kann bearbeitet, verschoben, entfernt oder hinzugefügt werden. Sie können Ihre Konfigurationen ändern. Es liegt ganz bei Ihnen! Um mehr darüber zu erfahren, wie Dashboards funktionieren, lesen Sie die [Dokumentation von Grafana](https://grafana.com/docs/grafana/latest/dashboards/).
+Sie könnten auch an [Alerting](https://grafana.com/docs/grafana/latest/alerting/) interessiert sein. Damit können Sie Warnmeldungen für den Fall einrichten, dass Metriken bestimmte Werte erreichen. Verschiedene Kommunikationskanäle werden unterstützt.
diff --git a/public/content/translations/de/developers/tutorials/nft-minter/index.md b/public/content/translations/de/developers/tutorials/nft-minter/index.md
new file mode 100644
index 00000000000..639817b074a
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/nft-minter/index.md
@@ -0,0 +1,876 @@
+---
+title: NFT-Minter Tutorial
+description: In diesem Tutorial erstellst du einen NFT-Minter und lernst, wie man eine Full-Stack-Dapp erstellt, indem du deinen Smart Contract mit einem React-Frontend unter Verwendung von MetaMask und Web3-Tools verbindest.
+author: "smudgil"
+tags:
+ [
+ "solidity",
+ "NFT",
+ "Alchemy",
+ "Smart Contracts",
+ "Frontend",
+ "Pinata"
+ ]
+skill: intermediate
+lang: de
+published: 2021-10-06
+---
+
+Eine der größten Herausforderungen für Entwickler mit einem Web2-Hintergrund ist herauszufinden, wie sie ihren Smart Contract mit einem Frontend Projekt verbinden und mit ihm interagieren können.
+
+Durch den Bau eines NFT-Minters - eine einfache Benutzeroberfläche, auf welcher ein Link den Nutzer zu seinen digitalen Vermögenswerten führt, ein Titel und eine Beschreibung - werden Sie Folgendes lernen:
+
+- Verbinden von MetaMask mit Ihrem Frontend-Projekt
+- Rufen von Smart-Contract Methoden von Ihrem Frontend
+- Transaktionen mit MetaMask signieren
+
+In diesem Tutorial werden wir [React](https://react.dev/) als unser Frontend-Framework verwenden. Da sich dieses Tutorial in erster Linie auf die Web3-Entwicklung konzentriert, werden wir nicht viel Zeit darauf verwenden, die React Grundlagen zu behandeln. Stattdessen konzentrieren wir uns darauf, Funktionalität in unser Projekt zu bringen.
+
+Als Voraussetzung solltest du ein grundlegendes Verständnis von React haben – du solltest wissen, wie Komponenten, Props, useState/useEffect und grundlegende Funktionsaufrufe funktionieren. Wenn du noch nie von diesen Begriffen gehört hast, solltest du dir dieses [Einführungstutorial zu React](https://react.dev/learn/tutorial-tic-tac-toe) ansehen. Für diejenigen, die eher visuell lernen, empfehlen wir diese ausgezeichnete Videoreihe [Full Modern React Tutorial](https://www.youtube.com/playlist?list=PL4cUxeGkcC9gZD-Tvwfod2gaISzfRiP9d) von Net Ninja.
+
+Und wenn Sie sich noch nicht angemeldet haben, dann benötigen Sie auf jeden Fall einen Alchemy Account, um dieses Tutorial zu beenden und um etwas auf der Blockchain bauen zu können. Registriere dich [hier](https://alchemy.com/) für ein kostenloses Konto.
+
+Lass uns ohne weiteres starten!
+
+## NFTs erstellen 101 {#making-nfts-101}
+
+Bevor wir uns überhaupt einen Code anschauen, ist es wichtig zu verstehen, wie das erstellen von NFTs überhaupt funktioniert. Es benötigt dafür zwei Schritte:
+
+### Einen NFT-Smart-Contract auf der Ethereum-Blockchain veröffentlichen {#publish-nft}
+
+Der größte Unterschied zwischen den beiden NFT smart Kontrakt Standards ist, dass der ERC-1155 ein Multi-Token Standard ist und eine Handvoll Funktionalitäten beinhaltet, wobei man mit dem ERC-721, welcher ein Single-Token Standard ist, nur eine Token-Transaktion gleichzeitig ausführen kann.
+
+### Die Minting-Funktion aufrufen {#minting-function}
+
+Normalerweise verlangt diese Minting-Funktion, dass du zwei Variablen als Parameter übergibst: erstens den `recipient` (Empfänger), der die Adresse angibt, die deinen frisch geminteten NFT erhält, und zweitens die `tokenURI` des NFTs, eine Zeichenfolge, die zu einem JSON-Dokument aufgelöst wird, das die Metadaten des NFTs beschreibt.
+
+Die NFT Metadaten sind das, was Leben hineinbringt, welches Ihnen erlaubt Eigenschaften zu haben, wie zum Beispiel: Namen, eine Beschreibung, ein Bild (oder andere digitale Vermögenswerte), und andere Attribute. [Hier ist ein Beispiel für eine tokenURI](https://gateway.pinata.cloud/ipfs/QmSvBcb4tjdFpajGJhbFAWeK3JAxCdNQLQtr6ZdiSi42V2), die die Metadaten eines NFT enthält.
+
+In diesem Tutorial werden wir uns auf den 2 Teil fokussieren, das Aufrufen von einer bereits existierenden NFT smart Kontrakt Prägungs Funktion, indem wir unsere React UI benutzen.
+
+[Hier ist ein Link](https://ropsten.etherscan.io/address/0x4C4a07F737Bf57F6632B6CAB089B78f62385aCaE) zu dem ERC-721-NFT-Smart-Contract, den wir in diesem Tutorial aufrufen werden. Wenn du lernen möchtest, wie wir ihn erstellt haben, empfehlen wir dir dringend unser anderes Tutorial [„Wie man einen NFT erstellt“](https://www.alchemy.com/docs/how-to-create-an-nft).
+
+Cool, nun verstehen wir wie die Erstellung von NFTS funktioniert, lass uns nun unsere Startdateien klonen!
+
+## Die Starter-Dateien klonen {#clone-the-starter-files}
+
+Gehe zuerst zum [nft-minter-tutorial GitHub-Repository](https://github.com/alchemyplatform/nft-minter-tutorial), um die Starter-Dateien für dieses Projekt zu erhalten. Klone dieses Repository in deine lokale Umgebung.
+
+Wenn du dieses geklonte `nft-minter-tutorial`-Repository öffnest, wirst du feststellen, dass es zwei Ordner enthält: `minter-starter-files` und `nft-minter`.
+
+- `minter-starter-files` enthält die Starter-Dateien (im Wesentlichen die React-UI) für dieses Projekt. In diesem Tutorial **werden wir in diesem Verzeichnis arbeiten**, während du lernst, wie du diese Benutzeroberfläche zum Leben erweckst, indem du sie mit deiner Ethereum-Wallet und einem NFT-Smart-Contract verbindest.
+- `nft-minter` enthält das gesamte, vollständige Tutorial und dient dir als **Referenz**, **falls du nicht weiterkommst.**
+
+Öffne als Nächstes deine Kopie von `minter-starter-files` in deinem Code-Editor und navigiere dann in deinen `src`-Ordner.
+
+Der gesamte Code, den wir schreiben werden, befindet sich im Ordner `src`. Wir werden die `Minter.js`-Komponente bearbeiten und zusätzliche JavaScript-Dateien schreiben, um unserem Projekt Web3-Funktionalität zu verleihen.
+
+## Schritt 2: Unsere Starter-Dateien ansehen {#step-2-check-out-our-starter-files}
+
+Bevor wir mit dem Programmieren beginnen, ist es wichtig, sich anzusehen, was uns in den Starter-Dateien bereits zur Verfügung gestellt wird.
+
+### Dein React-Projekt zum Laufen bringen {#get-your-react-project-running}
+
+Beginnen wir damit, das React-Projekt in unserem Browser auszuführen. Das Schöne an React ist, dass alle Änderungen, die wir speichern, live in unserem Browser aktualisiert werden, sobald unser Projekt im Browser läuft.
+
+Um das Projekt zum Laufen zu bringen, navigiere zum Stammverzeichnis des Ordners `minter-starter-files` und führe `npm install` in deinem Terminal aus, um die Abhängigkeiten des Projekts zu installieren:
+
+```bash
+cd minter-starter-files
+npm install
+```
+
+Sobald die Installation abgeschlossen ist, führe `npm start` in deinem Terminal aus:
+
+```bash
+npm start
+```
+
+Dadurch sollte sich http://localhost:3000/ in deinem Browser öffnen, wo du das Frontend für unser Projekt siehst. Es sollte aus 3 Feldern bestehen: einem Feld zur Eingabe eines Links zum Asset deines NFTs, einem Feld zur Eingabe des Namens deines NFTs und einem Feld zur Angabe einer Beschreibung.
+
+Wenn du versuchst, auf die Schaltflächen „Wallet verbinden“ oder „NFT minten“ zu klicken, wirst du feststellen, dass sie nicht funktionieren – das liegt daran, dass wir ihre Funktionalität noch programmieren müssen! :\)
+
+### Die Minter.js-Komponente {#minter-js}
+
+**HINWEIS:** Stelle sicher, dass du dich im Ordner `minter-starter-files` und nicht im Ordner `nft-minter` befindest!
+
+Gehen wir zurück in den `src`-Ordner in unserem Editor und öffnen die Datei `Minter.js`. Es ist sehr wichtig, dass wir alles in dieser Datei verstehen, da es sich um die primäre React-Komponente handelt, an der wir arbeiten werden.
+
+Oben in dieser Datei befinden sich unsere Zustandsvariablen, die wir nach bestimmten Ereignissen aktualisieren werden.
+
+```javascript
+//Zustandsvariablen
+const [walletAddress, setWallet] = useState("")
+const [status, setStatus] = useState("")
+const [name, setName] = useState("")
+const [description, setDescription] = useState("")
+const [url, setURL] = useState("")
+```
+
+Noch nie von React-Zustandsvariablen oder State-Hooks gehört? Sieh dir [diese](https://legacy.reactjs.org/docs/hooks-state.html) Dokumentation an.
+
+Hier ist, was die einzelnen Variablen darstellen:
+
+- `walletAddress` - eine Zeichenfolge, die die Wallet-Adresse des Benutzers speichert
+- `status` - eine Zeichenfolge, die eine Nachricht enthält, die am unteren Rand der Benutzeroberfläche angezeigt wird
+- `name` - eine Zeichenfolge, die den Namen des NFT speichert
+- `description` - eine Zeichenfolge, die die Beschreibung des NFT speichert
+- `url` - eine Zeichenfolge, die ein Link zum digitalen Asset des NFT ist
+
+Nach den Zustandsvariablen siehst du drei nicht implementierte Funktionen: `useEffect`, `connectWalletPressed` und `onMintPressed`. Du wirst feststellen, dass alle diese Funktionen `async` sind, weil wir in ihnen asynchrone API-Aufrufe tätigen werden! Ihre Namen sind gleichbedeutend mit ihren Funktionalitäten:
+
+```javascript
+useEffect(async () => {
+ //TODO: implementieren
+}, [])
+
+const connectWalletPressed = async () => {
+ //TODO: implementieren
+}
+
+const onMintPressed = async () => {
+ //TODO: implementieren
+}
+```
+
+- [`useEffect`](https://legacy.reactjs.org/docs/hooks-effect.html) – dies ist ein React-Hook, der aufgerufen wird, nachdem deine Komponente gerendert wurde. Da ihm ein leeres Array `[]` als Prop übergeben wird (siehe Zeile 3), wird er nur beim _ersten_ Rendern der Komponente aufgerufen. Hier rufen wir unseren Wallet-Listener und eine weitere Wallet-Funktion auf, um unsere Benutzeroberfläche zu aktualisieren und anzuzeigen, ob eine Wallet bereits verbunden ist.
+- `connectWalletPressed` – diese Funktion wird aufgerufen, um die MetaMask-Wallet des Benutzers mit unserer Dapp zu verbinden.
+- `onMintPressed` – diese Funktion wird aufgerufen, um den NFT des Benutzers zu minten.
+
+Gegen Ende dieser Datei haben wir die Benutzeroberfläche unserer Komponente. Wenn du diesen Code sorgfältig durchgehst, wirst du feststellen, dass wir unsere `url`-, `name`- und `description`-Zustandsvariablen aktualisieren, wenn sich die Eingabe in den entsprechenden Textfeldern ändert.
+
+Du wirst auch sehen, dass `connectWalletPressed` und `onMintPressed` aufgerufen werden, wenn die Schaltflächen mit den IDs `mintButton` bzw. `walletButton` angeklickt werden.
+
+```javascript
+//die Benutzeroberfläche unserer Komponente
+return (
+
+
+
+
+ 🧙♂️ Alchemy NFT Minter
+
+ Füge einfach den Link, den Namen und die Beschreibung deines Assets hinzu und drücke dann auf „Minten“.
+
+
+
+ {status}
+
+)
+```
+
+Schließlich wollen wir uns ansehen, wo diese Minter-Komponente hinzugefügt wird.
+
+Wenn du zur Datei `App.js` gehst, der Hauptkomponente in React, die als Container für alle anderen Komponenten fungiert, siehst du, dass unsere Minter-Komponente in Zeile 7 eingefügt wird.
+
+**In diesem Tutorial werden wir nur die `Minter.js`-Datei bearbeiten und Dateien in unserem `src`-Ordner hinzufügen.**
+
+Nachdem wir nun verstanden haben, womit wir arbeiten, richten wir unsere Ethereum-Wallet ein!
+
+## Richte deine Ethereum-Wallet ein {#set-up-your-ethereum-wallet}
+
+Damit Benutzer mit deinem Smart Contract interagieren können, müssen sie ihre Ethereum-Wallet mit deiner Dapp verbinden.
+
+### MetaMask herunterladen {#download-metamask}
+
+In diesem Tutorial verwenden wir MetaMask, eine virtuelle Wallet im Browser, mit der Sie Ihre Ethereum-Kontoadresse verwalten können. Wenn du mehr darüber erfahren möchtest, wie Transaktionen auf Ethereum funktionieren, sieh dir [diese Seite](/developers/docs/transactions/) an.
+
+Sie können MetaMask [hier](https://metamask.io/download) kostenlos herunterladen und ein Konto erstellen. Wenn du ein Konto erstellst oder bereits eines hast, wechsle unbedingt zum „Ropsten Test Network“ oben rechts (damit wir nicht mit echtem Geld hantieren).
+
+### Ether von einem Faucet hinzufügen {#add-ether-from-faucet}
+
+Um unsere NFTs zu minten (oder Transaktionen auf der Ethereum-Blockchain zu signieren), benötigen wir einige gefälschte ETH. Um ETH zu erhalten, kannst du zum [Ropsten-Faucet](https://faucet.ropsten.be/) gehen und deine Ropsten-Kontoadresse eingeben und dann auf „Send Ropsten ETH“ klicken. Kurz darauf solltest du ETH in deinem MetaMask-Konto sehen!
+
+### Deinen Kontostand überprüfen {#check-your-balance}
+
+Um zu überprüfen, ob unser Guthaben vorhanden ist, machen wir eine [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance)-Anfrage mit dem [Composer-Tool von Alchemy](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D). Dies gibt den Betrag an ETH in unserer Wallet zurück. Nachdem Sie die Adresse Ihres MetaMask-Kontos eingegeben und auf “Send Request” (Anforderung senden) geklickt haben, sollten Sie eine Antwort ähnlich der Folgenden erhalten:
+
+```text
+{"jsonrpc": "2.0", "id": 0, "result": "0xde0b6b3a7640000"}
+```
+
+**HINWEIS:** Dieses Ergebnis ist in Wei, nicht in ETH. Wei ist die kleinste Einheit von Ether. Die Umrechnung von Wei in ETH ist: 1 ETH = 10¹⁸ Wei. Wenn wir also 0xde0b6b3a7640000 in eine Dezimalzahl umwandeln, erhalten wir 1\*10¹⁸, was 1 ETH entspricht.
+
+Puh! Unser Falschgeld ist da!
+ {" "}
+ 🦊
+ Du musst MetaMask, eine virtuelle Ethereum-Wallet, in deinem
+ Browser installieren.
+
+
+
+ ),
+ }
+ }
+}
+```
+
+Schauen wir uns an, was dieser Code bewirkt:
+
+Zuerst prüft unsere Funktion, ob `window.ethereum` in deinem Browser aktiviert ist.
+
+`window.ethereum` ist eine globale API, die von MetaMask und anderen Wallet-Anbietern eingeschleust wird und es Websites ermöglicht, die Ethereum-Konten von Benutzern anzufordern. Wenn dies genehmigt wird, kann sie Daten aus den Blockchains lesen, mit denen der Benutzer verbunden ist, und dem Benutzer vorschlagen, Nachrichten und Transaktionen zu signieren. Weitere Informationen findest du in der [MetaMask-Dokumentation](https://docs.metamask.io/guide/ethereum-provider.html#table-of-contents)!
+
+Wenn `window.ethereum` _nicht_ vorhanden ist, bedeutet das, dass MetaMask nicht installiert ist. Dies führt dazu, dass ein JSON-Objekt zurückgegeben wird, bei dem die zurückgegebene `address` eine leere Zeichenfolge ist und das `status`-JSX-Objekt meldet, dass der Benutzer MetaMask installieren muss.
+
+**Die meisten Funktionen, die wir schreiben, geben JSON-Objekte zurück, mit denen wir unsere Zustandsvariablen und die Benutzeroberfläche aktualisieren können.**
+
+Wenn `window.ethereum` jedoch vorhanden _ist_, dann wird es interessant.
+
+Mithilfe einer try/catch-Schleife versuchen wir, eine Verbindung zu MetaMask herzustellen, indem wir [`window.ethereum.request({ method: "eth_requestAccounts" });`](https://docs.metamask.io/guide/rpc-api.html#eth-requestaccounts) aufrufen. Der Aufruf dieser Funktion öffnet MetaMask im Browser, woraufhin der Benutzer aufgefordert wird, seine Wallet mit deiner Dapp zu verbinden.
+
+- Wenn der Benutzer die Verbindung herstellt, gibt `method: "eth_requestAccounts"` ein Array zurück, das alle Adressen der Benutzerkonten enthält, die mit der Dapp verbunden sind. Insgesamt gibt unsere `connectWallet`-Funktion ein JSON-Objekt zurück, das die _erste_ `address` in diesem Array (siehe Zeile 9) und eine `status`-Nachricht enthält, die den Benutzer auffordert, eine Nachricht an den Smart Contract zu schreiben.
+- Wenn der Benutzer die Verbindung ablehnt, enthält das JSON-Objekt eine leere Zeichenfolge für die zurückgegebene `address` und eine `status`-Nachricht, die widerspiegelt, dass der Benutzer die Verbindung abgelehnt hat.
+
+### Hinzufügen der connectWallet-Funktion zur Minter.js-UI-Komponente {#add-connect-wallet}
+
+Nachdem wir diese `connectWallet`-Funktion geschrieben haben, verbinden wir sie mit unserer `Minter.js.`-Komponente.
+
+Zuerst müssen wir unsere Funktion in unsere `Minter.js`-Datei importieren, indem wir `import { connectWallet } from "./utils/interact.js";` am Anfang der `Minter.js`-Datei hinzufügen. Deine ersten 11 Zeilen von `Minter.js` sollten nun so aussehen:
+
+```javascript
+import { useEffect, useState } from "react";
+import { connectWallet } from "./utils/interact.js";
+
+const Minter = (props) => {
+
+ //Zustandsvariablen
+ const [walletAddress, setWallet] = useState("");
+ const [status, setStatus] = useState("");
+ const [name, setName] = useState("");
+ const [description, setDescription] = useState("");
+ const [url, setURL] = useState("");
+```
+
+Dann rufen wir in unserer `connectWalletPressed`-Funktion unsere importierte `connectWallet`-Funktion auf, wie folgt:
+
+```javascript
+const connectWalletPressed = async () => {
+ const walletResponse = await connectWallet()
+ setStatus(walletResponse.status)
+ setWallet(walletResponse.address)
+}
+```
+
+Fällt dir auf, wie der größte Teil unserer Funktionalität von unserer `Minter.js`-Komponente in die `interact.js`-Datei abstrahiert wird? Dies geschieht, damit wir dem M-V-C-Paradigma entsprechen!
+
+In `connectWalletPressed` machen wir einfach einen Await-Aufruf an unsere importierte `connectWallet`-Funktion, und mit ihrer Antwort aktualisieren wir unsere `status`- und `walletAddress`-Variablen über ihre State-Hooks.
+
+Speichern wir nun beide Dateien, `Minter.js` und `interact.js`, und testen unsere Benutzeroberfläche.
+
+Öffne deinen Browser unter localhost:3000 und drücke die Schaltfläche „Wallet verbinden“ oben rechts auf der Seite.
+
+Wenn du MetaMask installiert hast, solltest du aufgefordert werden, deine Wallet mit deiner Dapp zu verbinden. Akzeptiere die Aufforderung, eine Verbindung herzustellen.
+
+Du solltest sehen, dass die Wallet-Schaltfläche nun anzeigt, dass deine Adresse verbunden ist.
+
+Als Nächstes versuche, die Seite neu zu laden ... Das ist seltsam. Unsere Wallet-Schaltfläche fordert uns auf, MetaMask zu verbinden, obwohl es bereits verbunden ist ...
+
+Aber keine Sorge! Das können wir leicht beheben, indem wir eine Funktion namens `getCurrentWalletConnected` implementieren, die prüft, ob eine Adresse bereits mit unserer Dapp verbunden ist, und unsere Benutzeroberfläche entsprechend aktualisiert!
+
+### Die getCurrentWalletConnected-Funktion {#get-current-wallet}
+
+Füge in deine `interact.js`-Datei die folgende `getCurrentWalletConnected`-Funktion ein:
+
+```javascript
+export const getCurrentWalletConnected = async () => {
+ if (window.ethereum) {
+ try {
+ const addressArray = await window.ethereum.request({
+ method: "eth_accounts",
+ })
+ if (addressArray.length > 0) {
+ return {
+ address: addressArray[0],
+ status: "👆🏽 Schreibe eine Nachricht in das Textfeld oben.",
+ }
+ } else {
+ return {
+ address: "",
+ status: "🦊 Verbinde dich mit MetaMask über die Schaltfläche oben rechts.",
+ }
+ }
+ } catch (err) {
+ return {
+ address: "",
+ status: "😥 " + err.message,
+ }
+ }
+ } else {
+ return {
+ address: "",
+ status: (
+
+
+ {" "}
+ 🦊
+ Du musst MetaMask, eine virtuelle Ethereum-Wallet, in deinem
+ Browser installieren.
+
+
+
+ ),
+ }
+ }
+}
+```
+
+Dieser Code ist der `connectWallet`-Funktion, die wir gerade geschrieben haben, _sehr_ ähnlich.
+
+Der Hauptunterschied besteht darin, dass wir anstelle der Methode `eth_requestAccounts`, die MetaMask für den Benutzer öffnet, um seine Wallet zu verbinden, hier die Methode `eth_accounts` aufrufen, die einfach ein Array zurückgibt, das die MetaMask-Adressen enthält, die derzeit mit unserer Dapp verbunden sind.
+
+Um diese Funktion in Aktion zu sehen, rufen wir sie in der `useEffect`-Funktion unserer `Minter.js`-Komponente auf.
+
+Wie bei `connectWallet` müssen wir diese Funktion aus unserer `interact.js`-Datei in unsere `Minter.js`-Datei importieren, und zwar so:
+
+```javascript
+import { useEffect, useState } from "react"
+import {
+ connectWallet,
+ getCurrentWalletConnected, //hier importieren
+} from "./utils/interact.js"
+```
+
+Jetzt rufen wir sie einfach in unserer `useEffect`-Funktion auf:
+
+```javascript
+useEffect(async () => {
+ const { address, status } = await getCurrentWalletConnected()
+ setWallet(address)
+ setStatus(status)
+}, [])
+```
+
+Beachte, dass wir die Antwort unseres Aufrufs an `getCurrentWalletConnected` verwenden, um unsere `walletAddress`- und `status`-Zustandsvariablen zu aktualisieren.
+
+Nachdem du diesen Code hinzugefügt hast, versuche, unser Browserfenster zu aktualisieren. Die Schaltfläche sollte anzeigen, dass du verbunden bist, und eine Vorschau der Adresse deiner verbundenen Wallet anzeigen – auch nach dem Aktualisieren!
+
+### addWalletListener implementieren {#implement-add-wallet-listener}
+
+Der letzte Schritt in der Einrichtung unserer Dapp-Wallet ist die Implementierung des Wallet-Listeners, damit unsere Benutzeroberfläche aktualisiert wird, wenn sich der Zustand unserer Wallet ändert, z. B. wenn der Benutzer die Verbindung trennt oder das Konto wechselt.
+
+Füge in deine `Minter.js`-Datei eine Funktion `addWalletListener` hinzu, die wie folgt aussieht:
+
+```javascript
+function addWalletListener() {
+ if (window.ethereum) {
+ window.ethereum.on("accountsChanged", (accounts) => {
+ if (accounts.length > 0) {
+ setWallet(accounts[0])
+ setStatus("👆🏽 Schreibe eine Nachricht in das Textfeld oben.")
+ } else {
+ setWallet("")
+ setStatus("🦊 Verbinde dich mit MetaMask über die Schaltfläche oben rechts.")
+ }
+ })
+ } else {
+ setStatus(
+
+ {" "}
+ 🦊
+ Du musst MetaMask, eine virtuelle Ethereum-Wallet, in deinem Browser installieren.
+
+
+ )
+ }
+}
+```
+
+Lass uns kurz aufschlüsseln, was hier passiert:
+
+- Zuerst prüft unsere Funktion, ob `window.ethereum` aktiviert ist (d. h. MetaMask ist installiert).
+ - Wenn nicht, setzen wir einfach unsere `status`-Zustandsvariable auf eine JSX-Zeichenfolge, die den Benutzer auffordert, MetaMask zu installieren.
+ - Wenn es aktiviert ist, richten wir den Listener `window.ethereum.on("accountsChanged")` in Zeile 3 ein, der auf Zustandsänderungen in der MetaMask-Wallet lauscht. Dazu gehören, wenn der Benutzer ein zusätzliches Konto mit der Dapp verbindet, Konten wechselt oder ein Konto trennt. Wenn mindestens ein Konto verbunden ist, wird die Zustandsvariable `walletAddress` als das erste Konto im `accounts`-Array aktualisiert, das vom Listener zurückgegeben wird. Andernfalls wird `walletAddress` als leere Zeichenfolge festgelegt.
+
+Schließlich müssen wir sie in unserer `useEffect`-Funktion aufrufen:
+
+```javascript
+useEffect(async () => {
+ const { address, status } = await getCurrentWalletConnected()
+ setWallet(address)
+ setStatus(status)
+
+ addWalletListener()
+}, [])
+```
+
+Und voilà! Wir haben die Programmierung all unserer Wallet-Funktionalitäten abgeschlossen! Nachdem unsere Wallet nun eingerichtet ist, finden wir heraus, wie wir unser NFT minten können!
+
+## NFT-Metadaten 101 {#nft-metadata-101}
+
+Erinnerst du dich an die NFT-Metadaten, über die wir in Schritt 0 dieses Tutorials gesprochen haben? Sie erwecken einen NFT zum Leben und ermöglichen es ihm, Eigenschaften wie ein digitales Asset, einen Namen, eine Beschreibung und andere Attribute zu haben.
+
+Wir müssen diese Metadaten als JSON-Objekt konfigurieren und speichern, damit wir sie als `tokenURI`-Parameter übergeben können, wenn wir die `mintNFT`-Funktion unseres Smart Contracts aufrufen.
+
+Der Text in den Feldern „Link zum Asset“, „Name“, „Beschreibung“ wird die verschiedenen Eigenschaften der Metadaten unseres NFTs umfassen. Wir werden diese Metadaten als JSON-Objekt formatieren, aber es gibt ein paar Optionen, wo wir dieses JSON-Objekt speichern können:
+
+- Wir könnten sie auf der Ethereum-Blockchain speichern, was jedoch sehr teuer wäre.
+- Wir könnten sie auf einem zentralisierten Server wie AWS oder Firebase speichern. Aber das würde unserem Dezentralisierungs-Ethos widersprechen.
+- Wir könnten IPFS verwenden, ein dezentralisiertes Protokoll und Peer-to-Peer-Netzwerk zum Speichern und Teilen von Daten in einem verteilten Dateisystem. Da dieses Protokoll dezentralisiert und kostenlos ist, ist es unsere beste Option!
+
+Um unsere Metadaten auf IPFS zu speichern, verwenden wir [Pinata](https://pinata.cloud/), eine praktische IPFS-API und ein Toolkit. Im nächsten Schritt erklären wir genau, wie das geht!
+
+## Pinata verwenden, um deine Metadaten auf IPFS zu pinnen {#use-pinata-to-pin-your-metadata-to-IPFS}
+
+Wenn du noch kein [Pinata](https://pinata.cloud/)-Konto hast, registriere dich [hier](https://app.pinata.cloud/auth/signup) für ein kostenloses Konto und führe die Schritte zur Verifizierung deiner E-Mail und deines Kontos durch.
+
+### Erstelle deinen Pinata-API-Schlüssel {#create-pinata-api-key}
+
+Navigiere zur Seite [https://pinata.cloud/keys](https://pinata.cloud/keys), wähle dann oben die Schaltfläche „New Key“ (Neuer Schlüssel), setze das Admin-Widget auf „Enabled“ (Aktiviert) und benenne deinen Schlüssel.
+
+Dir wird dann ein Popup mit deinen API-Informationen angezeigt. Bewahre diese an einem sicheren Ort auf.
+
+Nachdem unser Schlüssel nun eingerichtet ist, fügen wir ihn zu unserem Projekt hinzu, damit wir ihn verwenden können.
+
+### Eine .env-Datei erstellen {#create-a-env}
+
+Wir können unseren Pinata-Schlüssel und das Geheimnis sicher in einer Umgebungsdatei speichern. Installieren wir das [dotenv-Paket](https://www.npmjs.com/package/dotenv) in deinem Projektverzeichnis.
+
+Öffne einen neuen Tab in deinem Terminal (getrennt von dem, auf dem der Localhost läuft) und stelle sicher, dass du dich im Ordner `minter-starter-files` befindest. Führe dann den folgenden Befehl in deinem Terminal aus:
+
+```text
+npm install dotenv --save
+```
+
+Als Nächstes erstelle eine `.env`-Datei im Stammverzeichnis deiner `minter-starter-files`, indem du Folgendes in deiner Befehlszeile eingibst:
+
+```javascript
+vim.env
+```
+
+Dadurch wird deine `.env`-Datei in vim (einem Texteditor) geöffnet. Um sie zu speichern, drücke „esc“ + „:“ + „q“ in dieser Reihenfolge auf deiner Tastatur.
+
+Navigiere als Nächstes in VSCode zu deiner `.env`-Datei und füge deinen Pinata-API-Schlüssel und dein API-Geheimnis hinzu, und zwar so:
+
+```text
+REACT_APP_PINATA_KEY =
+REACT_APP_PINATA_SECRET =
+```
+
+Speichere die Datei, und dann kannst du damit beginnen, die Funktion zum Hochladen deiner JSON-Metadaten auf IPFS zu schreiben!
+
+### pinJSONToIPFS implementieren {#pin-json-to-ipfs}
+
+Glücklicherweise hat Pinata eine [API speziell für das Hochladen von JSON-Daten auf IPFS](https://docs.pinata.cloud/api-reference/endpoint/ipfs/pin-json-to-ipfs#pin-json) und ein praktisches JavaScript-Beispiel mit Axios, das wir mit leichten Änderungen verwenden können.
+
+Erstellen wir in deinem `utils`-Ordner eine weitere Datei namens `pinata.js` und importieren dann unser Pinata-Geheimnis und den Schlüssel aus der .env-Datei wie folgt:
+
+```javascript
+require("dotenv").config()
+const key = process.env.REACT_APP_PINATA_KEY
+const secret = process.env.REACT_APP_PINATA_SECRET
+```
+
+Füge als Nächstes den zusätzlichen Code von unten in deine `pinata.js`-Datei ein. Keine Sorge, wir werden aufschlüsseln, was alles bedeutet!
+
+```javascript
+require("dotenv").config()
+const key = process.env.REACT_APP_PINATA_KEY
+const secret = process.env.REACT_APP_PINATA_SECRET
+
+const axios = require("axios")
+
+export const pinJSONToIPFS = async (JSONBody) => {
+ const url = `https://api.pinata.cloud/pinning/pinJSONToIPFS`
+ //axios-POST-Anfrage an Pinata stellen ⬇️
+ return axios
+ .post(url, JSONBody, {
+ headers: {
+ pinata_api_key: key,
+ pinata_secret_api_key: secret,
+ },
+ })
+ .then(function (response) {
+ return {
+ success: true,
+ pinataUrl:
+ "https://gateway.pinata.cloud/ipfs/" + response.data.IpfsHash,
+ }
+ })
+ .catch(function (error) {
+ console.log(error)
+ return {
+ success: false,
+ message: error.message,
+ }
+ })
+}
+```
+
+Was genau macht dieser Code also?
+
+Zuerst importiert er [axios](https://www.npmjs.com/package/axios), einen Promise-basierten HTTP-Client für den Browser und node.js, den wir verwenden werden, um eine Anfrage an Pinata zu stellen.
+
+Dann haben wir unsere asynchrone Funktion `pinJSONToIPFS`, die einen `JSONBody` als Eingabe und den Pinata-API-Schlüssel und das Geheimnis in ihrem Header entgegennimmt, um eine POST-Anfrage an ihre `pinJSONToIPFS`-API zu stellen.
+
+- Wenn diese POST-Anfrage erfolgreich ist, gibt unsere Funktion ein JSON-Objekt zurück, bei dem der `success`-Boole’sche Wert auf „true“ gesetzt ist und die `pinataUrl` angibt, wo unsere Metadaten angeheftet wurden. Wir werden diese zurückgegebene `pinataUrl` als `tokenURI`-Eingabe für die Mint-Funktion unseres Smart Contracts verwenden.
+- Wenn diese Post-Anfrage fehlschlägt, gibt unsere Funktion ein JSON-Objekt zurück, bei dem der `success`-Boole’sche Wert auf „false“ gesetzt ist und eine `message`-Zeichenfolge unseren Fehler weitergibt.
+
+Wie bei unseren `connectWallet`-Funktionsrückgabetypen geben wir JSON-Objekte zurück, damit wir ihre Parameter zur Aktualisierung unserer Zustandsvariablen und der Benutzeroberfläche verwenden können.
+
+## Lade deinen Smart Contract {#load-your-smart-contract}
+
+Nachdem wir nun eine Möglichkeit haben, unsere NFT-Metadaten über unsere `pinJSONToIPFS`-Funktion auf IPFS hochzuladen, benötigen wir eine Möglichkeit, eine Instanz unseres Smart Contracts zu laden, damit wir seine `mintNFT`-Funktion aufrufen können.
+
+Wie bereits erwähnt, werden wir in diesem Tutorial [diesen bestehenden NFT-Smart-Contract](https://ropsten.etherscan.io/address/0x4C4a07F737Bf57F6632B6CAB089B78f62385aCaE) verwenden. Wenn du jedoch lernen möchtest, wie wir ihn erstellt haben oder selbst einen erstellen möchtest, empfehlen wir dir dringend, unser anderes Tutorial [„Wie man einen NFT erstellt“](https://www.alchemy.com/docs/how-to-create-an-nft) anzusehen.
+
+### Das Contract-ABI {#contract-abi}
+
+Wenn du unsere Dateien genau untersucht hast, wirst du bemerkt haben, dass es in unserem `src`-Verzeichnis eine `contract-abi.json`-Datei gibt. Ein ABI ist notwendig, um anzugeben, welche Funktion ein Vertrag aufrufen wird, und um sicherzustellen, dass die Funktion Daten in dem von dir erwarteten Format zurückgibt.
+
+Wir werden auch einen Alchemy-API-Schlüssel und die Alchemy-Web3-API benötigen, um uns mit der Ethereum-Blockchain zu verbinden und unseren Smart Contract zu laden.
+
+### Erstelle deinen Alchemy-API-Schlüssel {#create-alchemy-api}
+
+Wenn du noch kein Alchemy-Konto hast, [registriere dich hier kostenlos](https://alchemy.com/?a=eth-org-nft-minter).
+
+Sobald Sie ein Alchemy-Konto erstellt haben, können Sie einen API-Schlüssel generieren. Erstellen Sie dafür eine App. Dadurch können wir Anfragen an das Ropsten-Testnet stellen.
+
+Navigiere zur Seite „App erstellen“ in deinem Alchemy-Dashboard, indem du in der Navigationsleiste über „Apps“ fährst und auf „App erstellen“ klickst.
+
+Benenne deine App – wir haben „Mein erster NFT!“ gewählt –, gib eine kurze Beschreibung, wähle „Staging“ für die Umgebung, die für die Buchführung deiner App verwendet wird, und wähle „Ropsten“ als dein Netzwerk.
+
+Klicken Sie auf “Create app” (App erstellen) und schon sind Sie fertig. Die App sollte in der untenstehenden Tabelle erscheinen.
+
+Super, jetzt, da wir unsere HTTP-Alchemy-API-URL erstellt haben, kopiere sie in deine Zwischenablage ...
+
+… und fügen wir sie zu unserer `.env`-Datei hinzu. Insgesamt sollte deine .env-Datei so aussehen:
+
+```text
+REACT_APP_PINATA_KEY =
+REACT_APP_PINATA_SECRET =
+REACT_APP_ALCHEMY_KEY = https://eth-ropsten.alchemyapi.io/v2/
+```
+
+Jetzt, da wir unser Contract-ABI und unseren Alchemy-API-Schlüssel haben, sind wir bereit, unseren Smart Contract mit [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) zu laden.
+
+### Richte deinen Alchemy-Web3-Endpunkt und deinen Vertrag ein {#setup-alchemy-endpoint}
+
+Wenn du es noch nicht hast, musst du zuerst [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) installieren, indem du im Terminal zum Stammverzeichnis navigierst: `nft-minter-tutorial`:
+
+```text
+cd ..
+npm install @alch/alchemy-web3
+```
+
+Als Nächstes kehren wir zu unserer `interact.js`-Datei zurück. Füge am Anfang der Datei den folgenden Code hinzu, um deinen Alchemy-Schlüssel aus deiner .env-Datei zu importieren und deinen Alchemy-Web3-Endpunkt einzurichten:
+
+```javascript
+require("dotenv").config()
+const alchemyKey = process.env.REACT_APP_ALCHEMY_KEY
+const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
+const web3 = createAlchemyWeb3(alchemyKey)
+```
+
+[Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) ist ein Wrapper um [Web3.js](https://docs.web3js.org/) und bietet erweiterte API-Methoden und andere entscheidende Vorteile, um dir das Leben als Web3-Entwickler zu erleichtern. Es ist so konzipiert, dass es eine minimale Konfiguration erfordert, sodass du es sofort in deiner App verwenden kannst!
+
+Als Nächstes fügen wir unser Contract-ABI und unsere Contract-Adresse zu unserer Datei hinzu.
+
+```javascript
+require("dotenv").config()
+const alchemyKey = process.env.REACT_APP_ALCHEMY_KEY
+const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
+const web3 = createAlchemyWeb3(alchemyKey)
+
+const contractABI = require("../contract-abi.json")
+const contractAddress = "0x4C4a07F737Bf57F6632B6CAB089B78f62385aCaE"
+```
+
+Sobald wir beides haben, sind wir bereit, unsere Mint-Funktion zu programmieren!
+
+## Die mintNFT-Funktion implementieren {#implement-the-mintnft-function}
+
+Definieren wir in deiner `interact.js`-Datei unsere Funktion `mintNFT`, die gleichnamig unseren NFT minten wird.
+
+Da wir zahlreiche asynchrone Aufrufe machen werden (an Pinata, um unsere Metadaten auf IPFS zu pinnen, an Alchemy Web3, um unseren Smart Contract zu laden, und an MetaMask, um unsere Transaktionen zu signieren), wird unsere Funktion ebenfalls asynchron sein.
+
+Die drei Eingaben für unsere Funktion sind die `url` unseres digitalen Assets, der `name` und die `description`. Füge die folgende Funktionssignatur unter der `connectWallet`-Funktion hinzu:
+
+```javascript
+export const mintNFT = async (url, name, description) => {}
+```
+
+### Fehlerbehandlung bei der Eingabe {#input-error-handling}
+
+Natürlich ist es sinnvoll, am Anfang der Funktion eine Art Fehlerbehandlung für die Eingabe zu haben, damit wir diese Funktion beenden, wenn unsere Eingabeparameter nicht korrekt sind. Fügen wir in unserer Funktion den folgenden Code hinzu:
+
+```javascript
+export const mintNFT = async (url, name, description) => {
+ //Fehlerbehandlung
+ if (url.trim() == "" || name.trim() == "" || description.trim() == "") {
+ return {
+ success: false,
+ status: "❗Bitte stelle sicher, dass alle Felder vor dem Minten ausgefüllt sind.",
+ }
+ }
+}
+```
+
+Im Wesentlichen, wenn einer der Eingabeparameter eine leere Zeichenfolge ist, geben wir ein JSON-Objekt zurück, bei dem der `success`-Boole'sche Wert auf „false“ gesetzt ist und die `status`-Zeichenfolge meldet, dass alle Felder in unserer Benutzeroberfläche vollständig sein müssen.
+
+### Hochladen der Metadaten auf IPFS {#upload-metadata-to-ipfs}
+
+Sobald wir wissen, dass unsere Metadaten korrekt formatiert sind, besteht der nächste Schritt darin, sie in ein JSON-Objekt zu verpacken und über die von uns geschriebene `pinJSONToIPFS`-Funktion auf IPFS hochzuladen!
+
+Dazu müssen wir zuerst die `pinJSONToIPFS`-Funktion in unsere `interact.js`-Datei importieren. Ganz oben in der `interact.js` fügen wir hinzu:
+
+```javascript
+import { pinJSONToIPFS } from "./pinata.js"
+```
+
+Erinnere dich daran, dass `pinJSONToIPFS` einen JSON-Körper entgegennimmt. Bevor wir sie aufrufen, müssen wir also unsere `url`-, `name`- und `description`-Parameter in ein JSON-Objekt formatieren.
+
+Aktualisieren wir unseren Code, um ein JSON-Objekt namens `metadata` zu erstellen und dann einen Aufruf an `pinJSONToIPFS` mit diesem `metadata`-Parameter zu machen:
+
+```javascript
+export const mintNFT = async (url, name, description) => {
+ //Fehlerbehandlung
+ if (url.trim() == "" || name.trim() == "" || description.trim() == "") {
+ return {
+ success: false,
+ status: "❗Bitte stelle sicher, dass alle Felder vor dem Minten ausgefüllt sind.",
+ }
+ }
+
+ //Metadaten erstellen
+ const metadata = new Object()
+ metadata.name = name
+ metadata.image = url
+ metadata.description = description
+
+ //Pinata-Aufruf durchführen
+ const pinataResponse = await pinJSONToIPFS(metadata)
+ if (!pinataResponse.success) {
+ return {
+ success: false,
+ status: "😢 Etwas ist beim Hochladen deiner tokenURI schiefgelaufen.",
+ }
+ }
+ const tokenURI = pinataResponse.pinataUrl
+}
+```
+
+Beachte, dass wir die Antwort unseres Aufrufs an `pinJSONToIPFS(metadata)` im `pinataResponse`-Objekt speichern. Dann analysieren wir dieses Objekt auf Fehler.
+
+Wenn ein Fehler auftritt, geben wir ein JSON-Objekt zurück, bei dem der `success`-Boole’sche Wert auf „false“ gesetzt ist und unsere `status`-Zeichenfolge meldet, dass unser Aufruf fehlgeschlagen ist. Andernfalls extrahieren wir die `pinataURL` aus der `pinataResponse` und speichern sie als unsere `tokenURI`-Variable.
+
+Jetzt ist es an der Zeit, unseren Smart Contract mit der Alchemy Web3-API zu laden, die wir am Anfang unserer Datei initialisiert haben. Füge die folgende Codezeile am Ende der `mintNFT`-Funktion hinzu, um den Vertrag auf die globale Variable `window.contract` zu setzen:
+
+```javascript
+window.contract = await new web3.eth.Contract(contractABI, contractAddress)
+```
+
+Das Letzte, was wir in unserer `mintNFT`-Funktion hinzufügen müssen, ist unsere Ethereum-Transaktion:
+
+```javascript
+//Deine Ethereum-Transaktion einrichten
+const transactionParameters = {
+ to: contractAddress, // Erforderlich, außer bei Vertragsveröffentlichungen.
+ from: window.ethereum.selectedAddress, // muss mit der aktiven Adresse des Benutzers übereinstimmen.
+ data: window.contract.methods
+ .mintNFT(window.ethereum.selectedAddress, tokenURI)
+ .encodeABI(), //Aufruf des NFT-Smart-Contracts durchführen
+}
+
+//die Transaktion über MetaMask signieren
+try {
+ const txHash = await window.ethereum.request({
+ method: "eth_sendTransaction",
+ params: [transactionParameters],
+ })
+ return {
+ success: true,
+ status:
+ "✅ Sieh dir deine Transaktion auf Etherscan an: https://ropsten.etherscan.io/tx/" +
+ txHash,
+ }
+} catch (error) {
+ return {
+ success: false,
+ status: "😥 Etwas ist schiefgelaufen: " + error.message,
+ }
+}
+```
+
+Wenn du bereits mit Ethereum-Transaktionen vertraut bist, wirst du feststellen, dass die Struktur ziemlich ähnlich zu dem ist, was du bereits gesehen hast.
+
+- Zuerst richten wir unsere Transaktionsparameter ein.
+ - `to` gibt die Empfängeradresse an (unser Smart Contract)
+ - `from` gibt den Unterzeichner der Transaktion an (die mit MetaMask verbundene Adresse des Benutzers: `window.ethereum.selectedAddress`)
+ - `data` enthält den Aufruf unserer Smart-Contract-`mintNFT`-Methode, die unsere `tokenURI` und die Wallet-Adresse des Benutzers, `window.ethereum.selectedAddress`, als Eingaben erhält
+- Dann machen wir einen Await-Aufruf, `window.ethereum.request,`, bei dem wir MetaMask bitten, die Transaktion zu signieren. Beachte, dass wir in dieser Anfrage unsere eth-Methode (eth_SentTransaction) angeben und unsere `transactionParameters` übergeben. An diesem Punkt öffnet sich MetaMask im Browser und fordert den Benutzer auf, die Transaktion zu signieren oder abzulehnen.
+ - Wenn die Transaktion erfolgreich ist, gibt die Funktion ein JSON-Objekt zurück, bei dem der Boole’sche Wert `success` auf „true“ gesetzt ist und die `status`-Zeichenfolge den Benutzer auffordert, Etherscan für weitere Informationen zu seiner Transaktion zu besuchen.
+ - Wenn die Transaktion fehlschlägt, gibt die Funktion ein JSON-Objekt zurück, bei dem der `success`-Boole’sche Wert auf „false“ gesetzt ist und die `status`-Zeichenfolge die Fehlermeldung weitergibt.
+
+Insgesamt sollte unsere `mintNFT`-Funktion so aussehen:
+
+```javascript
+export const mintNFT = async (url, name, description) => {
+ //Fehlerbehandlung
+ if (url.trim() == "" || name.trim() == "" || description.trim() == "") {
+ return {
+ success: false,
+ status: "❗Bitte stelle sicher, dass alle Felder vor dem Minten ausgefüllt sind.",
+ }
+ }
+
+ //Metadaten erstellen
+ const metadata = new Object()
+ metadata.name = name
+ metadata.image = url
+ metadata.description = description
+
+ //Pinata-Pin-Anfrage
+ const pinataResponse = await pinJSONToIPFS(metadata)
+ if (!pinataResponse.success) {
+ return {
+ success: false,
+ status: "😢 Etwas ist beim Hochladen deiner tokenURI schiefgelaufen.",
+ }
+ }
+ const tokenURI = pinataResponse.pinataUrl
+
+ //Smart Contract laden
+ window.contract = await new web3.eth.Contract(contractABI, contractAddress) //loadContract();
+
+ //Deine Ethereum-Transaktion einrichten
+ const transactionParameters = {
+ to: contractAddress, // Erforderlich, außer bei Vertragsveröffentlichungen.
+ from: window.ethereum.selectedAddress, // muss mit der aktiven Adresse des Benutzers übereinstimmen.
+ data: window.contract.methods
+ .mintNFT(window.ethereum.selectedAddress, tokenURI)
+ .encodeABI(), //Aufruf des NFT-Smart-Contracts durchführen
+ }
+
+ //Transaktion über MetaMask signieren
+ try {
+ const txHash = await window.ethereum.request({
+ method: "eth_sendTransaction",
+ params: [transactionParameters],
+ })
+ return {
+ success: true,
+ status:
+ "✅ Sieh dir deine Transaktion auf Etherscan an: https://ropsten.etherscan.io/tx/" +
+ txHash,
+ }
+ } catch (error) {
+ return {
+ success: false,
+ status: "😥 Etwas ist schiefgelaufen: " + error.message,
+ }
+ }
+}
+```
+
+Das ist eine riesige Funktion! Jetzt müssen wir nur noch unsere `mintNFT`-Funktion mit unserer `Minter.js`-Komponente verbinden ...
+
+## Verbinde mintNFT mit unserem Minter.js-Frontend {#connect-our-frontend}
+
+Öffne deine `Minter.js`-Datei und aktualisiere die Zeile `import { connectWallet, getCurrentWalletConnected } from "./utils/interact.js";` am Anfang zu:
+
+```javascript
+import {
+ connectWallet,
+ getCurrentWalletConnected,
+ mintNFT,
+} from "./utils/interact.js"
+```
+
+Implementiere schließlich die `onMintPressed`-Funktion, um einen Await-Aufruf an deine importierte `mintNFT`-Funktion zu machen und die `status`-Zustandsvariable zu aktualisieren, um widerzuspiegeln, ob unsere Transaktion erfolgreich war oder fehlgeschlagen ist:
+
+```javascript
+const onMintPressed = async () => {
+ const { status } = await mintNFT(url, name, description)
+ setStatus(status)
+}
+```
+
+## Stelle deinen NFT auf einer Live-Website bereit {#deploy-your-NFT}
+
+Bereit, dein Projekt live zu schalten, damit Benutzer damit interagieren können? Sieh dir [dieses Tutorial](https://docs.alchemy.com/alchemy/tutorials/nft-minter/how-do-i-deploy-nfts-online) an, um deinen Minter auf einer Live-Website bereitzustellen.
+
+Ein letzter Schritt ...
+
+## Erobere die Blockchain-Welt im Sturm {#take-the-blockchain-world-by-storm}
+
+Nur ein Scherz, du hast es bis zum Ende des Tutorials geschafft!
+
+Zusammenfassend lässt sich sagen, dass du durch den Bau eines NFT-Minters erfolgreich gelernt hast, wie man:
+
+- Verbinden von MetaMask mit Ihrem Frontend-Projekt
+- Rufen von Smart-Contract Methoden von Ihrem Frontend
+- Transaktionen mit MetaMask signieren
+
+Vermutlich möchtest du die über deine Dapp geminteten NFTs in deiner Wallet präsentieren können – sieh dir also unbedingt unser kurzes Tutorial [So zeigst du dein NFT in deiner Wallet an](https://www.alchemy.com/docs/how-to-view-your-nft-in-your-mobile-wallet) an!
+
+Und wie immer, wenn du Fragen hast, sind wir hier, um im [Alchemy Discord](https://discord.gg/gWuC7zB) zu helfen. Wir können es kaum erwarten zu sehen, wie du die Konzepte aus diesem Tutorial auf deine zukünftigen Projekte anwendest!
diff --git a/public/content/translations/de/developers/tutorials/optimism-std-bridge-annotated-code/index.md b/public/content/translations/de/developers/tutorials/optimism-std-bridge-annotated-code/index.md
new file mode 100644
index 00000000000..59a7e410e1c
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/optimism-std-bridge-annotated-code/index.md
@@ -0,0 +1,1357 @@
+---
+title: "Walkthrough zum Vertrag der Optimism-Standard-Brücke"
+description: Wie funktioniert die Standard-Brücke für Optimism? Warum funktioniert sie auf diese Weise?
+author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+tags: [ "solidity", "Brücke", "Layer 2" ]
+skill: intermediate
+published: 2022-03-30
+lang: de
+---
+
+[Optimism](https://www.optimism.io/) ist ein [Optimistic Rollup](/developers/docs/scaling/optimistic-rollups/).
+Optimistic Rollups können Transaktionen zu einem viel niedrigeren Preis als das Ethereum Mainnet (auch bekannt als Layer 1 oder L1) verarbeiten, da Transaktionen nur von einigen wenigen Knoten anstatt von jedem Knoten im Netzwerk verarbeitet werden.
+Gleichzeitig werden alle Daten auf L1 geschrieben, sodass alles mit der Integrität und Verfügbarkeit des Mainnets nachgewiesen und rekonstruiert werden kann.
+
+Um L1-Assets auf Optimism (oder einem anderen L2) zu verwenden, müssen die Assets [überbrückt](/bridges/#prerequisites) werden.
+Eine Möglichkeit, dies zu erreichen, besteht darin, dass Benutzer Assets (ETH und [ERC-20-Tokens](/developers/docs/standards/tokens/erc-20/) sind die häufigsten) auf L1 sperren und gleichwertige Assets zur Verwendung auf L2 erhalten.
+Schließlich möchte derjenige, der sie am Ende besitzt, sie vielleicht wieder auf L1 zurückbrücken.
+Dabei werden die Assets auf L2 verbrannt und dann auf L1 wieder an den Benutzer freigegeben.
+
+So funktioniert die [Optimism Standard-Brücke](https://docs.optimism.io/app-developers/bridging/standard-bridge).
+In diesem Artikel gehen wir den Quellcode für diese Brücke durch, um zu sehen, wie sie funktioniert, und um sie als Beispiel für gut geschriebenen Solidity-Code zu studieren.
+
+## Kontrollflüsse {#control-flows}
+
+Die Brücke hat zwei Hauptabläufe:
+
+- Einzahlung (von L1 nach L2)
+- Auszahlung (von L2 nach L1)
+
+### Einzahlungsablauf {#deposit-flow}
+
+#### Layer 1 {#deposit-flow-layer-1}
+
+1. Bei der Einzahlung eines ERC-20 erteilt der Einzahler der Brücke eine Freigabe, den eingezahlten Betrag auszugeben.
+2. Der Einzahler ruft die L1-Brücke auf (`depositERC20`, `depositERC20To`, `depositETH` oder `depositETHTo`)
+3. Die L1-Brücke nimmt das überbrückte Asset in Besitz.
+ - ETH: Das Asset wird vom Einzahler als Teil des Aufrufs übertragen.
+ - ERC-20: Das Asset wird von der Brücke unter Verwendung der vom Einzahler erteilten Freigabe an sich selbst übertragen.
+4. Die L1-Brücke verwendet den domänenübergreifenden Nachrichtenmechanismus, um `finalizeDeposit` auf der L2-Brücke aufzurufen.
+
+#### Layer 2 {#deposit-flow-layer-2}
+
+5. Die L2-Brücke überprüft, ob der Aufruf von `finalizeDeposit` rechtmäßig ist:
+ - Kam vom domänenübergreifenden Nachrichtenvertrag
+ - War ursprünglich von der Brücke auf L1
+6. Die L2-Brücke prüft, ob der ERC-20-Token-Vertrag auf L2 der richtige ist:
+ - Der L2-Vertrag meldet, dass sein L1-Gegenstück dasselbe ist wie das, von dem die Tokens auf L1 kamen
+ - Der L2-Vertrag meldet, dass er die richtige Schnittstelle unterstützt ([unter Verwendung von ERC-165](https://eips.ethereum.org/EIPS/eip-165)).
+7. Wenn der L2-Vertrag der richtige ist, rufen Sie ihn auf, um die entsprechende Anzahl von Tokens an die entsprechende Adresse zu prägen. Wenn nicht, starten Sie einen Auszahlungsprozess, damit der Benutzer die Tokens auf L1 beanspruchen kann.
+
+### Auszahlungsablauf {#withdrawal-flow}
+
+#### Layer 2 {#withdrawal-flow-layer-2}
+
+1. Der Auszahlende ruft die L2-Brücke auf (`withdraw` oder `withdrawTo`)
+2. Die L2-Brücke verbrennt die entsprechende Anzahl von Tokens, die `msg.sender` gehören.
+3. Die L2-Brücke verwendet den domänenübergreifenden Nachrichtenmechanismus, um `finalizeETHWithdrawal` oder `finalizeERC20Withdrawal` auf der L1-Brücke aufzurufen.
+
+#### Layer 1 {#withdrawal-flow-layer-1}
+
+4. Die L1-Brücke überprüft, ob der Aufruf von `finalizeETHWithdrawal` oder `finalizeERC20Withdrawal` rechtmäßig ist:
+ - Kam vom domänenübergreifenden Nachrichtenmechanismus
+ - War ursprünglich von der Brücke auf L2
+5. Die L1-Brücke überträgt das entsprechende Asset (ETH oder ERC-20) an die entsprechende Adresse.
+
+## Layer-1-Code {#layer-1-code}
+
+Dies ist der Code, der auf L1, dem Ethereum Mainnet, läuft.
+
+### IL1ERC20Bridge {#IL1ERC20Bridge}
+
+[Diese Schnittstelle ist hier definiert](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/IL1ERC20Bridge.sol).
+Sie enthält Funktionen und Definitionen, die für die Überbrückung von ERC-20-Tokens erforderlich sind.
+
+```solidity
+// SPDX-License-Identifier: MIT
+```
+
+[Der größte Teil des Codes von Optimism wird unter der MIT-Lizenz veröffentlicht](https://help.optimism.io/hc/en-us/articles/4411908707995-What-software-license-does-Optimism-use-).
+
+```solidity
+pragma solidity >0.5.0 <0.9.0;
+```
+
+Zum Zeitpunkt des Schreibens ist die neueste Version von Solidity 0.8.12.
+Bis zur Veröffentlichung von Version 0.9.0 wissen wir nicht, ob dieser Code damit kompatibel ist oder nicht.
+
+```solidity
+/**
+ * @title IL1ERC20Bridge
+ */
+interface IL1ERC20Bridge {
+ /**********
+ * Ereignisse *
+ **********/
+
+ event ERC20DepositInitiated(
+```
+
+In der Terminologie der Optimism-Brücke bedeutet _Einzahlung_ eine Übertragung von L1 nach L2 und _Auszahlung_ eine Übertragung von L2 nach L1.
+
+```solidity
+ address indexed _l1Token,
+ address indexed _l2Token,
+```
+
+In den meisten Fällen ist die Adresse eines ERC-20 auf L1 nicht dieselbe wie die Adresse des entsprechenden ERC-20 auf L2.
+[Sie können die Liste der Token-Adressen hier einsehen](https://static.optimism.io/optimism.tokenlist.json).
+Die Adresse mit `chainId` 1 befindet sich auf L1 (Mainnet) und die Adresse mit `chainId` 10 auf L2 (Optimism).
+Die anderen beiden `chainId`-Werte sind für das Kovan-Testnetz (42) und das Optimistic Kovan-Testnetz (69).
+
+```solidity
+ address indexed _from,
+ address _to,
+ uint256 _amount,
+ bytes _data
+ );
+```
+
+Es ist möglich, Notizen zu Übertragungen hinzuzufügen, in diesem Fall werden sie zu den Ereignissen hinzugefügt, die sie melden.
+
+```solidity
+ event ERC20WithdrawalFinalized(
+ address indexed _l1Token,
+ address indexed _l2Token,
+ address indexed _from,
+ address _to,
+ uint256 _amount,
+ bytes _data
+ );
+```
+
+Derselbe Brückenvertrag behandelt Übertragungen in beide Richtungen.
+Im Fall der L1-Brücke bedeutet dies die Initiierung von Einzahlungen und die Finalisierung von Auszahlungen.
+
+```solidity
+
+ /********************
+ * Öffentliche Funktionen *
+ ********************/
+
+ /**
+ * @dev Ruft die Adresse des entsprechenden L2-Brückenvertrags ab.
+ * @return Adresse des entsprechenden L2-Brückenvertrags.
+ */
+ function l2TokenBridge() external returns (address);
+```
+
+Diese Funktion wird nicht wirklich benötigt, da es sich auf L2 um einen vorab bereitgestellten Vertrag (predeployed contract) handelt, der sich also immer an der Adresse `0x4200000000000000000000000000000000000010` befindet.
+Sie ist hier aus Symmetriegründen zur L2-Brücke, da die Adresse der L1-Brücke _nicht_ trivial zu kennen ist.
+
+```solidity
+ /**
+ * @dev Zahlt einen Betrag des ERC20 auf das Guthaben des Aufrufers auf L2 ein.
+ * @param _l1Token Adresse des L1 ERC20, das wir einzahlen.
+ * @param _l2Token Adresse des entsprechenden L2 ERC20.
+ * @param _amount Einzuzahlender Betrag des ERC20.
+ * @param _l2Gas Erforderliches Gaslimit, um die Einzahlung auf L2 abzuschließen.
+ * @param _data Optionale Daten zur Weiterleitung an L2. Diese Daten werden
+ * lediglich als Annehmlichkeit für externe Verträge zur Verfügung gestellt. Abgesehen von der Durchsetzung einer maximalen
+ * Länge geben diese Verträge keine Garantien über ihren Inhalt.
+ */
+ function depositERC20(
+ address _l1Token,
+ address _l2Token,
+ uint256 _amount,
+ uint32 _l2Gas,
+ bytes calldata _data
+ ) external;
+```
+
+Der Parameter `_l2Gas` ist die Menge an L2-Gas, die die Transaktion verbrauchen darf.
+[Bis zu einem bestimmten (hohen) Limit ist dies kostenlos](https://community.optimism.io/docs/developers/bridge/messaging/#for-l1-%E2%87%92-l2-transactions-2), daher sollte es kein Problem sein, es sei denn, der ERC-20-Vertrag macht beim Prägen etwas wirklich Seltsames.
+Diese Funktion kümmert sich um das übliche Szenario, bei dem ein Benutzer Assets an dieselbe Adresse auf einer anderen Blockchain überbrückt.
+
+```solidity
+ /**
+ * @dev zahlt einen Betrag von ERC20 auf das Guthaben eines Empfängers auf L2 ein.
+ * @param _l1Token Adresse des L1 ERC20, den wir einzahlen
+ * @param _l2Token Adresse des entsprechenden L2 ERC20 auf L1
+ * @param _to L2-Adresse, auf die die Abhebung gutgeschrieben werden soll.
+ * @param _amount Einzuzahlender Betrag des ERC20.
+ * @param _l2Gas Gaslimit, das erforderlich ist, um die Einzahlung auf L2 abzuschließen.
+ * @param _data Optionale Daten zur Weiterleitung an L2. Diese Daten werden
+ * lediglich als Annehmlichkeit für externe Verträge zur Verfügung gestellt. Abgesehen von der Durchsetzung einer maximalen
+ * Länge geben diese Verträge keine Garantien über ihren Inhalt.
+ */
+ function depositERC20To(
+ address _l1Token,
+ address _l2Token,
+ address _to,
+ uint256 _amount,
+ uint32 _l2Gas,
+ bytes calldata _data
+ ) external;
+```
+
+Diese Funktion ist fast identisch mit `depositERC20`, aber sie ermöglicht es Ihnen, den ERC-20 an eine andere Adresse zu senden.
+
+```solidity
+ /*************************
+ * Cross-Chain-Funktionen *
+ *************************/
+
+ /**
+ * @dev Schließt eine Auszahlung von L2 nach L1 ab und schreibt den Betrag dem Guthaben des
+ * L1-ERC20-Tokens des Empfängers gut.
+ * Dieser Aufruf schlägt fehl, wenn die initiierte Auszahlung von L2 noch nicht finalisiert wurde.
+ *
+ * @param _l1Token Adresse des L1-Tokens, für das finalizeWithdrawal ausgeführt wird.
+ * @param _l2Token Adresse des L2-Tokens, auf dem die Auszahlung eingeleitet wurde.
+ * @param _from L2-Adresse, die die Übertragung initiiert.
+ * @param _to L1-Adresse, der die Auszahlung gutgeschrieben werden soll.
+ * @param _amount Einzuzahlender Betrag des ERC20.
+ * @param _data Vom Absender auf L2 bereitgestellte Daten. Diese Daten werden
+ * lediglich als Annehmlichkeit für externe Verträge zur Verfügung gestellt. Abgesehen von der Durchsetzung einer maximalen
+ * Länge geben diese Verträge keine Garantien über ihren Inhalt.
+ */
+ function finalizeERC20Withdrawal(
+ address _l1Token,
+ address _l2Token,
+ address _from,
+ address _to,
+ uint256 _amount,
+ bytes calldata _data
+ ) external;
+}
+```
+
+Auszahlungen (und andere Nachrichten von L2 nach L1) in Optimism sind ein zweistufiger Prozess:
+
+1. Eine initiierende Transaktion auf L2.
+2. Eine finalisierende oder beanspruchende Transaktion auf L1.
+ Diese Transaktion muss nach dem Ende des [Fehler-Anfechtungszeitraums](https://community.optimism.io/docs/how-optimism-works/#fault-proofs) für die L2-Transaktion erfolgen.
+
+### IL1StandardBridge {#il1standardbridge}
+
+[Diese Schnittstelle ist hier definiert](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/IL1StandardBridge.sol).
+Diese Datei enthält Ereignis- und Funktionsdefinitionen für ETH.
+Diese Definitionen sind sehr ähnlich zu denen, die oben in `IL1ERC20Bridge` für ERC-20 definiert wurden.
+
+Die Brückenschnittstelle ist auf zwei Dateien aufgeteilt, da einige ERC-20-Tokens eine benutzerdefinierte Verarbeitung erfordern und nicht von der Standardbrücke verarbeitet werden können.
+Auf diese Weise kann die benutzerdefinierte Brücke, die einen solchen Token verarbeitet, `IL1ERC20Bridge` implementieren und muss nicht auch ETH überbrücken.
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity >0.5.0 <0.9.0;
+
+import "./IL1ERC20Bridge.sol";
+
+/**
+ * @title IL1StandardBridge
+ */
+interface IL1StandardBridge is IL1ERC20Bridge {
+ /**********
+ * Ereignisse *
+ **********/
+ event ETHDepositInitiated(
+ address indexed _from,
+ address indexed _to,
+ uint256 _amount,
+ bytes _data
+ );
+```
+
+Dieses Ereignis ist fast identisch mit der ERC-20-Version (`ERC20DepositInitiated`), jedoch ohne die L1- und L2-Token-Adressen.
+Dasselbe gilt für die anderen Ereignisse und die Funktionen.
+
+```solidity
+ event ETHWithdrawalFinalized(
+ .
+ .
+ .
+ );
+
+ /********************
+ * Öffentliche Funktionen *
+ ********************/
+
+ /**
+ * @dev Einzahlung eines ETH-Betrags in das Guthaben des Aufrufers auf L2.
+ .
+ .
+ .
+ */
+ function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;
+
+ /**
+ * @dev Einzahlung eines ETH-Betrags in das Guthaben eines Empfängers auf L2.
+ .
+ .
+ .
+ */
+ function depositETHTo(
+ address _to,
+ uint32 _l2Gas,
+ bytes calldata _data
+ ) external payable;
+
+ /*************************
+ * Cross-Chain-Funktionen *
+ *************************/
+
+ /**
+ * @dev Schließen Sie eine Auszahlung von L2 nach L1 ab und schreiben Sie den Betrag dem Guthaben des L1-ETH-Tokens des Empfängers gut.
+ * Da nur der xDomainMessenger diese Funktion aufrufen kann, wird sie niemals aufgerufen
+ * bevor die Auszahlung finalisiert ist.
+ .
+ .
+ .
+ */
+ function finalizeETHWithdrawal(
+ address _from,
+ address _to,
+ uint256 _amount,
+ bytes calldata _data
+ ) external;
+}
+```
+
+### CrossDomainEnabled {#crossdomainenabled}
+
+[Dieser Vertrag](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/libraries/bridge/CrossDomainEnabled.sol) wird von beiden Brücken ([L1](#the-l1-bridge-contract) und [L2](#the-l2-bridge-contract)) geerbt, um Nachrichten an den anderen Layer zu senden.
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity >0.5.0 <0.9.0;
+
+/* Schnittstellen-Importe */
+import { ICrossDomainMessenger } from "./ICrossDomainMessenger.sol";
+```
+
+[Diese Schnittstelle](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/libraries/bridge/ICrossDomainMessenger.sol) teilt dem Vertrag mit, wie Nachrichten an den anderen Layer gesendet werden sollen, indem der Cross-Domain-Messenger verwendet wird.
+Dieser Cross-Domain-Messenger ist ein ganz anderes System und verdient einen eigenen Artikel, den ich hoffentlich in Zukunft schreiben werde.
+
+```solidity
+/**
+ * @title CrossDomainEnabled
+ * @dev Hilfsvertrag für Verträge, die domänenübergreifende Kommunikation durchführen
+ *
+ * Verwendeter Compiler: definiert durch vererbenden Vertrag
+ */
+contract CrossDomainEnabled {
+ /*************
+ * Variablen *
+ *************/
+
+ // Messenger-Vertrag, der zum Senden und Empfangen von Nachrichten aus der anderen Domäne verwendet wird.
+ address public messenger;
+
+ /***************
+ * Konstruktor *
+ ***************/
+
+ /**
+ * @param _messenger Adresse des CrossDomainMessenger auf der aktuellen Ebene.
+ */
+ constructor(address _messenger) {
+ messenger = _messenger;
+ }
+```
+
+Der eine Parameter, den der Vertrag kennen muss, ist die Adresse des Cross-Domain-Messengers auf diesem Layer.
+Dieser Parameter wird einmal im Konstruktor gesetzt und ändert sich nie.
+
+```solidity
+
+ /**********************
+ * Funktionsmodifikatoren *
+ **********************/
+
+ /**
+ * Erzwingt, dass die modifizierte Funktion nur von einem bestimmten domänenübergreifenden Konto aufgerufen werden kann.
+ * @param _sourceDomainAccount Das einzige Konto in der Ursprungsdomäne, das
+ * zur Ausführung dieser Funktion berechtigt ist.
+ */
+ modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {
+```
+
+Das domänenübergreifende Messaging ist für jeden Vertrag auf der Blockchain zugänglich, auf der es läuft (entweder Ethereum Mainnet oder Optimism).
+Aber wir brauchen die Brücke auf jeder Seite, um _nur_ bestimmten Nachrichten zu vertrauen, wenn sie von der Brücke auf der anderen Seite kommen.
+
+```solidity
+ require(
+ msg.sender == address(getCrossDomainMessenger()),
+ "OVM_XCHAIN: messenger contract unauthenticated"
+ );
+```
+
+Nur Nachrichten vom entsprechenden Cross-Domain-Messenger (`messenger`, wie Sie unten sehen) können als vertrauenswürdig eingestuft werden.
+
+```solidity
+
+ require(
+ getCrossDomainMessenger().xDomainMessageSender() == _sourceDomainAccount,
+ "OVM_XCHAIN: wrong sender of cross-domain message"
+ );
+```
+
+Die Art und Weise, wie der Cross-Domain-Messenger die Adresse bereitstellt, die eine Nachricht mit dem anderen Layer gesendet hat, ist [die Funktion `.xDomainMessageSender()`](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/L1CrossDomainMessenger.sol#L122-L128).
+Solange sie in der Transaktion aufgerufen wird, die durch die Nachricht initiiert wurde, kann sie diese Information bereitstellen.
+
+Wir müssen sicherstellen, dass die Nachricht, die wir erhalten haben, von der anderen Brücke kam.
+
+```solidity
+
+ _;
+ }
+
+ /**********************
+ * Interne Funktionen *
+ **********************/
+
+ /**
+ * Ruft den Messenger ab, normalerweise aus dem Speicher. Diese Funktion wird für den Fall verfügbar gemacht, dass ein untergeordneter Vertrag
+ * sie überschreiben muss.
+ * @return Die Adresse des Cross-Domain-Messenger-Vertrags, der verwendet werden sollte.
+ */
+ function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
+ return ICrossDomainMessenger(messenger);
+ }
+```
+
+Diese Funktion gibt den Cross-Domain-Messenger zurück.
+Wir verwenden eine Funktion anstelle der Variable `messenger`, um Verträgen, die von diesem erben, zu ermöglichen, einen Algorithmus zu verwenden, um anzugeben, welcher Cross-Domain-Messenger verwendet werden soll.
+
+```solidity
+
+ /**
+ * Sendet eine Nachricht an ein Konto in einer anderen Domäne
+ * @param _crossDomainTarget Der beabsichtigte Empfänger in der Zieldomäne
+ * @param _message Die an das Ziel zu sendenden Daten (normalerweise Calldata an eine Funktion mit
+ * `onlyFromCrossDomainAccount()`)
+ * @param _gasLimit Das GasLimit für den Empfang der Nachricht in der Zieldomäne.
+ */
+ function sendCrossDomainMessage(
+ address _crossDomainTarget,
+ uint32 _gasLimit,
+ bytes memory _message
+```
+
+Schließlich die Funktion, die eine Nachricht an den anderen Layer sendet.
+
+```solidity
+ ) internal {
+ // slither-disable-next-line reentrancy-events, reentrancy-benign
+```
+
+[Slither](https://github.com/crytic/slither) ist ein statischer Analysator, den Optimism auf jedem Vertrag ausführt, um nach Schwachstellen und anderen potenziellen Problemen zu suchen.
+In diesem Fall löst die folgende Zeile zwei Schwachstellen aus:
+
+1. [Reentrancy-Ereignisse](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-3)
+2. [Gutartige Wiedereintrittsfähigkeit](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-2)
+
+```solidity
+ getCrossDomainMessenger().sendMessage(_crossDomainTarget, _message, _gasLimit);
+ }
+}
+```
+
+In diesem Fall machen wir uns keine Sorgen über Wiedereintrittsfähigkeit, da wir wissen, dass `getCrossDomainMessenger()` eine vertrauenswürdige Adresse zurückgibt, auch wenn Slither keine Möglichkeit hat, das zu wissen.
+
+### Der L1-Brückenvertrag {#the-l1-bridge-contract}
+
+[Der Quellcode für diesen Vertrag befindet sich hier](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/L1StandardBridge.sol).
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+```
+
+Die Schnittstellen können Teil anderer Verträge sein, daher müssen sie eine breite Palette von Solidity-Versionen unterstützen.
+Aber die Brücke selbst ist unser Vertrag, und wir können streng sein, welche Solidity-Version sie verwendet.
+
+```solidity
+/* Schnittstellen-Importe */
+import { IL1StandardBridge } from "./IL1StandardBridge.sol";
+import { IL1ERC20Bridge } from "./IL1ERC20Bridge.sol";
+```
+
+[IL1ERC20Bridge](#IL1ERC20Bridge) und [IL1StandardBridge](#IL1StandardBridge) werden oben erklärt.
+
+```solidity
+import { IL2ERC20Bridge } from "../../L2/messaging/IL2ERC20Bridge.sol";
+```
+
+[Diese Schnittstelle](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/IL2ERC20Bridge.sol) ermöglicht es uns, Nachrichten zu erstellen, um die Standardbrücke auf L2 zu steuern.
+
+```solidity
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+```
+
+[Diese Schnittstelle](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol) ermöglicht es uns, ERC-20-Verträge zu steuern.
+[Hier können Sie mehr darüber lesen](/developers/tutorials/erc20-annotated-code/#the-interface).
+
+```solidity
+/* Bibliotheks-Importe */
+import { CrossDomainEnabled } from "../../libraries/bridge/CrossDomainEnabled.sol";
+```
+
+[Wie oben erklärt](#crossdomainenabled), wird dieser Vertrag für die Interlayer-Nachrichtenübermittlung verwendet.
+
+```solidity
+import { Lib_PredeployAddresses } from "../../libraries/constants/Lib_PredeployAddresses.sol";
+```
+
+`Lib_PredeployAddresses` (https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/libraries/constants/Lib_PredeployAddresses.sol) hat die Adressen für die L2-Verträge, die immer dieselbe Adresse haben. Dies schließt die Standard-Brücke auf L2 mit ein.
+
+```solidity
+import { Address } from "@openzeppelin/contracts/utils/Address.sol";
+```
+
+[OpenZeppelins Address-Dienstprogramme](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol). Es wird verwendet, um zwischen Vertragsadressen und solchen zu unterscheiden, die zu extern besessenen Konten (EOA) gehören.
+
+Beachten Sie, dass dies keine perfekte Lösung ist, da es keine Möglichkeit gibt, zwischen direkten Aufrufen und Aufrufen aus dem Konstruktor eines Vertrags zu unterscheiden, aber zumindest können wir so einige häufige Benutzerfehler identifizieren und verhindern.
+
+```solidity
+import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+```
+
+[Der ERC-20-Standard](https://eips.ethereum.org/EIPS/eip-20) unterstützt zwei Möglichkeiten für einen Vertrag, einen Fehler zu melden:
+
+1. Zurücksetzen (revert)
+2. `false` zurückgeben
+
+Die Handhabung beider Fälle würde unseren Code komplizierter machen, daher verwenden wir stattdessen [OpenZeppelins `SafeERC20`](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/utils/SafeERC20.sol), das sicherstellt, dass [alle Fehler zu einem Revert führen](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/utils/SafeERC20.sol#L96).
+
+```solidity
+/**
+ * @title L1StandardBridge
+ * @dev Die L1-ETH- und ERC20-Brücke ist ein Vertrag, der hinterlegte L1-Mittel und Standard-Token
+ * speichert, die auf L2 verwendet werden. Sie synchronisiert eine entsprechende L2-Brücke, informiert sie über Einzahlungen
+ * und hört auf sie für neu finalisierte Auszahlungen.
+ *
+ */
+contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
+ using SafeERC20 for IERC20;
+```
+
+Diese Zeile gibt an, dass der `SafeERC20`-Wrapper jedes Mal verwendet werden soll, wenn wir die `IERC20`-Schnittstelle verwenden.
+
+```solidity
+
+ /********************************
+ * Externe Vertragsreferenzen *
+ ********************************/
+
+ address public l2TokenBridge;
+```
+
+Die Adresse von [L2StandardBridge](#the-l2-bridge-contract).
+
+```solidity
+
+ // Ordnet L1-Token zu L2-Token zu Saldo des hinterlegten L1-Tokens zu
+ mapping(address => mapping(address => uint256)) public deposits;
+```
+
+Ein doppeltes [Mapping](https://www.tutorialspoint.com/solidity/solidity_mappings.htm) wie dieses ist die Art und Weise, wie Sie ein [zweidimensionales dünn besetztes Array](https://en.wikipedia.org/wiki/Sparse_matrix) definieren.
+Werte in dieser Datenstruktur werden als `deposit[L1-Token-Adresse][L2-Token-Adresse]` identifiziert.
+Der Standardwert ist Null.
+Nur Zellen, die auf einen anderen Wert gesetzt sind, werden in den Speicher geschrieben.
+
+```solidity
+
+ /***************
+ * Konstruktor *
+ ***************/
+
+ // Dieser Vertrag lebt hinter einem Proxy, daher werden die Konstruktorparameter ungenutzt bleiben.
+ constructor() CrossDomainEnabled(address(0)) {}
+```
+
+Wir wollen diesen Vertrag aktualisieren können, ohne alle Variablen im Speicher kopieren zu müssen.
+Dazu verwenden wir einen [`Proxy`](https://docs.openzeppelin.com/contracts/3.x/api/proxy), einen Vertrag, der `delegatecall` verwendet, um Aufrufe an einen separaten Vertrag zu übertragen, dessen Adresse vom Proxy-Vertrag gespeichert wird (wenn Sie ein Upgrade durchführen, weisen Sie den Proxy an, diese Adresse zu ändern).
+Wenn Sie `delegatecall` verwenden, bleibt der Speicher der Speicher des _aufrufenden_ Vertrags, sodass die Werte aller Vertragszustandsvariablen unberührt bleiben.
+
+Ein Effekt dieses Musters ist, dass der Speicher des Vertrags, der der _Aufgerufene_ von `delegatecall` ist, nicht verwendet wird und daher die an ihn übergebenen Konstruktorwerte keine Rolle spielen.
+Dies ist der Grund, warum wir dem `CrossDomainEnabled`-Konstruktor einen unsinnigen Wert übergeben können.
+Dies ist auch der Grund, warum die folgende Initialisierung vom Konstruktor getrennt ist.
+
+```solidity
+ /******************
+ * Initialisierung *
+ ******************/
+
+ /**
+ * @param _l1messenger L1 Messenger-Adresse, die für die Cross-Chain-Kommunikation verwendet wird.
+ * @param _l2TokenBridge L2-Standard-Brückenadresse.
+ */
+ // slither-disable-next-line external-function
+```
+
+Dieser [Slither-Test](https://github.com/crytic/slither/wiki/Detector-Documentation#public-function-that-could-be-declared-external) identifiziert Funktionen, die nicht aus dem Vertragscode aufgerufen werden und daher als `external` anstatt `public` deklariert werden könnten.
+Die Gaskosten von `external`-Funktionen können niedriger sein, da sie mit Parametern in den Calldata versorgt werden können.
+Als `public` deklarierte Funktionen müssen innerhalb des Vertrags zugänglich sein.
+Verträge können ihre eigenen Calldata nicht ändern, daher müssen sich die Parameter im Speicher befinden.
+Wenn eine solche Funktion extern aufgerufen wird, ist es notwendig, die Calldata in den Speicher zu kopieren, was Gas kostet.
+In diesem Fall wird die Funktion nur einmal aufgerufen, sodass die Ineffizienz für uns keine Rolle spielt.
+
+```solidity
+ function initialize(address _l1messenger, address _l2TokenBridge) public {
+ require(messenger == address(0), "Vertrag wurde bereits initialisiert.");
+```
+
+Die `initialize`-Funktion sollte nur einmal aufgerufen werden.
+Wenn sich die Adresse des L1-Cross-Domain-Messengers oder der L2-Token-Brücke ändert, erstellen wir einen neuen Proxy und eine neue Brücke, die ihn aufruft.
+Dies wird wahrscheinlich nur bei einem Upgrade des gesamten Systems geschehen, ein sehr seltenes Ereignis.
+
+Beachten Sie, dass diese Funktion keinen Mechanismus hat, der einschränkt, _wer_ sie aufrufen kann.
+Das bedeutet, dass ein Angreifer theoretisch warten könnte, bis wir den Proxy und die erste Version der Brücke deployen, und dann [Front-Running betreiben](https://solidity-by-example.org/hacks/front-running/) könnte, um zur `initialize`-Funktion zu gelangen, bevor der legitime Benutzer dies tut. Es gibt jedoch zwei Methoden, um dies zu verhindern:
+
+1. Wenn die Verträge nicht direkt von einem EOA, sondern [in einer Transaktion bereitgestellt werden, in der ein anderer Vertrag sie erstellt](https://medium.com/upstate-interactive/creating-a-contract-with-a-smart-contract-bdb67c5c8595), kann der gesamte Prozess atomar sein und abgeschlossen werden, bevor eine andere Transaktion ausgeführt wird.
+2. Wenn der legitime Aufruf von `initialize` fehlschlägt, ist es immer möglich, den neu erstellten Proxy und die Brücke zu ignorieren und neue zu erstellen.
+
+```solidity
+ messenger = _l1messenger;
+ l2TokenBridge = _l2TokenBridge;
+ }
+```
+
+Dies sind die beiden Parameter, die die Brücke kennen muss.
+
+```solidity
+
+ /**************
+ * Einzahlung *
+ **************/
+
+ /** @dev Modifikator, der erfordert, dass der Absender ein EOA ist. Diese Prüfung könnte von einem bösartigen
+ * Vertrag über initcode umgangen werden, aber sie kümmert sich um den Benutzerfehler, den wir vermeiden wollen.
+ */
+ modifier onlyEOA() {
+ // Wird verwendet, um Einzahlungen von Verträgen zu stoppen (verhindert versehentlich verlorene Tokens)
+ require(!Address.isContract(msg.sender), "Konto nicht EOA");
+ _;
+ }
+```
+
+Dies ist der Grund, warum wir die `Address`-Dienstprogramme von OpenZeppelin benötigten.
+
+```solidity
+ /**
+ * @dev Diese Funktion kann ohne Daten aufgerufen werden
+ * um einen Betrag von ETH auf das Guthaben des Aufrufers auf L2 einzuzahlen.
+ * Da die Empfangsfunktion keine Daten entgegennimmt, wird ein konservativer
+ * Standardbetrag an L2 weitergeleitet.
+ */
+ receive() external payable onlyEOA {
+ _initiateETHDeposit(msg.sender, msg.sender, 200_000, bytes(""));
+ }
+```
+
+Diese Funktion existiert zu Testzwecken.
+Beachten Sie, dass sie nicht in den Schnittstellendefinitionen erscheint – sie ist nicht für den normalen Gebrauch bestimmt.
+
+```solidity
+ /**
+ * @inheritdoc IL1StandardBridge
+ */
+ function depositETH(uint32 _l2Gas, bytes calldata _data) external payable onlyEOA {
+ _initiateETHDeposit(msg.sender, msg.sender, _l2Gas, _data);
+ }
+
+ /**
+ * @inheritdoc IL1StandardBridge
+ */
+ function depositETHTo(
+ address _to,
+ uint32 _l2Gas,
+ bytes calldata _data
+ ) external payable {
+ _initiateETHDeposit(msg.sender, _to, _l2Gas, _data);
+ }
+```
+
+Diese beiden Funktionen sind Wrapper um `_initiateETHDeposit`, die Funktion, die die eigentliche ETH-Einzahlung abwickelt.
+
+```solidity
+ /**
+ * @dev Führt die Logik für Einzahlungen durch, indem der ETH gespeichert und das L2-ETH-Gateway
+ * über die Einzahlung informiert wird.
+ * @param _from Konto, von dem die Einzahlung auf L1 abgezogen wird.
+ * @param _to Konto, dem die Einzahlung auf L2 gutgeschrieben wird.
+ * @param _l2Gas Gaslimit, das erforderlich ist, um die Einzahlung auf L2 abzuschließen.
+ * @param _data Optionale Daten zur Weiterleitung an L2. Diese Daten werden
+ * lediglich als Annehmlichkeit für externe Verträge zur Verfügung gestellt. Abgesehen von der Durchsetzung einer maximalen
+ * Länge geben diese Verträge keine Garantien über ihren Inhalt.
+ */
+ function _initiateETHDeposit(
+ address _from,
+ address _to,
+ uint32 _l2Gas,
+ bytes memory _data
+ ) internal {
+ // Konstruiere Calldata für den finalizeDeposit-Aufruf
+ bytes memory message = abi.encodeWithSelector(
+```
+
+Die Funktionsweise von Cross-Domain-Nachrichten besteht darin, dass der Zielvertrag mit der Nachricht als Calldata aufgerufen wird.
+Solidity-Verträge interpretieren ihre Calldata immer gemäß
+[den ABI-Spezifikationen](https://docs.soliditylang.org/en/v0.8.12/abi-spec.html).
+Die Solidity-Funktion [`abi.encodeWithSelector`](https://docs.soliditylang.org/en/v0.8.12/units-and-global-variables.html#abi-encoding-and-decoding-functions) erstellt diese Calldata.
+
+```solidity
+ IL2ERC20Bridge.finalizeDeposit.selector,
+ address(0),
+ Lib_PredeployAddresses.OVM_ETH,
+ _from,
+ _to,
+ msg.value,
+ _data
+ );
+```
+
+Die Nachricht hier ist, [die Funktion `finalizeDeposit`](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/L2StandardBridge.sol#L141-L148) mit diesen Parametern aufzurufen:
+
+| Parameter | Wert | Bedeutung |
+| ------------------------------- | ---------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| \_l1Token | Adresse(0) | Sonderwert für ETH (das kein ERC-20-Token ist) auf L1 |
+| \_l2Token | Lib_PredeployAddresses.OVM_ETH | Der L2-Vertrag, der ETH auf Optimism verwaltet, `0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000` (dieser Vertrag ist nur für den internen Gebrauch von Optimism bestimmt) |
+| \_from | \_from | Die Adresse auf L1, die die ETH sendet |
+| \_to | \_to | Die Adresse auf L2, die die ETH empfängt |
+| Betrag | msg.value | Gesendeter Betrag in Wei (der bereits an die Brücke gesendet wurde) |
+| \_data | \_data | Zusätzliche Daten, die an die Einzahlung angehängt werden |
+
+```solidity
+ // Senden Sie Calldata nach L2
+ // slither-disable-next-line reentrancy-events
+ sendCrossDomainMessage(l2TokenBridge, _l2Gas, message);
+```
+
+Senden Sie die Nachricht über den Cross-Domain-Messenger.
+
+```solidity
+ // slither-disable-next-line reentrancy-events
+ emit ETHDepositInitiated(_from, _to, msg.value, _data);
+ }
+```
+
+Ein Ereignis auslösen, um jede dezentralisierte Anwendung, die zuhört, über diese Übertragung zu informieren.
+
+```solidity
+ /**
+ * @inheritdoc IL1ERC20Bridge
+ */
+ function depositERC20(
+ .
+ .
+ .
+ ) external virtual onlyEOA {
+ _initiateERC20Deposit(_l1Token, _l2Token, msg.sender, msg.sender, _amount, _l2Gas, _data);
+ }
+
+ /**
+ * @inheritdoc IL1ERC20Bridge
+ */
+ function depositERC20To(
+ .
+ .
+ .
+ ) external virtual {
+ _initiateERC20Deposit(_l1Token, _l2Token, msg.sender, _to, _amount, _l2Gas, _data);
+ }
+```
+
+Diese beiden Funktionen sind Wrapper um `_initiateERC20Deposit`, die Funktion, die die eigentliche ERC-20-Einzahlung abwickelt.
+
+```solidity
+ /**
+ * @dev Führt die Logik für Einzahlungen durch, indem der L2 Deposited Token
+ * Vertrag über die Einzahlung informiert wird und ein Handler aufgerufen wird, um die L1-Mittel zu sperren. (z. B. transferFrom)
+ *
+ * @param _l1Token Adresse des L1 ERC20, den wir einzahlen
+ * @param _l2Token Adresse des entsprechenden L2 ERC20 auf L1
+ * @param _from Konto, von dem die Einzahlung auf L1 abgezogen wird
+ * @param _to Konto, dem die Einzahlung auf L2 gutgeschrieben wird
+ * @param _amount Einzuzahlender Betrag des ERC20.
+ * @param _l2Gas Gaslimit, das erforderlich ist, um die Einzahlung auf L2 abzuschließen.
+ * @param _data Optionale Daten zur Weiterleitung an L2. Diese Daten werden
+ * lediglich als Annehmlichkeit für externe Verträge zur Verfügung gestellt. Abgesehen von der Durchsetzung einer maximalen
+ * Länge geben diese Verträge keine Garantien über ihren Inhalt.
+ */
+ function _initiateERC20Deposit(
+ address _l1Token,
+ address _l2Token,
+ address _from,
+ address _to,
+ uint256 _amount,
+ uint32 _l2Gas,
+ bytes calldata _data
+ ) internal {
+```
+
+Diese Funktion ist ähnlich wie `_initiateETHDeposit` oben, mit einigen wichtigen Unterschieden.
+Der erste Unterschied besteht darin, dass diese Funktion die Token-Adressen und den zu übertragenden Betrag als Parameter erhält.
+Im Fall von ETH enthält der Aufruf der Brücke bereits die Übertragung des Assets auf das Brückenkonto (`msg.value`).
+
+```solidity
+ // Wenn eine Einzahlung auf L1 initiiert wird, überträgt die L1-Brücke die Mittel an sich selbst für zukünftige
+ // Auszahlungen. safeTransferFrom prüft auch, ob der Vertrag Code hat, sodass dies fehlschlägt, wenn
+ // _from ein EOA oder address(0) ist.
+ // slither-disable-next-line reentrancy-events, reentrancy-benign
+ IERC20(_l1Token).safeTransferFrom(_from, address(this), _amount);
+```
+
+Übertragungen von ERC-20-Token folgen einem anderen Prozess als ETH:
+
+1. Der Benutzer (`_from`) erteilt der Brücke eine Freigabe, um die entsprechenden Tokens zu übertragen.
+2. Der Benutzer ruft die Brücke mit der Adresse des Token-Vertrags, dem Betrag usw. auf.
+3. Die Brücke überträgt die Tokens (an sich selbst) als Teil des Einzahlungsprozesses.
+
+Der erste Schritt kann in einer separaten Transaktion von den letzten beiden erfolgen.
+Front-Running ist jedoch kein Problem, da die beiden Funktionen, die `_initiateERC20Deposit` aufrufen (`depositERC20` und `depositERC20To`), diese Funktion nur mit `msg.sender` als `_from`-Parameter aufrufen.
+
+```solidity
+ // Konstruiere Calldata für _l2Token.finalizeDeposit(_to, _amount)
+ bytes memory message = abi.encodeWithSelector(
+ IL2ERC20Bridge.finalizeDeposit.selector,
+ _l1Token,
+ _l2Token,
+ _from,
+ _to,
+ _amount,
+ _data
+ );
+
+ // Sende Calldata nach L2
+ // slither-disable-next-line reentrancy-events, reentrancy-benign
+ sendCrossDomainMessage(l2TokenBridge, _l2Gas, message);
+
+ // slither-disable-next-line reentrancy-benign
+ deposits[_l1Token][_l2Token] = deposits[_l1Token][_l2Token] + _amount;
+```
+
+Fügen Sie den eingezahlten Betrag an Tokens zur `deposits`-Datenstruktur hinzu.
+Es könnten mehrere Adressen auf L2 vorhanden sein, die demselben L1-ERC-20-Token entsprechen, daher ist es nicht ausreichend, das Guthaben der Brücke am L1-ERC-20-Token zu verwenden, um die Einzahlungen zu verfolgen.
+
+```solidity
+
+ // slither-disable-next-line reentrancy-events
+ emit ERC20DepositInitiated(_l1Token, _l2Token, _from, _to, _amount, _data);
+ }
+
+ /*************************
+ * Cross-Chain-Funktionen *
+ *************************/
+
+ /**
+ * @inheritdoc IL1StandardBridge
+ */
+ function finalizeETHWithdrawal(
+ address _from,
+ address _to,
+ uint256 _amount,
+ bytes calldata _data
+```
+
+Die L2-Brücke sendet eine Nachricht an den L2-Cross-Domain-Messenger, der bewirkt, dass der L1-Cross-Domain-Messenger diese Funktion aufruft (natürlich sobald die [Transaktion, die die Nachricht finalisiert](https://community.optimism.io/docs/developers/bridge/messaging/#fees-for-l2-%E2%87%92-l1-transactions), auf L1 übermittelt wurde).
+
+```solidity
+ ) external onlyFromCrossDomainAccount(l2TokenBridge) {
+```
+
+Stellen Sie sicher, dass dies eine _legitime_ Nachricht ist, die vom Cross-Domain-Messenger kommt und von der L2-Token-Brücke stammt.
+Diese Funktion wird verwendet, um ETH von der Brücke abzuheben, daher müssen wir sicherstellen, dass sie nur vom autorisierten Aufrufer aufgerufen wird.
+
+```solidity
+ // slither-disable-next-line reentrancy-events
+ (bool success, ) = _to.call{ value: _amount }(new bytes(0));
+```
+
+Die Art und Weise, ETH zu übertragen, besteht darin, den Empfänger mit dem Betrag in Wei im `msg.value` aufzurufen.
+
+```solidity
+ require(success, "TransferHelper::safeTransferETH: ETH transfer failed");
+
+ // slither-disable-next-line reentrancy-events
+ emit ETHWithdrawalFinalized(_from, _to, _amount, _data);
+```
+
+Ein Ereignis über die Auszahlung auslösen.
+
+```solidity
+ }
+
+ /**
+ * @inheritdoc IL1ERC20Bridge
+ */
+ function finalizeERC20Withdrawal(
+ address _l1Token,
+ address _l2Token,
+ address _from,
+ address _to,
+ uint256 _amount,
+ bytes calldata _data
+ ) external onlyFromCrossDomainAccount(l2TokenBridge) {
+```
+
+Diese Funktion ist ähnlich wie `finalizeETHWithdrawal` oben, mit den notwendigen Änderungen für ERC-20-Tokens.
+
+```solidity
+ deposits[_l1Token][_l2Token] = deposits[_l1Token][_l2Token] - _amount;
+```
+
+Aktualisieren Sie die `deposits`-Datenstruktur.
+
+```solidity
+
+ // Wenn eine Auszahlung auf L1 finalisiert wird, überträgt die L1-Brücke die Mittel an den Auszahlenden
+ // slither-disable-next-line reentrancy-events
+ IERC20(_l1Token).safeTransfer(_to, _amount);
+
+ // slither-disable-next-line reentrancy-events
+ emit ERC20WithdrawalFinalized(_l1Token, _l2Token, _from, _to, _amount, _data);
+ }
+
+
+ /*****************************
+ * Vorübergehend - Migration von ETH *
+ *****************************/
+
+ /**
+ * @dev Fügt ETH-Guthaben zum Konto hinzu. Dies soll ermöglichen, dass ETH
+ * von einem alten Gateway zu einem neuen Gateway migriert wird.
+ * HINWEIS: Dies wird nur für ein Upgrade beibehalten, damit wir die migrierte ETH aus dem
+ * alten Vertrag empfangen können
+ */
+ function donateETH() external payable {}
+}
+```
+
+Es gab eine frühere Implementierung der Brücke.
+Als wir von dieser Implementierung zu dieser wechselten, mussten wir alle Assets verschieben.
+ERC-20-Tokens können einfach verschoben werden.
+Um jedoch ETH an einen Vertrag zu übertragen, benötigen Sie die Zustimmung dieses Vertrags, was uns `donateETH` bietet.
+
+## ERC-20-Tokens auf L2 {#erc-20-tokens-on-l2}
+
+Damit ein ERC-20-Token in die Standardbrücke passt, muss es der Standardbrücke und _nur_ der Standardbrücke erlauben, Token zu prägen.
+Dies ist notwendig, weil die Brücken sicherstellen müssen, dass die Anzahl der auf Optimism zirkulierenden Tokens gleich der Anzahl der im L1-Brückenvertrag gesperrten Tokens ist.
+Wenn es zu viele Tokens auf L2 gibt, könnten einige Benutzer ihre Assets nicht zurück auf L1 überbrücken.
+Anstelle einer vertrauenswürdigen Brücke würden wir im Wesentlichen [Mindestreservebanking](https://www.investopedia.com/terms/f/fractionalreservebanking.asp) nachbilden.
+Wenn es zu viele Tokens auf L1 gibt, würden einige dieser Tokens für immer im Brückenvertrag gesperrt bleiben, weil es keine Möglichkeit gibt, sie ohne das Verbrennen von L2-Tokens freizugeben.
+
+### IL2StandardERC20 {#il2standarderc20}
+
+Jeder ERC-20-Token auf L2, der die Standardbrücke verwendet, muss [diese Schnittstelle](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/standards/IL2StandardERC20.sol) bereitstellen, die die Funktionen und Ereignisse enthält, die die Standardbrücke benötigt.
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+```
+
+[Die Standard-ERC-20-Schnittstelle](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol) enthält nicht die Funktionen `mint` und `burn`.
+Diese Methoden sind nicht durch [den ERC-20-Standard](https://eips.ethereum.org/EIPS/eip-20) vorgeschrieben, der die Mechanismen zur Erstellung und Zerstörung von Tokens nicht spezifiziert.
+
+```solidity
+import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+```
+
+[Die ERC-165-Schnittstelle](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/introspection/IERC165.sol) wird verwendet, um anzugeben, welche Funktionen ein Vertrag bereitstellt.
+[Sie können den Standard hier lesen](https://eips.ethereum.org/EIPS/eip-165).
+
+```solidity
+interface IL2StandardERC20 is IERC20, IERC165 {
+ function l1Token() external returns (address);
+```
+
+Diese Funktion gibt die Adresse des L1-Tokens an, das auf diesen Vertrag überbrückt wird.
+Beachten Sie, dass wir keine ähnliche Funktion in die entgegengesetzte Richtung haben.
+Wir müssen in der Lage sein, jeden L1-Token zu überbrücken, unabhängig davon, ob bei seiner Implementierung eine L2-Unterstützung geplant war oder nicht.
+
+```solidity
+
+ function mint(address _to, uint256 _amount) external;
+
+ function burn(address _from, uint256 _amount) external;
+
+ event Mint(address indexed _account, uint256 _amount);
+ event Burn(address indexed _account, uint256 _amount);
+}
+```
+
+Funktionen und Ereignisse zum Prägen (Erstellen) und Verbrennen (Zerstören) von Tokens.
+Die Brücke sollte die einzige Entität sein, die diese Funktionen ausführen kann, um sicherzustellen, dass die Anzahl der Tokens korrekt ist (gleich der Anzahl der auf L1 gesperrten Tokens).
+
+### L2StandardERC20 {#L2StandardERC20}
+
+[Dies ist unsere Implementierung der `IL2StandardERC20`-Schnittstelle](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/standards/L2StandardERC20.sol).
+Sofern Sie keine benutzerdefinierte Logik benötigen, sollten Sie diese verwenden.
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+```
+
+[Der OpenZeppelin ERC-20-Vertrag](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol).
+Optimism glaubt nicht daran, das Rad neu zu erfinden, besonders wenn das Rad gut geprüft ist und vertrauenswürdig genug sein muss, um Vermögenswerte zu halten.
+
+```solidity
+import "./IL2StandardERC20.sol";
+
+contract L2StandardERC20 is IL2StandardERC20, ERC20 {
+ address public l1Token;
+ address public l2Bridge;
+```
+
+Dies sind die beiden zusätzlichen Konfigurationsparameter, die wir benötigen und die ERC-20 normalerweise nicht hat.
+
+```solidity
+
+ /**
+ * @param _l2Bridge Adresse der L2-Standardbrücke.
+ * @param _l1Token Adresse des entsprechenden L1-Tokens.
+ * @param _name ERC20-Name.
+ * @param _symbol ERC20-Symbol.
+ */
+ constructor(
+ address _l2Bridge,
+ address _l1Token,
+ string memory _name,
+ string memory _symbol
+ ) ERC20(_name, _symbol) {
+ l1Token = _l1Token;
+ l2Bridge = _l2Bridge;
+ }
+```
+
+Zuerst den Konstruktor für den Vertrag aufrufen, von dem wir erben (`ERC20(_name, _symbol)`) und dann unsere eigenen Variablen setzen.
+
+```solidity
+
+ modifier onlyL2Bridge() {
+ require(msg.sender == l2Bridge, "Nur die L2-Brücke kann prägen und verbrennen");
+ _;
+ }
+
+
+ // slither-disable-next-line external-function
+ function supportsInterface(bytes4 _interfaceId) public pure returns (bool) {
+ bytes4 firstSupportedInterface = bytes4(keccak256("supportsInterface(bytes4)")); // ERC165
+ bytes4 secondSupportedInterface = IL2StandardERC20.l1Token.selector ^
+ IL2StandardERC20.mint.selector ^
+ IL2StandardERC20.burn.selector;
+ return _interfaceId == firstSupportedInterface || _interfaceId == secondSupportedInterface;
+ }
+```
+
+So funktioniert [ERC-165](https://eips.ethereum.org/EIPS/eip-165).
+Jede Schnittstelle ist eine Anzahl von unterstützten Funktionen und wird als [Exklusiv-Oder](https://en.wikipedia.org/wiki/Exclusive_or) der [ABI-Funktionsselektoren](https://docs.soliditylang.org/en/v0.8.12/abi-spec.html#function-selector) dieser Funktionen identifiziert.
+
+Die L2-Brücke verwendet ERC-165 als Plausibilitätsprüfung, um sicherzustellen, dass der ERC-20-Vertrag, an den sie Assets sendet, ein `IL2StandardERC20` ist.
+
+**Hinweis:** Es gibt nichts, was betrügerische Verträge daran hindert, falsche Antworten auf `supportsInterface` zu geben, daher ist dies ein Plausibilitätsprüfungsmechanismus, _kein_ Sicherheitsmechanismus.
+
+```solidity
+ // slither-disable-next-line external-function
+ function mint(address _to, uint256 _amount) public virtual onlyL2Bridge {
+ _mint(_to, _amount);
+
+ emit Mint(_to, _amount);
+ }
+
+ // slither-disable-next-line external-function
+ function burn(address _from, uint256 _amount) public virtual onlyL2Bridge {
+ _burn(_from, _amount);
+
+ emit Burn(_from, _amount);
+ }
+}
+```
+
+Nur die L2-Brücke darf Assets prägen und verbrennen.
+
+`_mint` und `_burn` sind tatsächlich im [OpenZeppelin ERC-20-Vertrag](/developers/tutorials/erc20-annotated-code/#the-_mint-and-_burn-functions-_mint-and-_burn) definiert.
+Dieser Vertrag macht sie nur nicht extern zugänglich, weil die Bedingungen zum Prägen und Verbrennen von Tokens so vielfältig sind wie die Anzahl der Verwendungsmöglichkeiten von ERC-20.
+
+## L2-Brücken-Code {#l2-bridge-code}
+
+Dies ist der Code, der die Brücke auf Optimism ausführt.
+[Die Quelle für diesen Vertrag befindet sich hier](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/L2StandardBridge.sol).
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+/* Schnittstellen-Importe */
+import { IL1StandardBridge } from "../../L1/messaging/IL1StandardBridge.sol";
+import { IL1ERC20Bridge } from "../../L1/messaging/IL1ERC20Bridge.sol";
+import { IL2ERC20Bridge } from "./IL2ERC20Bridge.sol";
+```
+
+Die [IL2ERC20Bridge](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/IL2ERC20Bridge.sol)-Schnittstelle ist dem [L1-Äquivalent](#IL1ERC20Bridge), das wir oben gesehen haben, sehr ähnlich.
+Es gibt zwei wesentliche Unterschiede:
+
+1. Auf L1 initiieren Sie Einzahlungen und finalisieren Auszahlungen.
+ Hier initiieren Sie Auszahlungen und finalisieren Einzahlungen.
+2. Auf L1 ist es notwendig, zwischen ETH- und ERC-20-Tokens zu unterscheiden.
+ Auf L2 können wir dieselben Funktionen für beide verwenden, da intern ETH-Guthaben auf Optimism als ERC-20-Token mit der Adresse [0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000](https://explorer.optimism.io/address/0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000) behandelt werden.
+
+```solidity
+/* Bibliotheks-Importe */
+import { ERC165Checker } from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
+import { CrossDomainEnabled } from "../../libraries/bridge/CrossDomainEnabled.sol";
+import { Lib_PredeployAddresses } from "../../libraries/constants/Lib_PredeployAddresses.sol";
+
+/* Vertrags-Importe */
+import { IL2StandardERC20 } from "../../standards/IL2StandardERC20.sol";
+
+/**
+ * @title L2StandardBridge
+ * @dev Die L2-Standardbrücke ist ein Vertrag, der zusammen mit der L1-Standardbrücke
+ * ETH- und ERC20-Übergänge zwischen L1 und L2 ermöglicht.
+ * Dieser Vertrag fungiert als Minter für neue Tokens, wenn er von Einzahlungen in die L1-Standardbrücke
+ * erfährt.
+ * Dieser Vertrag fungiert auch als Burner der für die Auszahlung vorgesehenen Tokens und informiert die L1-
+ * Brücke, L1-Mittel freizugeben.
+ */
+contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
+ /********************************
+ * Externe Vertragsreferenzen *
+ ********************************/
+
+ address public l1TokenBridge;
+```
+
+Die Adresse der L1-Brücke im Auge behalten.
+Beachten Sie, dass wir im Gegensatz zum L1-Äquivalent hier diese Variable _brauchen_.
+Die Adresse der L1-Brücke ist nicht im Voraus bekannt.
+
+```solidity
+
+ /***************
+ * Konstruktor *
+ ***************/
+
+ /**
+ * @param _l2CrossDomainMessenger Von diesem Vertrag verwendeter domänenübergreifender Messenger.
+ * @param _l1TokenBridge Adresse der auf der Hauptkette bereitgestellten L1-Brücke.
+ */
+ constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)
+ CrossDomainEnabled(_l2CrossDomainMessenger)
+ {
+ l1TokenBridge = _l1TokenBridge;
+ }
+
+ /***************
+ * Auszahlung *
+ ***************/
+
+ /**
+ * @inheritdoc IL2ERC20Bridge
+ */
+ function withdraw(
+ address _l2Token,
+ uint256 _amount,
+ uint32 _l1Gas,
+ bytes calldata _data
+ ) external virtual {
+ _initiateWithdrawal(_l2Token, msg.sender, msg.sender, _amount, _l1Gas, _data);
+ }
+
+ /**
+ * @inheritdoc IL2ERC20Bridge
+ */
+ function withdrawTo(
+ address _l2Token,
+ address _to,
+ uint256 _amount,
+ uint32 _l1Gas,
+ bytes calldata _data
+ ) external virtual {
+ _initiateWithdrawal(_l2Token, msg.sender, _to, _amount, _l1Gas, _data);
+ }
+```
+
+Diese beiden Funktionen leiten Auszahlungen ein.
+Beachten Sie, dass die L1-Token-Adresse nicht angegeben werden muss.
+Es wird erwartet, dass L2-Tokens uns die Adresse des L1-Äquivalents mitteilen.
+
+```solidity
+
+ /**
+ * @dev Führt die Logik für Auszahlungen durch, indem der Token verbrannt und
+ * das L1-Token-Gateway über die Auszahlung informiert wird.
+ * @param _l2Token Adresse des L2-Tokens, bei dem die Auszahlung eingeleitet wird.
+ * @param _from Konto, von dem die Auszahlung auf L2 abgezogen wird.
+ * @param _to Konto, dem die Auszahlung auf L1 gutgeschrieben wird.
+ * @param _amount Betrag des abzuhebenden Tokens.
+ * @param _l1Gas Unbenutzt, aber aus Gründen der potenziellen Vorwärtskompatibilität enthalten.
+ * @param _data Optionale Daten zur Weiterleitung an L1. Diese Daten werden
+ * lediglich als Annehmlichkeit für externe Verträge zur Verfügung gestellt. Abgesehen von der Durchsetzung einer maximalen
+ * Länge geben diese Verträge keine Garantien über ihren Inhalt.
+ */
+ function _initiateWithdrawal(
+ address _l2Token,
+ address _from,
+ address _to,
+ uint256 _amount,
+ uint32 _l1Gas,
+ bytes calldata _data
+ ) internal {
+ // Wenn eine Auszahlung eingeleitet wird, verbrennen wir die Mittel des Auszahlenden, um eine nachfolgende L2-
+ // Nutzung zu verhindern
+ // slither-disable-next-line reentrancy-events
+ IL2StandardERC20(_l2Token).burn(msg.sender, _amount);
+```
+
+Beachten Sie, dass wir uns _nicht_ auf den `_from`-Parameter verlassen, sondern auf `msg.sender`, was viel schwerer zu fälschen ist (soweit ich weiß, unmöglich).
+
+```solidity
+
+ // Konstruiere Calldata für l1TokenBridge.finalizeERC20Withdrawal(_to, _amount)
+ // slither-disable-next-line reentrancy-events
+ address l1Token = IL2StandardERC20(_l2Token).l1Token();
+ bytes memory message;
+
+ if (_l2Token == Lib_PredeployAddresses.OVM_ETH) {
+```
+
+Auf L1 ist es notwendig, zwischen ETH und ERC-20 zu unterscheiden.
+
+```solidity
+ message = abi.encodeWithSelector(
+ IL1StandardBridge.finalizeETHWithdrawal.selector,
+ _from,
+ _to,
+ _amount,
+ _data
+ );
+ } else {
+ message = abi.encodeWithSelector(
+ IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
+ l1Token,
+ _l2Token,
+ _from,
+ _to,
+ _amount,
+ _data
+ );
+ }
+
+ // Nachricht an L1-Brücke senden
+ // slither-disable-next-line reentrancy-events
+ sendCrossDomainMessage(l1TokenBridge, _l1Gas, message);
+
+ // slither-disable-next-line reentrancy-events
+ emit WithdrawalInitiated(l1Token, _l2Token, msg.sender, _to, _amount, _data);
+ }
+
+ /************************************
+ * Cross-Chain-Funktion: Einzahlung *
+ ************************************/
+
+ /**
+ * @inheritdoc IL2ERC20Bridge
+ */
+ function finalizeDeposit(
+ address _l1Token,
+ address _l2Token,
+ address _from,
+ address _to,
+ uint256 _amount,
+ bytes calldata _data
+```
+
+Diese Funktion wird von `L1StandardBridge` aufgerufen.
+
+```solidity
+ ) external virtual onlyFromCrossDomainAccount(l1TokenBridge) {
+```
+
+Stellen Sie sicher, dass die Quelle der Nachricht legitim ist.
+Dies ist wichtig, da diese Funktion `_mint` aufruft und verwendet werden könnte, um Tokens auszugeben, die nicht durch Tokens gedeckt sind, die die Brücke auf L1 besitzt.
+
+```solidity
+ // Prüfen Sie, ob der Ziel-Token konform ist und
+ // überprüfen Sie, ob der eingezahlte Token auf L1 mit der L2-Darstellung des eingezahlten Tokens hier übereinstimmt
+ if (
+ // slither-disable-next-line reentrancy-events
+ ERC165Checker.supportsInterface(_l2Token, 0x1d1d8b63) &&
+ _l1Token == IL2StandardERC20(_l2Token).l1Token()
+```
+
+Plausibilitätsprüfungen:
+
+1. Die richtige Schnittstelle wird unterstützt
+2. Die L1-Adresse des L2-ERC-20-Vertrags stimmt mit der L1-Quelle der Tokens überein
+
+```solidity
+ ) {
+ // Wenn eine Einzahlung abgeschlossen ist, schreiben wir dem Konto auf L2 den gleichen Betrag an
+ // Tokens gut.
+ // slither-disable-next-line reentrancy-events
+ IL2StandardERC20(_l2Token).mint(_to, _amount);
+ // slither-disable-next-line reentrancy-events
+ emit DepositFinalized(_l1Token, _l2Token, _from, _to, _amount, _data);
+```
+
+Wenn die Plausibilitätsprüfungen erfolgreich sind, schließen Sie die Einzahlung ab:
+
+1. Prägen Sie die Tokens
+2. Das entsprechende Ereignis auslösen
+
+```solidity
+ } else {
+ // Entweder ist der L2-Token, in den eingezahlt wird, mit der korrekten Adresse
+ // seines L1-Tokens nicht einverstanden oder er unterstützt nicht die korrekte Schnittstelle.
+ // Dies sollte nur passieren, wenn es einen bösartigen L2-Token gibt oder wenn ein Benutzer irgendwie
+ // die falsche L2-Token-Adresse für die Einzahlung angegeben hat.
+ // In jedem Fall stoppen wir den Prozess hier und erstellen eine Auszahlungsnachricht
+ //, damit Benutzer in einigen Fällen ihre Gelder abheben können.
+ // Es gibt keine Möglichkeit, bösartige Token-Verträge vollständig zu verhindern, aber dies begrenzt
+ // Benutzerfehler und mildert einige Formen von bösartigem Vertragsverhalten.
+```
+
+Wenn ein Benutzer einen erkennbaren Fehler gemacht hat, indem er die falsche L2-Token-Adresse verwendet hat, möchten wir die Einzahlung stornieren und die Tokens auf L1 zurückgeben.
+Der einzige Weg, wie wir dies von L2 aus tun können, ist das Senden einer Nachricht, die den Fehler-Anfechtungszeitraum abwarten muss, aber das ist für den Benutzer viel besser als der dauerhafte Verlust der Tokens.
+
+```solidity
+ bytes memory message = abi.encodeWithSelector(
+ IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
+ _l1Token,
+ _l2Token,
+ _to, // hier _to und _from vertauscht, um die Einzahlung an den Absender zurückzuspringen
+ _from,
+ _amount,
+ _data
+ );
+
+ // Nachricht an die L1-Brücke senden
+ // slither-disable-next-line reentrancy-events
+ sendCrossDomainMessage(l1TokenBridge, 0, message);
+ // slither-disable-next-line reentrancy-events
+ emit DepositFailed(_l1Token, _l2Token, _from, _to, _amount, _data);
+ }
+ }
+}
+```
+
+## Fazit {#conclusion}
+
+Die Standard-Brücke ist der flexibelste Mechanismus für Asset-Übertragungen.
+Da er jedoch so generisch ist, ist er nicht immer der einfachste zu verwendende Mechanismus.
+Insbesondere für Auszahlungen bevorzugen die meisten Benutzer [Drittanbieter-Brücken](https://optimism.io/apps#bridge), die nicht auf den Anfechtungszeitraum warten und keinen Merkle-Beweis benötigen, um die Auszahlung abzuschließen.
+
+Diese Brücken funktionieren typischerweise, indem sie Assets auf L1 haben, die sie sofort gegen eine geringe Gebühr (oft weniger als die Gaskosten für eine Standard-Brückenauszahlung) zur Verfügung stellen.
+Wenn die Brücke (oder die Personen, die sie betreiben) erwartet, dass sie auf L1 knapp bei Kasse ist, überträgt sie ausreichend Vermögenswerte von L2. Da es sich hierbei um sehr große Auszahlungen handelt, werden die Auszahlungskosten auf einen großen Betrag verteilt und machen einen viel kleineren Prozentsatz aus.
+
+Hoffentlich hat Ihnen dieser Artikel geholfen, besser zu verstehen, wie Layer 2 funktioniert und wie man klaren und sicheren Solidity-Code schreibt.
+
+[Hier finden Sie mehr von meiner Arbeit](https://cryptodocguy.pro/).
diff --git a/public/content/translations/de/developers/tutorials/reverse-engineering-a-contract/index.md b/public/content/translations/de/developers/tutorials/reverse-engineering-a-contract/index.md
new file mode 100644
index 00000000000..1309b7bf0a5
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/reverse-engineering-a-contract/index.md
@@ -0,0 +1,744 @@
+---
+title: "Reverse Engineering eines Contracts"
+description: Wie Sie einen Contract verstehen, wenn Sie den Quellcode nicht haben
+author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+lang: de
+tags: [ "evm", "Opcodes" ]
+skill: advanced
+published: 2021-12-30
+---
+
+## Einführung {#introduction}
+
+_Auf der Blockchain gibt es keine Geheimnisse_, alles, was geschieht, ist konsistent, nachprüfbar und öffentlich zugänglich. Idealerweise sollten [Contracts ihren Quellcode auf Etherscan veröffentlichen und verifizieren lassen](https://etherscan.io/address/0xb8901acb165ed027e32754e0ffe830802919727f#code). [Das ist jedoch nicht immer der Fall](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f#code). In diesem Artikel lernen Sie, wie Sie Contracts per Reverse Engineering analysieren, indem Sie sich einen Contract ohne Quellcode ansehen: [`0x2510c039cc3b061d79e564b38836da87e31b342f`](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f).
+
+Es gibt Reverse-Compiler, aber sie liefern nicht immer [brauchbare Ergebnisse](https://etherscan.io/bytecode-decompiler?a=0x2510c039cc3b061d79e564b38836da87e31b342f). In diesem Artikel lernen Sie, wie Sie einen Contract manuell per Reverse Engineering analysieren und anhand [der Opcodes](https://github.com/wolflo/evm-opcodes) verstehen können, und wie Sie die Ergebnisse eines Decompilers interpretieren.
+
+Um diesen Artikel zu verstehen, sollten Sie bereits die Grundlagen der EVM kennen und zumindest einigermaßen mit EVM-Assembler vertraut sein. [Hier können Sie mehr über diese Themen lesen](https://medium.com/mycrypto/the-ethereum-virtual-machine-how-does-it-work-9abac2b7c9e).
+
+## Vorbereitung des ausführbaren Codes {#prepare-the-executable-code}
+
+Sie können die Opcodes abrufen, indem Sie auf Etherscan zum Contract navigieren, auf den Tab **Contract** und dann auf **Switch to Opcodes View** klicken. Sie erhalten eine Ansicht mit einem Opcode pro Zeile.
+
+
+
+Um Sprünge (Jumps) zu verstehen, müssen Sie jedoch wissen, wo sich die einzelnen Opcodes im Code befinden. Eine Möglichkeit besteht darin, ein Google Spreadsheet zu öffnen und die Opcodes in Spalte C einzufügen. [Sie können die folgenden Schritte überspringen, indem Sie eine Kopie dieser bereits vorbereiteten Tabelle erstellen](https://docs.google.com/spreadsheets/d/1tKmTJiNjUwHbW64wCKOSJxHjmh0bAUapt6btUYE7kDA/edit?usp=sharing).
+
+Der nächste Schritt besteht darin, die korrekten Code-Positionen zu ermitteln, damit wir die Sprünge verstehen können. Wir tragen die Opcode-Größe in Spalte B und die Position (in hexadezimaler Schreibweise) in Spalte A ein. Geben Sie diese Funktion in Zelle `B1` ein und kopieren Sie sie dann für den Rest von Spalte B bis zum Ende des Codes. Danach können Sie Spalte B ausblenden.
+
+```
+=1+IF(REGEXMATCH(C1,"PUSH"),REGEXEXTRACT(C1,"PUSH(\d+)"),0)
+```
+
+Zuerst fügt diese Funktion ein Byte für den Opcode selbst hinzu und sucht dann nach `PUSH`. Push-Opcodes sind besonders, da sie zusätzliche Bytes für den Wert benötigen, der gepusht wird. Wenn der Opcode ein `PUSH` ist, extrahieren wir die Anzahl der Bytes und addieren sie.
+
+In `A1` setzen Sie den ersten Offset, Null. Geben Sie dann in `A2` diese Funktion ein und kopieren Sie sie wieder für den Rest der Spalte A:
+
+```
+=dec2hex(hex2dec(A1)+B1)
+```
+
+Wir benötigen diese Funktion, um den hexadezimalen Wert zu erhalten, da die Werte, die vor Sprüngen (`JUMP` und `JUMPI`) gepusht werden, in hexadezimaler Form angegeben werden.
+
+## Der Einstiegspunkt (0x00) {#the-entry-point-0x00}
+
+Contracts werden immer ab dem ersten Byte ausgeführt. Dies ist der erste Teil des Codes:
+
+| Offset | Opcode | Stack (nach dem Opcode) |
+| -----: | ------------ | ---------------------------------------------- |
+| 0 | PUSH1 0x80 | 0x80 |
+| 2 | PUSH1 0x40 | 0x40, 0x80 |
+| 4 | MSTORE | Leer |
+| 5 | PUSH1 0x04 | 0x04 |
+| 7 | CALLDATASIZE | CALLDATASIZE 0x04 |
+| 8 | LT | CALLDATASIZE\<4 |
+| 9 | PUSH2 0x005e | 0x5E CALLDATASIZE\<4 |
+| C | JUMPI | Leer |
+
+Dieser Code macht zwei Dinge:
+
+1. Schreibt 0x80 als 32-Byte-Wert in die Speicherstellen 0x40-0x5F (0x80 wird in 0x5F gespeichert, und 0x40-0x5E sind alle Nullen).
+2. Liest die Calldata-Größe. Normalerweise folgen die Calldata für einen Ethereum-Contract [dem ABI (Application Binary Interface)](https://docs.soliditylang.org/en/v0.8.10/abi-spec.html), das mindestens vier Bytes für den Funktions-Selektor erfordert. Wenn die Calldata-Größe kleiner als vier ist, springe zu 0x5E.
+
+
+
+### Der Handler bei 0x5E (für Nicht-ABI-Calldata) {#the-handler-at-0x5e-for-non-abi-call-data}
+
+| Offset | Opcode |
+| -----: | ------------ |
+| 5E | JUMPDEST |
+| 5F | CALLDATASIZE |
+| 60 | PUSH2 0x007c |
+| 63 | JUMPI |
+
+Dieses Snippet beginnt mit einem `JUMPDEST`. EVM-Programme (Ethereum Virtual Machine) lösen eine Ausnahme aus, wenn Sie zu einem Opcode springen, der nicht `JUMPDEST` ist. Dann prüft er die CALLDATASIZE und springt, wenn sie „wahr“ ist (d. h. nicht null), zu 0x7C. Darauf kommen wir unten zu sprechen.
+
+| Offset | Opcode | Stack (nach Opcode) |
+| -----: | ---------- | --------------------------------------------------------------------------------------------------------------------- |
+| 64 | CALLVALUE | [Wei](/glossary/#wei), der durch den Aufruf bereitgestellt wird. Wird in Solidity `msg.value` genannt |
+| 65 | PUSH1 0x06 | 6 CALLVALUE |
+| 67 | PUSH1 0x00 | 0 6 CALLVALUE |
+| 69 | DUP3 | CALLVALUE 0 6 CALLVALUE |
+| 6A | DUP3 | 6 CALLVALUE 0 6 CALLVALUE |
+| 6B | SLOAD | Speicher[6] CALLVALUE 0 6 CALLVALUE |
+
+Wenn es also keine Calldata gibt, lesen wir den Wert von Speicher[6]. Wir wissen noch nicht, was dieser Wert ist, aber wir können nach Transaktionen suchen, die der Contract ohne Calldata erhalten hat. Transaktionen, die nur ETH ohne Calldata (und damit ohne Methode) übertragen, haben in Etherscan die Methode `Transfer`. Tatsächlich ist [die allererste Transaktion, die der Contract erhalten hat](https://etherscan.io/tx/0xeec75287a583c36bcc7ca87685ab41603494516a0f5986d18de96c8e630762e7), ein Transfer.
+
+Wenn wir uns diese Transaktion ansehen und auf **Click to see More** klicken, sehen wir, dass die Calldata, als Input Data bezeichnet, tatsächlich leer sind (`0x`). Beachten Sie auch, dass der Wert 1,559 ETH beträgt, was später relevant sein wird.
+
+
+
+Klicken Sie als Nächstes auf den Tab **State** und erweitern Sie den Contract, den wir per Reverse Engineering analysieren (0x2510...). Sie können sehen, dass sich `Speicher[6]` während der Transaktion geändert hat, und wenn Sie Hex auf **Number** ändern, sehen Sie, dass es 1.559.000.000.000.000.000 wurde, der in Wei übertragene Wert (ich habe die Kommas zur besseren Lesbarkeit hinzugefügt), der dem nächsten Contract-Wert entspricht.
+
+![Die Änderung in Speicher[6]](storage6.png)
+
+Wenn wir uns die Zustandsänderungen ansehen, die durch [andere `Transfer`-Transaktionen aus demselben Zeitraum](https://etherscan.io/tx/0xf708d306de39c422472f43cb975d97b66fd5d6a6863db627067167cbf93d84d1#statechange) verursacht wurden, sehen wir, dass `Speicher[6]` den Wert des Contracts eine Zeit lang nachverfolgt hat. Vorerst nennen wir es `Wert*`. Das Sternchen (`*`) erinnert uns daran, dass wir noch nicht _wissen_, was diese Variable tut, aber sie kann nicht nur dazu dienen, den Contract-Wert zu verfolgen, da es nicht nötig ist, Speicher zu verwenden, der sehr teuer ist, wenn man den Kontostand seines Accounts mit `ADDRESS BALANCE` abrufen kann. Der erste Opcode pusht die eigene Adresse des Contracts. Der zweite liest die Adresse an der Spitze des Stacks und ersetzt sie durch das Guthaben dieser Adresse.
+
+| Offset | Opcode | Stack |
+| -----: | ------------ | ------------------------------------------ |
+| 6C | PUSH2 0x0075 | 0x75 Wert\* CALLVALUE 0 6 CALLVALUE |
+| 6F | SWAP2 | CALLVALUE Wert\* 0x75 0 6 CALLVALUE |
+| 70 | SWAP1 | Wert\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 71 | PUSH2 0x01a7 | 0x01A7 Wert\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 74 | JUMP | |
+
+Wir werden diesen Code am Sprungziel weiterverfolgen.
+
+| Offset | Opcode | Stack |
+| -----: | ---------- | ---------------------------------------------------------- |
+| 1A7 | JUMPDEST | Wert\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1A8 | PUSH1 0x00 | 0x00 Wert\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1AA | DUP3 | CALLVALUE 0x00 Wert\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1AB | NOT | 2^256-CALLVALUE-1 0x00 Wert\* CALLVALUE 0x75 0 6 CALLVALUE |
+
+Das `NOT` ist bitweise, also kehrt es den Wert jedes Bits im Aufrufwert um.
+
+| Offset | Opcode | Stack |
+| -----: | ------------ | ---------------------------------------------------------------------------------------------------- |
+| 1AC | DUP3 | Wert\* 2^256-CALLVALUE-1 0x00 Wert\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1AD | GT | Wert\*>2^256-CALLVALUE-1 0x00 Wert\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1AE | ISZERO | Wert\*\<=2^256-CALLVALUE-1 0x00 Wert\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1AF | PUSH2 0x01df | 0x01DF Wert\*\<=2^256-CALLVALUE-1 0x00 Wert\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1B2 | JUMPI | |
+
+Wir springen, wenn `Wert*` kleiner oder gleich 2^256-CALLVALUE-1 ist. Das sieht nach einer Logik zur Vermeidung von Überläufen aus. Und tatsächlich sehen wir, dass der Contract nach ein paar unsinnigen Operationen (z. B. das Schreiben in den Speicher, der gleich gelöscht wird) bei Offset 0x01DE zurückgesetzt wird, wenn der Überlauf erkannt wird, was ein normales Verhalten ist.
+
+Beachten Sie, dass ein solcher Überlauf extrem unwahrscheinlich ist, da der Aufrufwert plus `Wert*` vergleichbar mit 2^256 Wei sein müsste, was etwa 10^59 ETH entspricht. [Die gesamte ETH-Menge beträgt zum Zeitpunkt der Erstellung dieses Artikels weniger als zweihundert Millionen](https://etherscan.io/stat/supply).
+
+| Offset | Opcode | Stack |
+| -----: | -------- | ---------------------------------------- |
+| 1DF | JUMPDEST | 0x00 Wert\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1E0 | POP | Wert\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1E1 | ADD | Wert\*+CALLVALUE 0x75 0 6 CALLVALUE |
+| 1E2 | SWAP1 | 0x75 Wert\*+CALLVALUE 0 6 CALLVALUE |
+| 1E3 | JUMP | |
+
+Wenn wir hier angekommen sind, erhalten wir `Wert* + CALLVALUE` und springen zu Offset 0x75.
+
+| Offset | Opcode | Stack |
+| -----: | -------- | ------------------------------ |
+| 75 | JUMPDEST | Wert\*+CALLVALUE 0 6 CALLVALUE |
+| 76 | SWAP1 | 0 Wert\*+CALLVALUE 6 CALLVALUE |
+| 77 | SWAP2 | 6 Wert\*+CALLVALUE 0 CALLVALUE |
+| 78 | SSTORE | 0 CALLVALUE |
+
+Wenn wir hier ankommen (was leere Calldata voraussetzt), addieren wir den Aufrufwert zu `Wert*`. Dies stimmt mit dem überein, was `Transfer`-Transaktionen laut unserer Aussage tun.
+
+| Offset | Opcode |
+| -----: | ------ |
+| 79 | POP |
+| 7A | POP |
+| 7B | STOP |
+
+Leeren Sie schließlich den Stack (was nicht notwendig ist) und signalisieren Sie das erfolgreiche Ende der Transaktion.
+
+Zusammenfassend finden Sie hier ein Flussdiagramm für den ursprünglichen Code.
+
+
+
+## Der Handler bei 0x7C {#the-handler-at-0x7c}
+
+Ich habe absichtlich nicht in die Überschrift geschrieben, was dieser Handler tut. Der Punkt ist nicht, Ihnen beizubringen, wie dieser spezielle Contract funktioniert, sondern wie man Contracts per Reverse Engineering analysiert. Sie werden auf die gleiche Weise wie ich lernen, was er tut, indem Sie dem Code folgen.
+
+Wir gelangen von mehreren Stellen hierher:
+
+- Wenn Calldata von 1, 2 oder 3 Bytes vorhanden sind (von Offset 0x63)
+- Wenn die Methodensignatur unbekannt ist (von Offsets 0x42 und 0x5D)
+
+| Offset | Opcode | Stack |
+| -----: | ------------ | ------------------------------------------------------------------------- |
+| 7C | JUMPDEST | |
+| 7D | PUSH1 0x00 | 0x00 |
+| 7F | PUSH2 0x009d | 0x9D 0x00 |
+| 82 | PUSH1 0x03 | 0x03 0x9D 0x00 |
+| 84 | SLOAD | Speicher[3] 0x9D 0x00 |
+
+Dies ist eine weitere Speicherzelle, die ich in keiner Transaktion finden konnte, so dass es schwieriger ist zu wissen, was sie bedeutet. Der folgende Code wird dies verdeutlichen.
+
+| Offset | Opcode | Stack |
+| -----: | ------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 85 | PUSH20 0xffffffffffffffffffffffffffffffffffffffff | 0xff....ff Speicher[3] 0x9D 0x00 |
+| 9A | AND | Speicher[3]-als-Adresse 0x9D 0x00 |
+
+Diese Opcodes kürzen den Wert, den wir aus Speicher[3] lesen, auf 160 Bit, die Länge einer Ethereum-Adresse.
+
+| Offset | Opcode | Stack |
+| -----: | ------ | ------------------------------------------------------------------------------------- |
+| 9B | SWAP1 | 0x9D Speicher[3]-als-Adresse 0x00 |
+| 9C | JUMP | Speicher[3]-als-Adresse 0x00 |
+
+Dieser Sprung ist überflüssig, da wir zum nächsten Opcode gehen. Dieser Code ist bei weitem nicht so gas-effizient, wie er sein könnte.
+
+| Offset | Opcode | Stack |
+| -----: | ---------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
+| 9D | JUMPDEST | Speicher[3]-als-Adresse 0x00 |
+| 9E | SWAP1 | 0x00 Speicher[3]-als-Adresse |
+| 9F | POP | Speicher[3]-als-Adresse |
+| A0 | PUSH1 0x40 | 0x40 Speicher[3]-als-Adresse |
+| A2 | MLOAD | Mem[0x40] Speicher[3]-als-Adresse |
+
+Ganz am Anfang des Codes setzen wir Mem[0x40] auf 0x80. Wenn wir später nach 0x40 suchen, sehen wir, dass wir es nicht ändern - wir können also davon ausgehen, dass es 0x80 ist.
+
+| Offset | Opcode | Stack |
+| -----: | ------------ | ------------------------------------------------------------------------------------------------------- |
+| A3 | CALLDATASIZE | CALLDATASIZE 0x80 Speicher[3]-als-Adresse |
+| A4 | PUSH1 0x00 | 0x00 CALLDATASIZE 0x80 Speicher[3]-als-Adresse |
+| A6 | DUP3 | 0x80 0x00 CALLDATASIZE 0x80 Speicher[3]-als-Adresse |
+| A7 | CALLDATACOPY | 0x80 Speicher[3]-als-Adresse |
+
+Kopieren Sie alle Calldata in den Speicher, beginnend bei 0x80.
+
+| Offset | Opcode | Stack |
+| -----: | ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| A8 | PUSH1 0x00 | 0x00 0x80 Speicher[3]-als-Adresse |
+| AA | DUP1 | 0x00 0x00 0x80 Speicher[3]-als-Adresse |
+| AB | CALLDATASIZE | CALLDATASIZE 0x00 0x00 0x80 Speicher[3]-als-Adresse |
+| AC | DUP4 | 0x80 CALLDATASIZE 0x00 0x00 0x80 Speicher[3]-als-Adresse |
+| AD | DUP6 | Speicher[3]-als-Adresse 0x80 CALLDATASIZE 0x00 0x00 0x80 Speicher[3]-als-Adresse |
+| AE | GAS | GAS Speicher[3]-als-Adresse 0x80 CALLDATASIZE 0x00 0x00 0x80 Speicher[3]-als-Adresse |
+| AF | DELEGATE_CALL | |
+
+Jetzt sind die Dinge viel klarer. Dieser Contract kann als [Proxy](https://blog.openzeppelin.com/proxy-patterns/) fungieren und die Adresse in Speicher[3] aufrufen, um die eigentliche Arbeit zu erledigen. `DELEGATE_CALL` ruft einen separaten Contract auf, bleibt aber im selben Speicher. Das bedeutet, dass der delegierte Contract, für den wir ein Proxy sind, auf denselben Speicherplatz zugreift. Die Parameter für den Aufruf sind:
+
+- _Gas_: Das gesamte verbleibende Gas
+- _Aufgerufene Adresse_: Speicher[3]-als-Adresse
+- _Calldata_: Die CALLDATASIZE-Bytes, die bei 0x80 beginnen, wo wir die ursprünglichen Calldata platziert haben
+- _Rückgabedaten_: Keine (0x00 - 0x00) Wir erhalten die Rückgabedaten auf andere Weise (siehe unten)
+
+| Offset | Opcode | Stack |
+| -----: | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| B0 | RETURNDATASIZE | RETURNDATASIZE (((Aufruf erfolgreich/fehlgeschlagen))) 0x80 Speicher[3]-als-Adresse |
+| B1 | DUP1 | RETURNDATASIZE RETURNDATASIZE (((Aufruf erfolgreich/fehlgeschlagen))) 0x80 Speicher[3]-als-Adresse |
+| B2 | PUSH1 0x00 | 0x00 RETURNDATASIZE RETURNDATASIZE (((Aufruf erfolgreich/fehlgeschlagen))) 0x80 Speicher[3]-als-Adresse |
+| B4 | DUP5 | 0x80 0x00 RETURNDATASIZE RETURNDATASIZE (((Aufruf erfolgreich/fehlgeschlagen))) 0x80 Speicher[3]-als-Adresse |
+| B5 | RETURNDATACOPY | RETURNDATASIZE (((Aufruf erfolgreich/fehlgeschlagen))) 0x80 Speicher[3]-als-Adresse |
+
+Hier kopieren wir alle Rückgabedaten in den Speicherpuffer, beginnend bei 0x80.
+
+| Offset | Opcode | Stack |
+| -----: | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| B6 | DUP2 | (((Aufruf erfolgreich/fehlgeschlagen))) RETURNDATASIZE (((Aufruf erfolgreich/fehlgeschlagen))) 0x80 Speicher[3]-als-Adresse |
+| B7 | DUP1 | (((Aufruf erfolgreich/fehlgeschlagen))) (((Aufruf erfolgreich/fehlgeschlagen))) RETURNDATASIZE (((Aufruf erfolgreich/fehlgeschlagen))) 0x80 Speicher[3]-als-Adresse |
+| B8 | ISZERO | (((ist der Aufruf fehlgeschlagen))) (((Aufruf erfolgreich/fehlgeschlagen))) RETURNDATASIZE (((Aufruf erfolgreich/fehlgeschlagen))) 0x80 Speicher[3]-als-Adresse |
+| B9 | PUSH2 0x00c0 | 0xC0 (((ist der Aufruf fehlgeschlagen))) (((Aufruf erfolgreich/fehlgeschlagen))) RETURNDATASIZE (((Aufruf erfolgreich/fehlgeschlagen))) 0x80 Speicher[3]-als-Adresse |
+| BC | JUMPI | (((Aufruf erfolgreich/fehlgeschlagen))) RETURNDATASIZE (((Aufruf erfolgreich/fehlgeschlagen))) 0x80 Speicher[3]-als-Adresse |
+| BD | DUP2 | RETURNDATASIZE (((Aufruf erfolgreich/fehlgeschlagen))) RETURNDATASIZE (((Aufruf erfolgreich/fehlgeschlagen))) 0x80 Speicher[3]-als-Adresse |
+| BE | DUP5 | 0x80 RETURNDATASIZE (((Aufruf erfolgreich/fehlgeschlagen))) RETURNDATASIZE (((Aufruf erfolgreich/fehlgeschlagen))) 0x80 Speicher[3]-als-Adresse |
+| BF | RETURN | |
+
+Nach dem Aufruf kopieren wir also die Rückgabedaten in den Puffer 0x80 - 0x80+RETURNDATASIZE, und wenn der Aufruf erfolgreich ist, führen wir `RETURN` mit genau diesem Puffer aus.
+
+### DELEGATECALL fehlgeschlagen {#delegatecall-failed}
+
+Wenn wir hier, bei 0xC0, ankommen, bedeutet das, dass der aufgerufene Contract zurückgesetzt wurde. Da wir nur ein Proxy für diesen Contract sind, wollen wir dieselben Daten zurückgeben und ebenfalls zurücksetzen.
+
+| Offset | Opcode | Stack |
+| -----: | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| C0 | JUMPDEST | (((Aufruf erfolgreich/fehlgeschlagen))) RETURNDATASIZE (((Aufruf erfolgreich/fehlgeschlagen))) 0x80 Speicher[3]-als-Adresse |
+| C1 | DUP2 | RETURNDATASIZE (((Aufruf erfolgreich/fehlgeschlagen))) RETURNDATASIZE (((Aufruf erfolgreich/fehlgeschlagen))) 0x80 Speicher[3]-als-Adresse |
+| C2 | DUP5 | 0x80 RETURNDATASIZE (((Aufruf erfolgreich/fehlgeschlagen))) RETURNDATASIZE (((Aufruf erfolgreich/fehlgeschlagen))) 0x80 Speicher[3]-als-Adresse |
+| C3 | REVERT | |
+
+Wir führen also `REVERT` mit demselben Puffer aus, den wir zuvor für `RETURN` verwendet haben: 0x80 - 0x80+RETURNDATASIZE
+
+
+
+## ABI-Aufrufe {#abi-calls}
+
+Wenn die Calldata-Größe vier Bytes oder mehr beträgt, könnte dies ein gültiger ABI-Aufruf sein.
+
+| Offset | Opcode | Stack |
+| -----: | ------------ | ------------------------------------------------------------------------------------------------------------------------- |
+| D | PUSH1 0x00 | 0x00 |
+| F | CALLDATALOAD | (((Erstes Wort (256 Bit) der Calldata))) |
+| 10 | PUSH1 0xe0 | 0xE0 (((Erstes Wort (256 Bit) der Calldata))) |
+| 12 | SHR | (((erste 32 Bits (4 Bytes) der Calldata))) |
+
+Etherscan teilt uns mit, dass `1C` ein unbekannter Opcode ist, da [er hinzugefügt wurde, nachdem Etherscan diese Funktion geschrieben hat](https://eips.ethereum.org/EIPS/eip-145) und sie sie nicht aktualisiert haben. Eine [aktuelle Opcode-Tabelle](https://github.com/wolflo/evm-opcodes) zeigt uns, dass dies eine Rechtsverschiebung ist
+
+| Offset | Opcode | Stack |
+| -----: | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 13 | DUP1 | (((erste 32 Bits (4 Bytes) der Calldata))) (((erste 32 Bits (4 Bytes) der Calldata))) |
+| 14 | PUSH4 0x3cd8045e | 0x3CD8045E (((erste 32 Bits (4 Bytes) der Calldata))) (((erste 32 Bits (4 Bytes) der Calldata))) |
+| 19 | GT | 0x3CD8045E>erste-32-Bits-der-Calldata (((erste 32 Bits (4 Bytes) der Calldata))) |
+| 1A | PUSH2 0x0043 | 0x43 0x3CD8045E>erste-32-Bits-der-Calldata (((erste 32 Bits (4 Bytes) der Calldata))) |
+| 1D | JUMPI | (((erste 32 Bits (4 Bytes) der Calldata))) |
+
+Indem die Tests zum Abgleich der Methodensignatur auf diese Weise in zwei Teile aufgeteilt werden, wird im Durchschnitt die Hälfte der Tests eingespart. Der Code, der unmittelbar darauf folgt, und der Code in 0x43 folgen demselben Muster: `DUP1` die ersten 32 Bits der Calldata, `PUSH4 (((Methodensignatur>`, `EQ` ausführen, um auf Gleichheit zu prüfen, und dann `JUMPI`, wenn die Methodensignatur übereinstimmt. Hier sind die Methodensignaturen, ihre Adressen und, falls bekannt, [die entsprechende Methodendefinition](https://www.4byte.directory/):
+
+| Methode | Methodensignatur | Offset, zu dem gesprungen wird |
+| --------------------------------------------------------------------------------------------------------- | ---------------- | ------------------------------ |
+| [splitter()](https://www.4byte.directory/signatures/?bytes4_signature=0x3cd8045e) | 0x3cd8045e | 0x0103 |
+| ??? | 0x81e580d3 | 0x0138 |
+| [currentWindow()](https://www.4byte.directory/signatures/?bytes4_signature=0xba0bafb4) | 0xba0bafb4 | 0x0158 |
+| ??? | 0x1f135823 | 0x00C4 |
+| [merkleRoot()](https://www.4byte.directory/signatures/?bytes4_signature=0x2eb4a7ab) | 0x2eb4a7ab | 0x00ED |
+
+Wenn keine Übereinstimmung gefunden wird, springt der Code zum [Proxy-Handler bei 0x7C](#the-handler-at-0x7c) in der Hoffnung, dass der Contract, für den wir ein Proxy sind, eine Übereinstimmung hat.
+
+
+
+## splitter() {#splitter}
+
+| Offset | Opcode | Stack |
+| -----: | ------------ | ----------------------------- |
+| 103 | JUMPDEST | |
+| 104 | CALLVALUE | CALLVALUE |
+| 105 | DUP1 | CALLVALUE CALLVALUE |
+| 106 | ISZERO | CALLVALUE==0 CALLVALUE |
+| 107 | PUSH2 0x010f | 0x010F CALLVALUE==0 CALLVALUE |
+| 10A | JUMPI | CALLVALUE |
+| 10B | PUSH1 0x00 | 0x00 CALLVALUE |
+| 10D | DUP1 | 0x00 0x00 CALLVALUE |
+| 10E | REVERT | |
+
+Als Erstes prüft diese Funktion, ob der Aufruf keine ETH gesendet hat. Diese Funktion ist nicht [`payable`](https://solidity-by-example.org/payable/). Wenn uns jemand ETH geschickt hat, muss das ein Fehler sein und wir wollen `REVERT` ausführen, um zu vermeiden, dass diese ETH dort sind, wo sie sie nicht zurückbekommen können.
+
+| Offset | Opcode | Stack |
+| -----: | ------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 10F | JUMPDEST | |
+| 110 | POP | |
+| 111 | PUSH1 0x03 | 0x03 |
+| 113 | SLOAD | (((Speicher[3] a.k.a. der Contract, für den wir ein Proxy sind))) |
+| 114 | PUSH1 0x40 | 0x40 (((Speicher[3] a.k.a. der Contract, für den wir ein Proxy sind))) |
+| 116 | MLOAD | 0x80 (((Speicher[3] a.k.a. der Contract, für den wir ein Proxy sind))) |
+| 117 | PUSH20 0xffffffffffffffffffffffffffffffffffffffff | 0xFF...FF 0x80 (((Speicher[3] a.k.a. der Contract, für den wir ein Proxy sind))) |
+| 12C | SWAP1 | 0x80 0xFF...FF (((Speicher[3] a.k.a. der Contract, für den wir ein Proxy sind))) |
+| 12D | SWAP2 | (((Speicher[3] a.k.a. der Contract, für den wir ein Proxy sind))) 0xFF...FF 0x80 |
+| 12E | AND | ProxyAddr 0x80 |
+| 12F | DUP2 | 0x80 ProxyAddr 0x80 |
+| 130 | MSTORE | 0x80 |
+
+Und 0x80 enthält nun die Proxy-Adresse
+
+| Offset | Opcode | Stack |
+| -----: | ------------ | --------- |
+| 131 | PUSH1 0x20 | 0x20 0x80 |
+| 133 | ADD | 0xA0 |
+| 134 | PUSH2 0x00e4 | 0xE4 0xA0 |
+| 137 | JUMP | 0xA0 |
+
+### Der E4-Code {#the-e4-code}
+
+Wir sehen diese Zeilen zum ersten Mal, aber sie werden mit anderen Methoden geteilt (siehe unten). Wir nennen den Wert im Stack also X und merken uns nur, dass in `splitter()` der Wert dieses X 0xA0 ist.
+
+| Offset | Opcode | Stack |
+| -----: | ---------- | ----------- |
+| E4 | JUMPDEST | X |
+| E5 | PUSH1 0x40 | 0x40 X |
+| E7 | MLOAD | 0x80 X |
+| E8 | DUP1 | 0x80 0x80 X |
+| E9 | SWAP2 | X 0x80 0x80 |
+| EA | SUB | X-0x80 0x80 |
+| EB | SWAP1 | 0x80 X-0x80 |
+| EC | RETURN | |
+
+Dieser Code empfängt also einen Speicherzeiger im Stack (X) und veranlasst den Contract, mit einem Puffer, der 0x80 - X ist, `RETURN` auszuführen.
+
+Im Fall von `splitter()` wird die Adresse zurückgegeben, für die wir ein Proxy sind. `RETURN` gibt den Puffer in 0x80-0x9F zurück, wo wir diese Daten geschrieben haben (Offset 0x130 oben).
+
+## currentWindow() {#currentwindow}
+
+Der Code in den Offsets 0x158-0x163 ist identisch mit dem, was wir in 0x103-0x10E in `splitter()` gesehen haben (außer dem `JUMPI`-Ziel), also wissen wir, dass `currentWindow()` auch nicht `payable` ist.
+
+| Offset | Opcode | Stack |
+| -----: | ------------ | ------------------------------------------------------------------------- |
+| 164 | JUMPDEST | |
+| 165 | POP | |
+| 166 | PUSH2 0x00da | 0xDA |
+| 169 | PUSH1 0x01 | 0x01 0xDA |
+| 16B | SLOAD | Speicher[1] 0xDA |
+| 16C | DUP2 | 0xDA Speicher[1] 0xDA |
+| 16D | JUMP | Speicher[1] 0xDA |
+
+### Der DA-Code {#the-da-code}
+
+Dieser Code wird auch von anderen Methoden verwendet. Wir nennen den Wert im Stack also Y und merken uns nur, dass in `currentWindow()` der Wert dieses Y Speicher[1] ist.
+
+| Offset | Opcode | Stack |
+| -----: | ---------- | ---------------- |
+| DA | JUMPDEST | Y 0xDA |
+| DB | PUSH1 0x40 | 0x40 Y 0xDA |
+| DD | MLOAD | 0x80 Y 0xDA |
+| DE | SWAP1 | Y 0x80 0xDA |
+| DF | DUP2 | 0x80 Y 0x80 0xDA |
+| E0 | MSTORE | 0x80 0xDA |
+
+Schreiben Sie Y nach 0x80-0x9F.
+
+| Offset | Opcode | Stack |
+| -----: | ---------- | -------------- |
+| E1 | PUSH1 0x20 | 0x20 0x80 0xDA |
+| E3 | ADD | 0xA0 0xDA |
+
+Und der Rest wird bereits [oben](#the-e4-code) erklärt. Sprünge zu 0xDA schreiben also den obersten Stack-Wert (Y) in 0x80-0x9F und geben diesen Wert zurück. Im Fall von `currentWindow()` wird Speicher[1] zurückgegeben.
+
+## merkleRoot() {#merkleroot}
+
+Der Code in den Offsets 0xED-0xF8 ist identisch mit dem, was wir in 0x103-0x10E in `splitter()` gesehen haben (abgesehen vom `JUMPI`-Ziel), also wissen wir, dass `merkleRoot()` ebenfalls nicht `payable` ist.
+
+| Offset | Opcode | Stack |
+| -----: | ------------ | ------------------------------------------------------------------------- |
+| F9 | JUMPDEST | |
+| FA | POP | |
+| FB | PUSH2 0x00da | 0xDA |
+| FE | PUSH1 0x00 | 0x00 0xDA |
+| 100 | SLOAD | Speicher[0] 0xDA |
+| 101 | DUP2 | 0xDA Speicher[0] 0xDA |
+| 102 | JUMP | Speicher[0] 0xDA |
+
+Was nach dem Sprung passiert, [haben wir bereits herausgefunden](#the-da-code). `merkleRoot()` gibt also Speicher[0] zurück.
+
+## 0x81e580d3 {#0x81e580d3}
+
+Der Code in den Offsets 0x138-0x143 ist identisch mit dem, was wir in 0x103-0x10E in `splitter()` gesehen haben (abgesehen vom `JUMPI`-Ziel), also wissen wir, dass diese Funktion ebenfalls nicht `payable` ist.
+
+| Offset | Opcode | Stack |
+| -----: | ------------ | ------------------------------------------------------------------------------- |
+| 144 | JUMPDEST | |
+| 145 | POP | |
+| 146 | PUSH2 0x00da | 0xDA |
+| 149 | PUSH2 0x0153 | 0x0153 0xDA |
+| 14C | CALLDATASIZE | CALLDATASIZE 0x0153 0xDA |
+| 14D | PUSH1 0x04 | 0x04 CALLDATASIZE 0x0153 0xDA |
+| 14F | PUSH2 0x018f | 0x018F 0x04 CALLDATASIZE 0x0153 0xDA |
+| 152 | JUMP | 0x04 CALLDATASIZE 0x0153 0xDA |
+| 18F | JUMPDEST | 0x04 CALLDATASIZE 0x0153 0xDA |
+| 190 | PUSH1 0x00 | 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 192 | PUSH1 0x20 | 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 194 | DUP3 | 0x04 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 195 | DUP5 | CALLDATASIZE 0x04 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 196 | SUB | CALLDATASIZE-4 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 197 | SLT | CALLDATASIZE-4\<32 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 198 | ISZERO | CALLDATASIZE-4>=32 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 199 | PUSH2 0x01a0 | 0x01A0 CALLDATASIZE-4>=32 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 19C | JUMPI | 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+
+Es sieht so aus, als ob diese Funktion mindestens 32 Bytes (ein Wort) an Calldata benötigt.
+
+| Offset | Opcode | Stack |
+| -----: | ------ | -------------------------------------------- |
+| 19D | DUP1 | 0x00 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 19E | DUP2 | 0x00 0x00 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 19F | REVERT | |
+
+Wenn sie die Calldata nicht erhält, wird die Transaktion ohne Rückgabedaten zurückgesetzt.
+
+Sehen wir uns an, was passiert, wenn die Funktion die benötigten Calldata _doch_ erhält.
+
+| Offset | Opcode | Stack |
+| -----: | ------------ | ----------------------------------------------------------- |
+| 1A0 | JUMPDEST | 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 1A1 | POP | 0x04 CALLDATASIZE 0x0153 0xDA |
+| 1A2 | CALLDATALOAD | calldataload(4) CALLDATASIZE 0x0153 0xDA |
+
+`calldataload(4)` ist das erste Wort der Calldata _nach_ der Methodensignatur
+
+| Offset | Opcode | Stack |
+| -----: | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 1A3 | SWAP2 | 0x0153 CALLDATASIZE calldataload(4) 0xDA |
+| 1A4 | SWAP1 | CALLDATASIZE 0x0153 calldataload(4) 0xDA |
+| 1A5 | POP | 0x0153 calldataload(4) 0xDA |
+| 1A6 | JUMP | calldataload(4) 0xDA |
+| 153 | JUMPDEST | calldataload(4) 0xDA |
+| 154 | PUSH2 0x016e | 0x016E calldataload(4) 0xDA |
+| 157 | JUMP | calldataload(4) 0xDA |
+| 16E | JUMPDEST | calldataload(4) 0xDA |
+| 16F | PUSH1 0x04 | 0x04 calldataload(4) 0xDA |
+| 171 | DUP2 | calldataload(4) 0x04 calldataload(4) 0xDA |
+| 172 | DUP2 | 0x04 calldataload(4) 0x04 calldataload(4) 0xDA |
+| 173 | SLOAD | Speicher[4] calldataload(4) 0x04 calldataload(4) 0xDA |
+| 174 | DUP2 | calldataload(4) Speicher[4] calldataload(4) 0x04 calldataload(4) 0xDA |
+| 175 | LT | calldataload(4)\)`, und eine andere ist `isClaimed()`, also sieht es wie ein Airdrop-Contract aus. Anstatt den Rest Opcode für Opcode durchzugehen, können wir [den Decompiler ausprobieren](https://etherscan.io/bytecode-decompiler?a=0x2f81e57ff4f4d83b40a9f719fd892d8e806e0761), der für drei Funktionen aus diesem Contract brauchbare Ergebnisse liefert. Das Reverse Engineering der anderen wird dem Leser als Übung überlassen.
+
+### scaleAmountByPercentage {#scaleamountbypercentage}
+
+Das gibt uns der Decompiler für diese Funktion aus:
+
+```python
+def unknown8ffb5c97(uint256 _param1, uint256 _param2) payable:
+ require calldata.size - 4 >=′ 64
+ if _param1 and _param2 > -1 / _param1:
+ revert with 0, 17
+ return (_param1 * _param2 / 100 * 10^6)
+```
+
+Das erste `require` testet, ob die Calldata zusätzlich zu den vier Bytes der Funktionssignatur mindestens 64 Bytes haben, genug für die beiden Parameter. Wenn nicht, dann ist offensichtlich etwas falsch.
+
+Die `if`-Anweisung scheint zu prüfen, dass `_param1` nicht Null ist und dass `_param1 * _param2` nicht negativ ist. Es dient wahrscheinlich dazu, Fälle von Wrap-Around zu verhindern.
+
+Schließlich gibt die Funktion einen skalierten Wert zurück.
+
+### claim {#claim}
+
+Der vom Decompiler erstellte Code ist komplex und nicht alles davon ist für uns relevant. Ich werde einen Teil davon überspringen, um mich auf die Zeilen zu konzentrieren, von denen ich glaube, dass sie nützliche Informationen liefern
+
+```python
+def unknown2e7ba6ef(uint256 _param1, uint256 _param2, uint256 _param3, array _param4) payable:
+ ...
+ require _param2 == addr(_param2)
+ ...
+ if currentWindow <= _param1:
+ revert with 0, 'cannot claim for a future window'
+```
+
+Wir sehen hier zwei wichtige Dinge:
+
+- `_param2` ist, obwohl als `uint256` deklariert, tatsächlich eine Adresse
+- `_param1` ist das Fenster, das beansprucht wird, und muss `currentWindow` oder früher sein.
+
+```python
+ ...
+ if stor5[_claimWindow][addr(_claimFor)]:
+ revert with 0, 'Account already claimed the given window'
+```
+
+Jetzt wissen wir also, dass Speicher[5] ein Array von Fenstern und Adressen ist und ob die Adresse die Belohnung für dieses Fenster beansprucht hat.
+
+```python
+ ...
+ idx = 0
+ s = 0
+ while idx < _param4.length:
+ ...
+ if s + sha3(mem[(32 * _param4.length) + 328 len mem[(32 * _param4.length) + 296]]) > mem[(32 * idx) + 296]:
+ mem[mem[64] + 32] = mem[(32 * idx) + 296]
+ ...
+ s = sha3(mem[_62 + 32 len mem[_62]])
+ continue
+ ...
+ s = sha3(mem[_66 + 32 len mem[_66]])
+ continue
+ if unknown2eb4a7ab != s:
+ revert with 0, 'Invalid proof'
+```
+
+Wir wissen, dass `unknown2eb4a7ab` eigentlich die Funktion `merkleRoot()` ist, also sieht dieser Code so aus, als würde er einen [Merkle-Beweis](https://medium.com/crypto-0-nite/merkle-proofs-explained-6dd429623dc5) verifizieren. Das bedeutet, dass `_param4` ein Merkle-Beweis ist.
+
+```python
+ call addr(_param2) with:
+ value unknown81e580d3[_param1] * _param3 / 100 * 10^6 wei
+ gas 30000 wei
+```
+
+So überträgt ein Contract seine eigenen ETH an eine andere Adresse (Contract oder externer Besitz). Er ruft ihn mit einem Wert auf, der dem zu übertragenden Betrag entspricht. Es sieht also so aus, als ob dies ein Airdrop von ETH ist.
+
+```python
+ if not return_data.size:
+ if not ext_call.success:
+ require ext_code.size(stor2)
+ call stor2.deposit() with:
+ value unknown81e580d3[_param1] * _param3 / 100 * 10^6 wei
+```
+
+Die unteren beiden Zeilen sagen uns, dass Speicher[2] auch ein Contract ist, den wir aufrufen. Wenn wir uns [die Konstruktor-Transaktion ansehen](https://etherscan.io/tx/0xa1ea0549fb349eb7d3aff90e1d6ce7469fdfdcd59a2fd9b8d1f5e420c0d05b58#statechange), sehen wir, dass dieser Contract [0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2](https://etherscan.io/address/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2) ist, ein Wrapped Ether-Contract, [dessen Quellcode auf Etherscan hochgeladen wurde](https://etherscan.io/address/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2#code).
+
+Es sieht also so aus, als ob die Contracts versuchen, ETH an `_param2` zu senden. Wenn er es tun kann, großartig. Wenn nicht, versucht er, [WETH](https://weth.tkn.eth.limo/) zu senden. Wenn `_param2` ein Konto in externem Besitz (EOA) ist, kann es immer ETH empfangen, aber Contracts können den Empfang von ETH verweigern. WETH ist jedoch ERC-20 und Contracts können die Annahme nicht verweigern.
+
+```python
+ ...
+ log 0xdbd5389f: addr(_param2), unknown81e580d3[_param1] * _param3 / 100 * 10^6, bool(ext_call.success)
+```
+
+Am Ende der Funktion sehen wir, dass ein Log-Eintrag generiert wird. [Sehen Sie sich die generierten Log-Einträge an](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f#events) und filtern Sie nach dem Thema, das mit `0xdbd5...` beginnt. Wenn wir [auf eine der Transaktionen klicken, die einen solchen Eintrag generiert haben](https://etherscan.io/tx/0xe7d3b7e00f645af17dfbbd010478ef4af235896c65b6548def1fe95b3b7d2274), sehen wir, dass es tatsächlich wie ein Anspruch aussieht - das Konto hat eine Nachricht an den Contract gesendet, den wir per Reverse Engineering analysieren, und im Gegenzug ETH erhalten.
+
+
+
+### 1e7df9d3 {#1e7df9d3}
+
+Diese Funktion ist sehr ähnlich zu [`claim`](#claim) oben. Es prüft auch einen Merkle-Beweis, versucht ETH auf den ersten zu übertragen und erzeugt die gleiche Art von Log-Eintrag.
+
+```python
+def unknown1e7df9d3(uint256 _param1, uint256 _param2, array _param3) payable:
+ ...
+ idx = 0
+ s = 0
+ while idx < _param3.length:
+ if idx >= mem[96]:
+ revert with 0, 50
+ _55 = mem[(32 * idx) + 128]
+ if s + sha3(mem[(32 * _param3.length) + 160 len mem[(32 * _param3.length) + 128]]) > mem[(32 * idx) + 128]:
+ ...
+ s = sha3(mem[_58 + 32 len mem[_58]])
+ continue
+ mem[mem[64] + 32] = s + sha3(mem[(32 * _param3.length) + 160 len mem[(32 * _param3.length) + 128]])
+ ...
+ if unknown2eb4a7ab != s:
+ revert with 0, 'Invalid proof'
+ ...
+ call addr(_param1) with:
+ value s wei
+ gas 30000 wei
+ if not return_data.size:
+ if not ext_call.success:
+ require ext_code.size(stor2)
+ call stor2.deposit() with:
+ value s wei
+ gas gas_remaining wei
+ ...
+ log 0xdbd5389f: addr(_param1), s, bool(ext_call.success)
+```
+
+Der Hauptunterschied besteht darin, dass der erste Parameter, das abzuhebende Fenster, nicht vorhanden ist. Stattdessen gibt es eine Schleife über alle Fenster, die beansprucht werden könnten.
+
+```python
+ idx = 0
+ s = 0
+ while idx < currentWindow:
+ ...
+ if stor5[mem[0]]:
+ if idx == -1:
+ revert with 0, 17
+ idx = idx + 1
+ s = s
+ continue
+ ...
+ stor5[idx][addr(_param1)] = 1
+ if idx >= unknown81e580d3.length:
+ revert with 0, 50
+ mem[0] = 4
+ if unknown81e580d3[idx] and _param2 > -1 / unknown81e580d3[idx]:
+ revert with 0, 17
+ if s > !(unknown81e580d3[idx] * _param2 / 100 * 10^6):
+ revert with 0, 17
+ if idx == -1:
+ revert with 0, 17
+ idx = idx + 1
+ s = s + (unknown81e580d3[idx] * _param2 / 100 * 10^6)
+ continue
+```
+
+Es sieht also wie eine `claim`-Variante aus, die alle Fenster beansprucht.
+
+## Fazit {#conclusion}
+
+Inzwischen sollten Sie wissen, wie Sie Contracts verstehen können, deren Quellcode nicht verfügbar ist, indem Sie entweder die Opcodes oder (wenn es funktioniert) den Decompiler verwenden. Wie aus der Länge dieses Artikels ersichtlich ist, ist das Reverse Engineering eines Contracts nicht trivial, aber in einem System, in dem Sicherheit unerlässlich ist, ist es eine wichtige Fähigkeit, überprüfen zu können, ob Contracts wie versprochen funktionieren.
+
+[Hier finden Sie mehr von meiner Arbeit](https://cryptodocguy.pro/).
diff --git a/public/content/translations/de/developers/tutorials/run-node-raspberry-pi/index.md b/public/content/translations/de/developers/tutorials/run-node-raspberry-pi/index.md
index 38d446dbd7b..b443271c60c 100644
--- a/public/content/translations/de/developers/tutorials/run-node-raspberry-pi/index.md
+++ b/public/content/translations/de/developers/tutorials/run-node-raspberry-pi/index.md
@@ -1,267 +1,190 @@
---
-title: So verwandeln Sie Ihren Raspberry Pi 4 durch Überschreiben der MicroSD-Karte in einen Node
-description: Verbinden Sie Ihren Raspberry Pi 4 mit einem Ethernetkabel, schließen Sie ihn anschließend an die SSD-Festplatte an und starten Sie das Gerät. Nun können Sie es als Ethereum-Node nutzen und eine Ausführungsebene oder Konsensebene (Beacon Chain/Validator) ausführen.
+title: Betreibe einen Ethereum-Node auf einem Raspberry Pi 4
+description: Flashe deinen Raspberry Pi 4, stecke ein Ethernet-Kabel ein, schließe die SSD-Festplatte an und schalte das Gerät ein, um den Raspberry Pi 4 in einen vollwertigen Ethereum-Node + Validator zu verwandeln
author: "EthereumOnArm"
tags:
- - "Clients"
- - "Ausführungsebene"
- - "Konsensebene"
- - "Nodes"
+ [
+ "Clients",
+ "Ausführungsebene",
+ "Konsensebene",
+ "Nodes"
+ ]
lang: de
-skill: advanced
-published: 2020-05-07
-source: r/ethereum
-sourceUrl: https://www.reddit.com/r/ethereum/comments/gf3nhg/ethereum_on_arm_raspberry_pi_4_images_release/
+skill: intermediate
+published: 2022-06-10
+source: Ethereum on ARM
+sourceUrl: https://ethereum-on-arm-documentation.readthedocs.io/en/latest/
---
-**TL;DR**: Verbinden Sie Ihren Raspberry Pi 4 mit einem Ethernetkabel, schließen Sie ihn anschließend an die SSD-Festplatte an und starten Sie das Gerät. Nun können Sie es als Ethereum-Node nutzen und eine Ausführungsebene oder Konsensebene (Beacon Chain/Validator) ausführen.
+**Ethereum on Arm ist ein benutzerdefiniertes Linux-Image, das einen Raspberry Pi in einen Ethereum-Node verwandeln kann.**
-[Mehr erfahren über Ethereum-Upgrades](/roadmap/)
+Um Ethereum on Arm zu verwenden, um einen Raspberry Pi in einen Ethereum-Node zu verwandeln, wird die folgende Hardware empfohlen:
-Zunächst ein paar Hintergrundinformationen: Wie Sie bereits wissen, gibt es einige Speicherprobleme [[1]](/developers/tutorials/run-node-raspberry-pi/#references) bei dem Raspberry Pi 4-Image, da die Betriebssoftware Raspbian OS bisher nur mit der 32-Bit-Version erhältlich ist [[2]](/developers/tutorials/run-node-raspberry-pi/#references) (das gilt jedenfalls für die Benutzeroberfläche). Obwohl wir das offizielle Betriebssystem bevorzugen würden, sind wir zu dem Entschluss gekommen, dass wir auf ein natives 64-Bit-Betriebssystem umsteigen müssen, um diese Probleme zu lösen.
-
-Außerdem unterstützen Konsens-Clients keine 32-Bit-Binärdateien, so dass die Verwendung von Raspbian den Raspberry Pi 4 vom Betrieb eines Node auf Konsensebene (und der Möglichkeit des Staking) ausschließen würde.
-
-Nach mehreren Tests veröffentlichen wir nun zwei verschiedene Images auf Basis von Ubuntu 20.04 64-Bit [[3]](/developers/tutorials/run-node-raspberry-pi/#references): Ausführungsebenen- und Konsensebenen-Editionen.
-
-Im Grunde genommen handelt es sich bei beiden um das gleiche Image, das die gleichen Funktionen wie die Raspbian-basierten Images enthält. Sie sind jedoch standardmäßig für die Ausführung von Software der Ausführungsebene oder der Konsensebene eingerichtet.
-
-**Images übernehmen alle notwendigen Schritte**, von der Einrichtung der Umgebung und der Formatierung der SSD-Platte über die Installation und Ausführung der Ethereum-Software bis hin zum Start der Blockchain-Synchronisation.
-
-## Hauptfunktionen {#main-features}
-
-- Basierend auf Ubuntu 20.04 64-Bit
-- Automatische Partitionierung und Formatierung von USB-Festplatten
-- Fügt Swap-Speicher hinzu (ZRAM-Kernel-Modul und eine Swap-Datei), basierend auf der Arbeit von Armbian [[7]](/developers/tutorials/run-node-raspberry-pi/#references)
-- Ändert den Hostnamen anhand des MAC-Hashes in etwas wie "ethnode-e2a3e6fe"
-- Führt Software als systemd-Dienst aus und beginnt mit der Synchronisierung der Blockchain
-- Enthält ein APT-Repository für die Installation und Aktualisierung von Ethereum-Software
-- Enthält ein auf Grafana/Prometheus basierendes Überwachungs-Dashboard
-
-## Enthaltene Software {#software-included}
-
-Beide Images enthalten die gleichen Pakete. Der einzige Unterschied besteht darin, dass die Ausführungsversion standardmäßig Geth und die Konsensversion standardmäßig die Prysm-Beacon Chain ausführt.
-
-### Ausführungs-Clients {#execution-clients}
-
-- Geth [[8]](/developers/tutorials/run-node-raspberry-pi/#references): 1.9.13 (offizielle Binärdatei)
-- Parity [[9]](/developers/tutorials/run-node-raspberry-pi/#references): 2.7.2 (quer kompiliert)
-- Nethermind [[10]](/developers/tutorials/run-node-raspberry-pi/#references): 1.8.28 (quer kompiliert)
-- Hyperledger Besu [[11]](/developers/tutorials/run-node-raspberry-pi/#references): 1.4.4 (kompiliert)
-
-### Konsens-Clients {#consensus-clients}
-
-- Prysm [[12]](/developers/tutorials/run-node-raspberry-pi/#references): 1.0.0-alpha6 (offizielle Binärdatei)
-- Lighthouse [[13]](/developers/tutorials/run-node-raspberry-pi/#references): 0.1.1 (kompiliert)
-
-### Ethereum-Framework {#ethereum-framework}
-
-- Swarm [[14]](/developers/tutorials/run-node-raspberry-pi/#references): 0.5.7 (offizielle Binärdatei)
-- Raiden Network [[15]](/developers/tutorials/run-node-raspberry-pi/#references): 0.200.0~rc1 (offizielle Binärdatei)
-- IPFS [[16]](/developers/tutorials/run-node-raspberry-pi/#references): 0.5.0 (offizielle Binärdatei)
-- Statusd [[17]](/developers/tutorials/run-node-raspberry-pi/#references): 0.52.3 (kompiliert)
-- Vipnode [[18]](/developers/tutorials/run-node-raspberry-pi/#references): 2.3.3 (offizielle Binärdatei)
-
-## Installationsanleitung und Anwendung {#installation-guide-and-usage}
-
-### Empfohlene Hardware und Einrichtung {#recommended-hardware-and-setup}
-
-- Raspberry 4 (Model B) – 4 GB
-- MicroSD-Karte (mindestens 16 GB Klasse 10)
-- SSD-USB-3.0-Festplatte (siehe Speicherabschnitt)
+- Raspberry 4 (Modell B 8 GB), Odroid M1 oder Rock 5B (8 GB/16 GB RAM) Platine
+- MicroSD-Karte (mindestens 16 GB, Klasse 10)
+- Mindestens 2 TB große SSD als USB-3.0-Laufwerk oder eine SSD in einem USB-zu-SATA-Gehäuse.
- Stromversorgung
- Ethernet-Kabel
-- 30303-Portweiterleitung (Ausführungseben) und 13000-Portweiterleitung (Konsensebene) [[4]](/developers/tutorials/run-node-raspberry-pi/#references)
-- Ein Gehäuse mit Kühlkörper und Lüfter (optional, aber dringend empfohlen)
-- USB-Tastatur, Monitor und HDMI-Kabel (micro-HDMI) (optional)
-
-## Speicher {#storage}
-
-Sie benötigen eine SSD, um die Ethereum-Clients auszuführen (ohne SSD-Laufwerk gibt es absolut keine Chance, die Ethereum-Blockchain zu synchronisieren). Es gibt zwei Optionen:
-
-- Verwenden Sie eine tragbare USB-SSD-Festplatte wie die Samsung T5 Portable SSD.
-- Verwenden Sie ein externes USB 3.0-Festplattengehäuse mit einer SSD-Festplatte. In unserem Fall haben wir ein Inateck 2.5 Hard Drive Enclosure FE2011 verwendet. Achten Sie darauf, ein Gehäuse mit einem UAS-kompatiblen Chip zu kaufen, insbesondere einen der folgenden: JMicron (JMS567 oder JMS578) oder ASMedia (ASM1153E).
+- Portweiterleitung (siehe Clients für weitere Informationen)
+- Ein Gehäuse mit Kühlkörper und Lüfter
+- USB-Tastatur, Monitor und HDMI-Kabel (Micro-HDMI) (optional)
-In beiden Fällen sollten Sie vermeiden, minderwertige SSD-Festplatten zu kaufen, da sie eine Schlüsselkomponente Ihrer Nodes sind und die Leistung (und die Synchronisierungszeiten) drastisch beeinträchtigen können.
+## Warum Ethereum auf ARM betreiben? {#why-run-ethereum-on-arm}
-Beachten Sie, dass die Festplatte an einen USB 3.0-Anschluss (blau) angeschlossen sein muss.
+ARM-Platinen sind sehr preisgünstige, flexible, kleine Computer. Sie sind eine gute Wahl für den Betrieb von Ethereum-Nodes, weil sie günstig zu erwerben sind, so konfiguriert werden können, dass alle ihre Ressourcen nur auf den Node ausgerichtet sind, was sie effizient macht, sie wenig Strom verbrauchen und physisch klein sind, sodass sie unauffällig in jedes Zuhause passen. Es ist auch sehr einfach, Nodes zu starten, da die MicroSD-Karte des Raspberry Pi einfach mit einem vorgefertigten Image geflasht werden kann, ohne dass Software heruntergeladen oder erstellt werden muss.
-## Images herunterladen und Installieren {#image-download-and-installation}
+## Wie funktioniert das? {#how-does-it-work}
-### 1. Laden Sie die Images der Ausführungs- und Konsensebene herunter {#1-download-execution-or-consensus-images}
+Die Speicherkarte des Raspberry Pi wird mit einem vorgefertigten Image geflasht. Dieses Image enthält alles, was zum Betreiben eines Ethereum-Nodes benötigt wird. Mit einer geflashten Karte musst du nur noch den Raspberry Pi einschalten. Alle Prozesse, die für den Betrieb des Nodes erforderlich sind, werden automatisch gestartet. Das funktioniert, weil die Speicherkarte ein Linux-basiertes Betriebssystem (OS) enthält, auf dem automatisch Prozesse auf Systemebene ausgeführt werden, die das Gerät in einen Ethereum-Node verwandeln.
-
- Image der Ausführungsebene herunterladen
-
+Ethereum kann nicht mit dem beliebten Raspberry Pi Linux-Betriebssystem „Raspbian“ betrieben werden, da Raspbian immer noch eine 32-Bit-Architektur verwendet, was dazu führt, dass Ethereum-Benutzer auf Speicherprobleme stoßen und Konsens-Clients keine 32-Bit-Binärdateien unterstützen. Um dies zu überwinden, ist das Ethereum-on-Arm-Team auf ein natives 64-Bit-Betriebssystem namens „Armbian“ umgestiegen.
-sha256 7fa9370d13857dd6abcc8fde637c7a9a7e3a66b307d5c28b0c0d29a09c73c55c
+**Images übernehmen alle notwendigen Schritte, von der Einrichtung der Umgebung und der Formatierung der SSD-Platte über die Installation und Ausführung der Ethereum-Software bis hin zum Start der Blockchain-Synchronisation.**
-
- Image der Konsensebene herunterladen
-
+## Hinweis zu Ausführungs- und Konsens-Clients {#note-on-execution-and-consensus-clients}
-sha256 74c0c15b708720e5ae5cac324f1afded6316537fb17166109326755232cd316e
+Das Ethereum on Arm-Image enthält vorgefertigte Ausführungs- und Konsens-Clients als Dienste. Ein Ethereum-Node erfordert, dass beide Clients synchronisiert sind und laufen. Du musst nur das Image herunterladen, es flashen und dann die Dienste starten. Das Image ist mit den folgenden Ausführungs-Clients vorinstalliert:
-### 2. Das Image flashen {#2-flash-the-image}
+- Geth
+- Nethermind
+- Besu
-Stecken Sie die microSD-Karte in Ihren Desktop/Laptop und laden Sie die Datei herunter (z. B. die Ausführungsebene):
+und die folgenden Konsens-Clients:
-```bash
-wget https://ethraspbian.com/downloads/ubuntu-20.04-preinstalled-server-arm64+raspi-eth1.img.zip
-```
+- Lighthouse
+- Nimbus
+- Prysm
+- Teku
-Hinweis: Wenn Sie mit der Befehlszeile nicht vertraut sind oder unter Windows arbeiten, können Sie [Etcher](https://etcher.io) verwenden.
+Du solltest einen von jedem zum Ausführen auswählen - alle Ausführungs-Clients sind mit allen Konsens-Clients kompatibel. Wenn du nicht explizit einen Client auswählst, greift der Node auf seine Standardeinstellungen - Geth und Lighthouse - zurück und führt sie automatisch aus, wenn die Platine eingeschaltet wird. Du musst Port 30303 auf deinem Router öffnen, damit Geth Peers finden und sich mit ihnen verbinden kann.
-Öffnen Sie ein Terminal und überprüfen Sie den Namen Ihres MicroSD-Geräts:
+## Herunterladen des Images {#downloading-the-image}
-```bash
-sudo fdisk -l
-```
+Das Raspberry Pi 4 Ethereum-Image ist ein „Plug-and-Play“-Image, das automatisch sowohl die Ausführungs- als auch die Konsens-Clients installiert und einrichtet, sie so konfiguriert, dass sie miteinander kommunizieren und sich mit dem Ethereum-Netzwerk verbinden. Alles, was du tun musst, ist, deine Prozesse mit einem einfachen Befehl zu starten.
-Sie sollten ein Gerät namens "mmcblk0" oder "sdd" sehen. Entpacken und flashen des Images:
+Lade das Raspberry Pi-Image von [Ethereum on Arm](https://ethereumonarm-my.sharepoint.com/:u:/p/dlosada/Ec_VmUvr80VFjf3RYSU-NzkBmj2JOteDECj8Bibde929Gw?download=1) herunter und überprüfe den SHA256-Hash:
-```bash
-unzip ubuntu-20.04-preinstalled-server-arm64+raspi-eth1.img.zip
-sudo dd bs=1M if=ubuntu-20.04-preinstalled-server-arm64+raspi-eth1.img of=/dev/mmcblk0 && sync
+```sh
+# Aus dem Verzeichnis, das das heruntergeladene Image enthält
+shasum -a 256 ethonarm_22.04.00.img.zip
+# Der Hash sollte Folgendes ausgeben: fb497e8f8a7388b62d6e1efbc406b9558bee7ef46ec7e53083630029c117444f
```
-### 3. Setzen Sie die MicroSD-Karte in den Raspberry Pi 4 ein. Schließen ein Ethernet-Kabel und die USB-SSD-Festplatte an (stellen Sie sicher, dass Sie einen blauen Anschluss verwenden). {#3-insert-the-microsd-into-the-raspberry-pi-4-connect-an-ethernet-cable-and-attach-the-usb-ssd-disk-make-sure-you-are-using-a-blue-port}
-
-### 4. Das Gerät einschalten {#4-power-on-the-device}
-
-Das Ubuntu-Betriebssystem wird in weniger als einer Minute hochgefahren, aber Sie müssen **etwa 10 Minuten warten**, damit das Skript die notwendigen Aufgaben durchführen kann, um das Gerät in einen Ethereum-Node zu verwandeln und den Raspberry neu zu starten.
+Beachte, dass Images für Rock 5B- und Odroid M1-Platinen auf der Ethereum-on-Arm-[Download-Seite](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/quick-guide/download-and-install.html) verfügbar sind.
-Je nach Image, wird das wie folgt ausgeführt:
+## Flashen der MicroSD {#flashing-the-microsd}
-- Ausführungs-Client: Geth als Standard-Client für die Synchronisierung der Blockchain
-- Konsens-Client: Prysm als Standard-Client für die Synchronisierung der Beacon Chain (Goerli-Testnet)
+Die MicroSD-Karte, die für den Raspberry Pi verwendet werden soll, sollte zuerst in einen Desktop oder Laptop eingelegt werden, damit sie geflasht werden kann. Mit den folgenden Terminalbefehlen wird das heruntergeladene Image auf die SD-Karte geflasht:
-### 5. Anmelden {#5-log-in}
-
-Sie können sich über SSH oder über die Konsole anmelden (wenn Sie einen Monitor und eine Tastatur angeschlossen haben).
+```shell
+# Namen der MicroSD-Karte überprüfen
+sudo fdisk -l
-```bash
-User: ethereum
-Password: ethereum
+>> sdxxx
```
-Bei der ersten Anmeldung werden Sie aufgefordert, das Passwort zu ändern, so dass Sie sich zweimal anmelden müssen.
-
-### 6. Öffnen Sie den Port 30303 für Geth und 13000, wenn Sie eine Prysm-Beacon Chain verwenden. Wenn Sie nicht wissen, wie das geht, geben Sie in einer Suchmaschine "Portweiterleitung" gefolgt von Ihrem Routermodell ein. {#6-open-30303-port-for-geth-and-13000-if-you-are-running-prysm-beacon-chain-if-you-dont-know-how-to-do-this-google-port-forwarding-followed-by-your-router-model}
-
-### 7. Konsolenausgabe abrufen {#7-get-console-output}
-
-Sie können sehen, was im Hintergrund passiert, indem Sie Folgendes eingeben:
+Es ist sehr wichtig, den richtigen Namen zu verwenden, da der nächste Befehl `dd` enthält, der den gesamten Inhalt der Karte löscht, bevor das Image darauf geschrieben wird. Um fortzufahren, navigiere zu dem Verzeichnis, das das gezippte Image enthält:
-```bash
-sudo tail -f /var/log/syslog
+```shell
+# Image entpacken und flashen
+unzip ethonarm_22.04.00.img.zip
+sudo dd bs=1M if=ethonarm_22.04.00.img of=/dev/ conv=fdatasync status=progress
```
-**Herzlichen Glückwunsch. Sie betreiben nun einen vollständigen Ethereum-Node auf Ihrem Raspberry Pi 4.**
+Die Karte ist nun geflasht und kann in den Raspberry Pi eingelegt werden.
-## Synchronisierung mit der Blockchain {#syncing-the-blockchain}
+## Den Node starten {#start-the-node}
-Jetzt müssen Sie warten, bis die Blockchain synchronisiert ist. Im Falle der Ausführungsebene wird dieser Vorgang einige Tage dauern, da er von verschiedenen Faktoren abhängig ist. Sie können mit bis zu 5-7 Tagen rechnen.
+Stecke die SD-Karte in den Raspberry Pi, schließe das Ethernet-Kabel und die SSD an und schalte das Gerät ein. Das Betriebssystem wird hochfahren und automatisch damit beginnen, die vorkonfigurierten Aufgaben auszuführen, die den Raspberry Pi in einen Ethereum-Node verwandeln, einschließlich der Installation und Erstellung der Client-Software. Dies wird wahrscheinlich 10-15 Minuten dauern.
-Wenn Sie die Konsensebene des Goerli-Testnets verwenden, können Sie mit einer Synchronisationszeit von 1-2 Tagen für die Beacon Chain rechnen. Denken Sie daran, dass Sie den Validator später einrichten müssen, um den Staking-Prozess zu starten. [So führen Sie den Konsensebenen-Validator aus](/developers/tutorials/run-node-raspberry-pi/#validator).
+Sobald alles installiert und konfiguriert ist, melde dich über eine SSH-Verbindung am Gerät an oder verwende das Terminal direkt, wenn ein Monitor und eine Tastatur an die Platine angeschlossen sind. Verwende das `ethereum`-Konto zum Anmelden, da dieses die erforderlichen Berechtigungen zum Starten des Nodes hat.
-## Dashboards überwachen {#monitoring-dashboards}
+```shell
+Benutzer: ethereum
+Passwort: ethereum
+```
-Für diese erste Version haben wir 3 Überwachungs-Dashboards auf Grundlage von Prometheus [[5]](/developers/tutorials/run-node-raspberry-pi/#references)/Grafana [[6]](/developers/tutorials/run-node-raspberry-pi/#references) eingebaut, um den Node und die Daten der Clients (Geth und Besu) zu überwachen. Sie können über Ihren Webbrowser darauf zugreifen:
+Der Standard-Ausführungs-Client, Geth, startet automatisch. Du kannst dies bestätigen, indem du die Protokolle mit dem folgenden Terminal-Befehl überprüfst:
-```bash
-URL: http://your_raspberrypi_IP:3000
-User: admin
-Password: ethereum
+```sh
+sudo journalctl -u geth -f
```
-## Clients wechseln {#switching-clients}
+Der Konsens-Client muss explizit gestartet werden. Öffne dazu zuerst Port 9000 auf deinem Router, damit Lighthouse Peers finden und eine Verbindung zu ihnen herstellen kann. Aktivieren und starten Sie dann den Lighthouse-Dienst:
-Alle Clients laufen als Systemdienst. Das ist wichtig, denn wenn ein Problem auftritt, wird das System den Prozess automatisch neu starten.
+```sh
+sudo systemctl enable lighthouse-beacon
+sudo systemctl start lighthouse-beacon
+```
-Die Beacon Chain von Geth und Prysm läuft standardmäßig (je nachdem, wie Sie synchronisieren, Ausführungsebene oder Konsensebene). Wenn Sie also zu einem anderen Client wechseln möchten (z. B. von Geth zu Nethermind), müssen Sie zuerst Geth anhalten und deaktivieren und dann den anderen Client aktivieren und starten:
+Überprüfe den Client anhand der Protokolle:
-```bash
-sudo systemctl stop geth && sudo systemctl disable geth
+```sh
+sudo journalctl -u lighthouse-beacon
```
-Befehle zum Aktivieren und Starten jedes Ausführungs-Clients:
+Beachte, dass der Konsens-Client in wenigen Minuten synchronisiert wird, da er die Checkpoint-Synchronisierung verwendet. Der Ausführungs-Client wird länger brauchen – möglicherweise mehrere Stunden – und er startet erst, wenn der Konsens-Client bereits synchronisiert ist (das liegt daran, dass der Ausführungs-Client ein Ziel für die Synchronisierung benötigt, das der synchronisierte Konsens-Client bereitstellt).
-```bash
-sudo systemctl enable besu && sudo systemctl start besu
-sudo systemctl enable nethermind && sudo systemctl start nethermind
-sudo systemctl enable parity && sudo systemctl start parity
-```
+Wenn die Dienste Geth und Lighthouse laufen und synchronisiert sind, ist dein Raspberry Pi jetzt ein Ethereum-Node! Am häufigsten wird mit dem Ethereum-Netzwerk über die Javascript-Konsole von Geth interagiert, die an den Geth-Client an Port 8545 angehängt werden kann. Es ist auch möglich, Befehle, die als JSON-Objekte formatiert sind, mit einem Anfrage-Tool wie Curl zu übermitteln. Mehr dazu findest du in der [Geth-Dokumentation](https://geth.ethereum.org/).
-Konsens-Clients:
+Geth ist so vorkonfiguriert, dass es Metriken an ein Grafana-Dashboard meldet, das im Browser angezeigt werden kann. Als fortgeschrittener Benutzer möchtest du diese Funktion möglicherweise nutzen, um den Zustand deines Nodes zu überwachen, indem du zu `ipaddress:3000` navigierst und `user: admin` sowie `passwd: ethereum` eingibst.
-```bash
-sudo systemctl stop prysm-beacon && sudo systemctl disable prysm-beacon
-sudo systemctl start lighthouse && sudo systemctl enable lighthouse
-```
+## Validatoren {#validators}
-## Parameter ändern {#changing-parameters}
+Optional kann auch ein Validator zum Konsens-Client hinzugefügt werden. Die Validator-Software ermöglicht es deinem Node, aktiv am Konsens teilzunehmen und versorgt das Netzwerk mit kryptoökonomischer Sicherheit. Für diese Arbeit wirst du in ETH belohnt. Um einen Validator zu betreiben, musst du zunächst 32 ETH besitzen, die in den Einzahlungsvertrag eingezahlt werden müssen. Die Einzahlung kann erfolgen, indem du der Schritt-für-Schritt-Anleitung auf dem [Launchpad](https://launchpad.ethereum.org/) folgst. Führe dies auf einem Desktop/Laptop durch, aber generiere keine Schlüssel – dies kann direkt auf dem Raspberry Pi erledigt werden.
-Die Konfigurationsdateien der Clients befinden sich in dem Verzeichnis /etc/ethereum/. Sie können diese Dateien bearbeiten und den Systemdienst neu starten, damit die Änderungen wirksam werden. Die einzige Ausnahme ist Nethermind, das zusätzlich eine Mainnet-Konfigurationsdatei hat, die sich hier befindet:
+Öffne ein Terminal auf dem Raspberry Pi und führe den folgenden Befehl aus, um die Einzahlungsschlüssel zu generieren:
-```bash
-/etc/nethermind/configs/mainnet.cfg
+```
+sudo apt-get update
+sudo apt-get install staking-deposit-cli
+cd && deposit new-mnemonic --num_validators 1
```
-Die Daten der Blockchain-Clients werden wie folgt auf dem Ethereum-Home-Konto gespeichert (beachten Sie den Punkt vor dem Verzeichnisnamen):
-
-### Ausführungsebene {#execution-layer}
+(Oder lade das [staking-deposit-cli](https://github.com/ethereum/staking-deposit-cli) herunter, um es auf einer Air-Gapped-Maschine auszuführen, und führe den Befehl `deposit new-mnemnonic` aus)
-```bash
-/home/ethereum/.geth
-/home/ethereum/.parity
-/home/ethereum/.besu
-/home/ethereum/.nethermind
-```
+Bewahre die mnemonische Phrase sicher auf! Der obige Befehl hat zwei Dateien im Keystore des Nodes generiert: die Validator-Schlüssel und eine Einzahlungsdatendatei. Die Einzahlungsdaten müssen auf das Launchpad hochgeladen werden, daher müssen sie vom Raspberry Pi auf den Desktop/Laptop kopiert werden. Dies kann über eine SSH-Verbindung oder eine andere Kopieren-und-Einfügen-Methode erfolgen.
-### Konsensebene {#consensus-layer}
+Sobald die Einzahlungsdatendatei auf dem Computer verfügbar ist, auf dem das Launchpad läuft, kann sie auf das `+` auf dem Launchpad-Bildschirm gezogen und abgelegt werden. Folge den Anweisungen auf dem Bildschirm, um eine Transaktion an den Einzahlungsvertrag zu senden.
-```bash
-/home/ethereum/.eth2
-/home/ethereum/.eth2validators
-/home/ethereum/.lighthouse
-```
+Zurück auf dem Raspberry Pi kann ein Validator gestartet werden. Dies erfordert den Import der Validator-Schlüssel, das Festlegen der Adresse zum Sammeln von Belohnungen und dann das Starten des vorkonfigurierten Validator-Prozesses. Das folgende Beispiel gilt für Lighthouse – Anleitungen für andere Konsens-Clients sind in den [Ethereum-on-Arm-Dokumenten](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/) verfügbar:
-## Nethermind und Hyperledger Besu {#nethermind-and-hyperledger-besu}
+```shell
+# Validator-Schlüssel importieren
+lighthouse account validator import --directory=/home/ethereum/validator_keys
-Diese beiden großartigen Ausführungs-Clients sind eine sehr gute Alternative zu Geth und Parity geworden. Je größer die Vielfalt im Netz, desto besser. Also probieren Sie sie aus und leisten Sie damit einen Beitrag zur Gesundheit des Netzwerks.
+# Belohnungsadresse festlegen
+sudo sed -i 's/' /etc/ethereum/lighthouse-validator.conf
-Beide Clients müssen noch weiter getestet werden. Experimentieren Sie also gerne damit und geben Sie uns Feedback dazu.
+# Validator starten
+sudo systemctl start lighthouse-validator
+```
-## So führen Sie den Konsensvalidator aus (Staking) {#validator}
+Herzlichen Glückwunsch, du hast jetzt einen vollständigen Ethereum-Node und Validator, der auf einem Raspberry Pi läuft!
-Sobald die Görli-Testnet-Beacon-Chain synchronisiert ist, können Sie einen Validator in demselben Gerät ausführen. Sie müssen [diese Teilnahmeschritte](https://prylabs.net/participate) befolgen.
+## Weitere Details {#more-details}
-Beim ersten Mal ist es erforderlich, manuell ein Konto zu erstellen. Führen Sie dazu das Binärprogramm "validator" aus und legen Sie ein Passwort fest. Sobald Sie diesen Schritt abgeschlossen haben, können Sie das Passwort zu `/etc/ethereum/prysm-validator.conf` hinzufügen und den Validator als Systemdienst starten.
+Diese Seite gab einen Überblick darüber, wie man einen Geth-Lighthouse-Node und -Validator mit einem Raspberry Pi einrichtet. Detailliertere Anweisungen sind auf der [Ethereum-on-Arm-Webseite](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/index.html) verfügbar.
## Feedback erwünscht {#feedback-appreciated}
-Wir haben viel Arbeit investiert, um den Raspberry Pi 4 als vollwertigen Ethereum-Node einzurichten, da wir wissen, dass die große Nutzerbasis dieses Geräts einen sehr positiven Einfluss auf das Netzwerk haben kann.
-
-Beachten Sie, dass dies das erste Image auf Basis von Ubuntu 20.04 ist und es daher noch einige Fehler enthalten kann. Wenn Sie das feststellen, eröffnen Sie ein Thema auf [GitHub](https://github.com/diglos/ethereumonarm) oder kontaktieren Sie uns auf [Twitter](https://twitter.com/EthereumOnARM).
+Wir wissen, dass der Raspberry Pi eine riesige Nutzerbasis hat, die einen sehr positiven Einfluss auf die Gesundheit des Ethereum-Netzwerks haben könnte.
+Bitte vertiefe dich in die Details dieses Tutorials, probiere es auf Testnets aus, sieh dir das Ethereum on Arm GitHub an, gib Feedback, melde Probleme und erstelle Pull-Requests und hilf mit, die Technologie und Dokumentation voranzubringen!
## Referenzen {#references}
-1. [geth stürzt wiederholt mit SIGSEGV ab](https://github.com/ethereum/go-ethereum/issues/20190)
-2. [https://github.com/diglos/ethereumonarm](https://github.com/diglos/ethereumonarm)
-3. https://ubuntu.com/download/raspberry-pi
-4. https://wikipedia.org/wiki/Port_forwarding
-5. https://prometheus.io
-6. https://grafana.com
-7. https://forum.armbian.com/topic/5565-zram-vs-swap/
-8. https://geth.ethereum.org
-9. https://github.com/openethereum/openethereum \* **Beachten Sie, dass OpenEthereum [veraltet](https://medium.com/openethereum/gnosis-joins-erigon-formerly-turbo-geth-to-release-next-gen-ethereum-client-c6708dd06dd) ist und nicht mehr gepflegt wird.** Verwenden Sie es mit Vorsicht und wechseln Sie lieber zu einer anderen Client-Implementierung.
-10. https://nethermind.io
-11. https://www.hyperledger.org/projects/besu
-12. https://github.com/prysmaticlabs/prysm
-13. https://lighthouse.sigmaprime.io
-14. https://ethersphere.github.io/swarm-home
-15. https://raiden.network
-16. https://ipfs.io
-17. https://status.im
-18. https://vipnode.org
+1. https://ubuntu.com/download/raspberry-pi
+2. https://wikipedia.org/wiki/Port_forwarding
+3. https://prometheus.io
+4. https://grafana.com
+5. https://forum.armbian.com/topic/5565-zram-vs-swap/
+6. https://geth.ethereum.org
+7. https://nethermind.io
+8. https://www.hyperledger.org/projects/besu
+9. https://github.com/prysmaticlabs/prysm
+10. https://lighthouse.sigmaprime.io
+11. https://ethersphere.github.io/swarm-home
+12. https://raiden.network
+13. https://ipfs.io
+14. https://status.im
+15. https://vipnode.org
diff --git a/public/content/translations/de/developers/tutorials/scam-token-tricks/index.md b/public/content/translations/de/developers/tutorials/scam-token-tricks/index.md
new file mode 100644
index 00000000000..1f72cf3b464
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/scam-token-tricks/index.md
@@ -0,0 +1,470 @@
+---
+title: "Einige Tricks, die von Betrugs-Tokens verwendet werden, und wie man sie erkennt"
+description: In diesem Tutorial analysieren wir einen Betrugs-Token, um einige der Tricks zu sehen, die Betrüger anwenden, wie sie sie implementieren und wie wir sie erkennen können.
+author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+tags:
+ [
+ "Betrug",
+ "Solidity",
+ "Erc-20",
+ "javascript",
+ "typescript"
+ ]
+skill: intermediate
+published: 15.09.2023
+lang: de
+---
+
+In diesem Tutorial analysieren wir [einen Betrugs-Token](https://etherscan.io/token/0xb047c8032b99841713b8e3872f06cf32beb27b82#code), um einige der Tricks zu sehen, die Betrüger anwenden und wie sie sie implementieren. Am Ende des Tutorials werden Sie einen umfassenderen Überblick über ERC-20-Token-Verträge, ihre Fähigkeiten und warum Skepsis notwendig ist, haben. Dann schauen wir uns die von diesem Betrugs-Token ausgegebenen Ereignisse an und sehen, wie wir automatisch erkennen können, dass er nicht legitim ist.
+
+## Betrugs-Tokens – was sind sie, warum machen Leute sie und wie kann man sie vermeiden {#scam-tokens}
+
+Eine der häufigsten Anwendungen von Ethereum ist die Schaffung eines handelbaren Tokens durch eine Gruppe, der gewissermaßen ihre eigene Währung darstellt. Jedoch gibt es überall, wo es legitime wertschöpfende Anwendungsmöglichkeiten gibt, auch Kriminelle, die diese Werte stehlen möchten.
+
+Sie können mehr über dieses Thema [an anderer Stelle auf ethereum.org](/guides/how-to-id-scam-tokens/) aus der Perspektive eines Benutzers lesen. Dieses Tutorial konzentriert sich auf die Analyse eines Betrugs-Tokens, um zu sehen, wie es gemacht wird und wie es erkannt werden kann.
+
+### Woher weiß ich, dass wARB ein Betrug ist? {#warb-scam}
+
+Der Token, den wir analysieren, ist [wARB](https://etherscan.io/token/0xb047c8032b99841713b8e3872f06cf32beb27b82#code), der vorgibt, dem legitimen [ARB-Token](https://etherscan.io/token/0xb50721bcf8d664c30412cfbc6cf7a15145234ad1) gleichwertig zu sein.
+
+Der einfachste Weg, um zu wissen, welcher der legitime Token ist, ist ein Blick auf die Herkunftsorganisation, [Arbitrum](https://arbitrum.foundation/). Die legitimen Adressen sind [in ihrer Dokumentation](https://docs.arbitrum.foundation/deployment-addresses#token) angegeben.
+
+### Warum ist der Quellcode verfügbar? {#why-source}
+
+Normalerweise würden wir erwarten, dass Leute, die versuchen, andere zu betrügen, geheimnisvoll sind, und tatsächlich haben viele Betrugs-Tokens ihren Code nicht verfügbar (zum Beispiel [dieser](https://optimistic.etherscan.io/token/0x15992f382d8c46d667b10dc8456dc36651af1452#code) und [dieser](https://optimistic.etherscan.io/token/0x026b623eb4aada7de37ef25256854f9235207178#code)).
+
+Allerdings veröffentlichen legitime Tokens normalerweise ihren Quellcode, sodass die Autoren von Betrugs-Tokens manchmal dasselbe tun, um legitim zu erscheinen. [wARB](https://etherscan.io/token/0xb047c8032b99841713b8e3872f06cf32beb27b82#code) ist einer dieser Tokens mit verfügbarem Quellcode, was das Verständnis erleichtert.
+
+Während Vertrags-Deployer wählen können, ob sie den Quellcode veröffentlichen oder nicht, können sie _nicht_ den falschen Quellcode veröffentlichen. Der Block-Explorer kompiliert den bereitgestellten Quellcode unabhängig, und wenn er nicht genau denselben Bytecode erhält, lehnt er diesen Quellcode ab. [Sie können mehr darüber auf der Etherscan-Seite lesen](https://etherscan.io/verifyContract).
+
+## Vergleich mit legitimen ERC-20-Tokens {#compare-legit-erc20}
+
+Wir werden diesen Token mit legitimen ERC-20-Tokens vergleichen. Wenn Sie nicht damit vertraut sind, wie legitime ERC-20-Tokens typischerweise geschrieben werden, [sehen Sie sich dieses Tutorial an](/developers/tutorials/erc20-annotated-code/).
+
+### Konstanten für privilegierte Adressen {#constants-for-privileged-addresses}
+
+Verträge benötigen manchmal privilegierte Adressen. Verträge, die für den langfristigen Gebrauch konzipiert sind, erlauben es einigen privilegierten Adressen, diese Adressen zu ändern, zum Beispiel um die Verwendung eines neuen Multisig-Vertrags zu ermöglichen. Es gibt mehrere Möglichkeiten, dies zu tun.
+
+Der [`HOP`-Token-Vertrag](https://etherscan.io/address/0xc5102fe9359fd9a28f877a67e36b0f050d81a3cc#code) verwendet das [`Ownable`](https://docs.openzeppelin.com/contracts/2.x/access-control#ownership-and-ownable)-Muster. Die privilegierte Adresse wird im Speicher in einem Feld namens `_owner` gehalten (siehe die dritte Datei, `Ownable.sol`).
+
+```solidity
+abstract contract Ownable is Context {
+ address private _owner;
+ .
+ .
+ .
+}
+```
+
+Der [`ARB`-Token-Vertrag](https://etherscan.io/address/0xad0c361ef902a7d9851ca7dcc85535da2d3c6fc7#code) hat nicht direkt eine privilegierte Adresse. Er braucht jedoch auch keine. Er befindet sich hinter einem [`Proxy`](https://docs.openzeppelin.com/contracts/5.x/api/proxy) an der [Adresse `0xb50721bcf8d664c30412cfbc6cf7a15145234ad1`](https://etherscan.io/address/0xb50721bcf8d664c30412cfbc6cf7a15145234ad1#code). Dieser Vertrag hat eine privilegierte Adresse (siehe die vierte Datei, `ERC1967Upgrade.sol`), die für Upgrades verwendet werden kann.
+
+```solidity
+ /**
+ * @dev Speichert eine neue Adresse im EIP1967-Admin-Slot.
+ */
+ function _setAdmin(address newAdmin) private {
+ require(newAdmin != address(0), "ERC1967: new admin is the zero address");
+ StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
+ }
+```
+
+Im Gegensatz dazu hat der `wARB`-Vertrag einen fest codierten `contract_owner`.
+
+```solidity
+contract WrappedArbitrum is Context, IERC20 {
+ .
+ .
+ .
+ address deployer = 0xB50721BCf8d664c30412Cfbc6cf7a15145234ad1;
+ address public contract_owner = 0xb40dE7b1beE84Ff2dc22B70a049A07A13a411A33;
+ .
+ .
+ .
+}
+```
+
+[Dieser Vertragsinhaber](https://etherscan.io/address/0xb40dE7b1beE84Ff2dc22B70a049A07A13a411A33) ist kein Vertrag, der zu verschiedenen Zeiten von verschiedenen Konten kontrolliert werden könnte, sondern ein [externes Konto](/developers/docs/accounts/#externally-owned-accounts-and-key-pairs). Das bedeutet, dass es wahrscheinlich für den kurzfristigen Gebrauch durch eine Einzelperson konzipiert ist, anstatt als langfristige Lösung zur Kontrolle eines ERC-20, das wertvoll bleiben wird.
+
+Und tatsächlich, wenn wir in Etherscan nachsehen, sehen wir, dass der Betrüger diesen Vertrag nur für 12 Stunden (von der [ersten Transaktion](https://etherscan.io/tx/0xf49136198c3f925fcb401870a669d43cecb537bde36eb8b41df77f06d5f6fbc2) bis zur [letzten Transaktion](https://etherscan.io/tx/0xdfd6e717157354e64bbd5d6adf16761e5a5b3f914b1948d3545d39633244d47b)) am 19. Mai 2023 verwendet hat.
+
+### Die gefälschte `_transfer`-Funktion {#the-fake-transfer-function}
+
+Es ist Standard, dass tatsächliche Transfers über eine [interne `_transfer`-Funktion](/developers/tutorials/erc20-annotated-code/#the-_transfer-function-_transfer) stattfinden.
+
+In `wARB` sieht diese Funktion fast legitim aus:
+
+```solidity
+ function _transfer(address sender, address recipient, uint256 amount) internal virtual{
+ require(sender != address(0), "ERC20: transfer from the zero address");
+ require(recipient != address(0), "ERC20: transfer to the zero address");
+
+ _beforeTokenTransfer(sender, recipient, amount);
+
+ _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
+ _balances[recipient] = _balances[recipient].add(amount);
+ if (sender == contract_owner){
+ sender = deployer;
+ }
+ emit Transfer(sender, recipient, amount);
+ }
+```
+
+Der verdächtige Teil ist:
+
+```solidity
+ if (sender == contract_owner){
+ sender = deployer;
+ }
+ emit Transfer(sender, recipient, amount);
+```
+
+Wenn der Vertragsinhaber Tokens sendet, warum zeigt das `Transfer`-Ereignis, dass sie von `deployer` kommen?
+
+Es gibt jedoch ein wichtigeres Problem. Wer ruft diese `_transfer`-Funktion auf? Sie kann nicht von außen aufgerufen werden, sie ist als `internal` markiert. Und der Code, den wir haben, enthält keine Aufrufe an `_transfer`. Offensichtlich ist sie hier als Köder.
+
+```solidity
+ function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
+ _f_(_msgSender(), recipient, amount);
+ return true;
+ }
+
+ function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
+ _f_(sender, recipient, amount);
+ _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
+ return true;
+ }
+```
+
+Wenn wir uns die Funktionen ansehen, die zum Übertragen von Tokens aufgerufen werden, `transfer` und `transferFrom`, sehen wir, dass sie eine völlig andere Funktion aufrufen, `_f_`.
+
+### Die echte `_f_`-Funktion {#the-real-f-function}
+
+```solidity
+ function _f_(address sender, address recipient, uint256 amount) internal _mod_(sender,recipient,amount) virtual {
+ require(sender != address(0), "ERC20: transfer from the zero address");
+ require(recipient != address(0), "ERC20: transfer to the zero address");
+
+ _beforeTokenTransfer(sender, recipient, amount);
+
+ _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
+ _balances[recipient] = _balances[recipient].add(amount);
+ if (sender == contract_owner){
+
+ sender = deployer;
+ }
+ emit Transfer(sender, recipient, amount);
+ }
+```
+
+Es gibt zwei potenzielle Warnsignale in dieser Funktion.
+
+- Die Verwendung des [Funktionsmodifikators](https://www.tutorialspoint.com/solidity/solidity_function_modifiers.htm) `_mod_`. Wenn wir uns jedoch den Quellcode ansehen, sehen wir, dass `_mod_` tatsächlich harmlos ist.
+
+ ```solidity
+ modifier _mod_(address sender, address recipient, uint256 amount){
+ _;
+ }
+ ```
+
+- Das gleiche Problem, das wir bei `_transfer` gesehen haben: Wenn `contract_owner` Tokens sendet, scheinen sie von `deployer` zu kommen.
+
+### Die gefälschte Ereignisfunktion `dropNewTokens` {#the-fake-events-function-dropNewTokens}
+
+Jetzt kommen wir zu etwas, das wie ein tatsächlicher Betrug aussieht. Ich habe die Funktion zur besseren Lesbarkeit etwas bearbeitet, aber sie ist funktional gleichwertig.
+
+```solidity
+function dropNewTokens(address uPool,
+ address[] memory eReceiver,
+ uint256[] memory eAmounts) public auth()
+```
+
+Diese Funktion hat den `auth()`-Modifikator, was bedeutet, dass sie nur vom Vertragsinhaber aufgerufen werden kann.
+
+```solidity
+modifier auth() {
+ require(msg.sender == contract_owner, "Not allowed to interact");
+ _;
+}
+```
+
+Diese Einschränkung ist vollkommen sinnvoll, da wir nicht wollen würden, dass zufällige Konten Tokens verteilen. Der Rest der Funktion ist jedoch verdächtig.
+
+```solidity
+{
+ for (uint256 i = 0; i < eReceiver.length; i++) {
+ emit Transfer(uPool, eReceiver[i], eAmounts[i]);
+ }
+}
+```
+
+Eine Funktion zum Übertragen von einem Pool-Konto an ein Array von Empfängern mit einem Array von Beträgen ist vollkommen sinnvoll. Es gibt viele Anwendungsfälle, in denen Sie Tokens von einer einzigen Quelle an mehrere Ziele verteilen möchten, wie z. B. Gehaltsabrechnungen, Airdrops usw. Es ist günstiger (in Gas), dies in einer einzigen Transaktion zu tun, anstatt mehrere Transaktionen auszugeben oder sogar den ERC-20-Vertrag mehrmals von einem anderen Vertrag als Teil derselben Transaktion aufzurufen.
+
+`dropNewTokens` tut das jedoch nicht. Es gibt [`Transfer`-Ereignisse](https://eips.ethereum.org/EIPS/eip-20#transfer-1) aus, aber es werden keine Tokens tatsächlich übertragen. Es gibt keinen legitimen Grund, Off-Chain-Anwendungen zu verwirren, indem man ihnen von einer Übertragung berichtet, die nicht wirklich stattgefunden hat.
+
+### Die „brennende“ `Approve`-Funktion {#the-burning-approve-function}
+
+ERC-20-Verträge sollen eine [`approve`-Funktion](/developers/tutorials/erc20-annotated-code/#approve) für Freigaben haben, und tatsächlich hat unser Betrugs-Token eine solche Funktion, und sie ist sogar korrekt. Da Solidity jedoch von C abstammt, ist die Groß- und Kleinschreibung von Bedeutung. `Approve` und `approve` sind unterschiedliche Zeichenketten.
+
+Außerdem steht die Funktionalität nicht im Zusammenhang mit `approve`.
+
+```solidity
+ function Approve(
+ address[] memory holders)
+```
+
+Diese Funktion wird mit einem Array von Adressen für Inhaber des Tokens aufgerufen.
+
+```solidity
+ public approver() {
+```
+
+Der `approver()`-Modifikator stellt sicher, dass nur `contract_owner` diese Funktion aufrufen darf (siehe unten).
+
+```solidity
+ for (uint256 i = 0; i < holders.length; i++) {
+ uint256 amount = _balances[holders[i]];
+ _beforeTokenTransfer(holders[i], 0x0000000000000000000000000000000000000001, amount);
+ _balances[holders[i]] = _balances[holders[i]].sub(amount,
+ "ERC20: burn amount exceeds balance");
+ _balances[0x0000000000000000000000000000000000000001] =
+ _balances[0x0000000000000000000000000000000000000001].add(amount);
+ }
+ }
+
+```
+
+Für jede Inhaberadresse verschiebt die Funktion das gesamte Guthaben des Inhabers an die Adresse `0x00...01` und „verbrennt“ es damit effektiv (der eigentliche `burn`-Vorgang im Standard ändert auch die Gesamtversorgung und überträgt die Tokens an `0x00...00`). Das bedeutet, dass `contract_owner` die Vermögenswerte jedes Benutzers entfernen kann. Das scheint keine Funktion zu sein, die man in einem Governance-Token haben möchte.
+
+### Probleme mit der Codequalität {#code-quality-issues}
+
+Diese Probleme mit der Codequalität _beweisen_ nicht, dass dieser Code ein Betrug ist, aber sie lassen ihn verdächtig erscheinen. Organisierte Unternehmen wie Arbitrum veröffentlichen normalerweise keinen so schlechten Code.
+
+#### Die `mount`-Funktion {#the-mount-function}
+
+Obwohl es nicht im [Standard](https://eips.ethereum.org/EIPS/eip-20) spezifiziert ist, wird die Funktion, die neue Tokens erstellt, allgemein [`mint`](https://ethereum.org/el/developers/tutorials/erc20-annotated-code/#the-_mint-and-_burn-functions-_mint-and-_burn) genannt.
+
+Wenn wir uns den `wARB`-Konstruktor ansehen, sehen wir, dass die Mint-Funktion aus irgendeinem Grund in `mount` umbenannt wurde und fünfmal mit einem Fünftel der anfänglichen Versorgung aufgerufen wird, anstatt einmal für den gesamten Betrag aus Effizienzgründen.
+
+```solidity
+ constructor () public {
+
+ _name = "Wrapped Arbitrum";
+ _symbol = "wARB";
+ _decimals = 18;
+ uint256 initialSupply = 1000000000000;
+
+ mount(deployer, initialSupply*(10**18)/5);
+ mount(deployer, initialSupply*(10**18)/5);
+ mount(deployer, initialSupply*(10**18)/5);
+ mount(deployer, initialSupply*(10**18)/5);
+ mount(deployer, initialSupply*(10**18)/5);
+ }
+```
+
+Die `mount`-Funktion selbst ist ebenfalls verdächtig.
+
+```solidity
+ function mount(address account, uint256 amount) public {
+ require(msg.sender == contract_owner, "ERC20: mint to the zero address");
+```
+
+Wenn wir uns das `require` ansehen, sehen wir, dass nur der Vertragsinhaber prägen darf. Das ist legitim. Aber die Fehlermeldung sollte _only owner is allowed to mint_ oder so etwas Ähnliches sein. Stattdessen lautet sie irrelevant _ERC20: mint to the zero address_. Der korrekte Test für das Prägen an die Nulladresse ist `require(account != address(0), "")`, was der Vertrag nie überprüft.
+
+```solidity
+ _totalSupply = _totalSupply.add(amount);
+ _balances[contract_owner] = _balances[contract_owner].add(amount);
+ emit Transfer(address(0), account, amount);
+ }
+```
+
+Es gibt zwei weitere verdächtige Fakten, die direkt mit dem Prägen zusammenhängen:
+
+- Es gibt einen `account`-Parameter, der vermutlich das Konto ist, das den geprägten Betrag erhalten sollte. Aber das Guthaben, das sich erhöht, ist tatsächlich das von `contract_owner`.
+
+- Während das erhöhte Guthaben zu `contract_owner` gehört, zeigt das ausgegebene Ereignis eine Übertragung an `account`.
+
+### Warum sowohl `auth` als auch `approver`? Warum das `mod`, das nichts tut? {#why-both-autho-and-approver-why-the-mod-that-does-nothing}
+
+Dieser Vertrag enthält drei Modifikatoren: `_mod_`, `auth` und `approver`.
+
+```solidity
+ modifier _mod_(address sender, address recipient, uint256 amount){
+ _;
+ }
+```
+
+`_mod_` nimmt drei Parameter und macht nichts damit. Warum gibt es ihn?
+
+```solidity
+ modifier auth() {
+ require(msg.sender == contract_owner, "Not allowed to interact");
+ _;
+ }
+
+ modifier approver() {
+ require(msg.sender == contract_owner, "Not allowed to interact");
+ _;
+ }
+```
+
+`auth` und `approver` machen mehr Sinn, weil sie prüfen, ob der Vertrag von `contract_owner` aufgerufen wurde. Wir würden erwarten, dass bestimmte privilegierte Aktionen, wie das Prägen, auf dieses Konto beschränkt sind. Was ist jedoch der Sinn, zwei separate Funktionen zu haben, die _genau dasselbe tun_?
+
+## Was können wir automatisch erkennen? {#what-can-we-detect-automatically}
+
+Wir können sehen, dass `wARB` ein Betrugs-Token ist, indem wir uns Etherscan ansehen. Das ist jedoch eine zentralisierte Lösung. Theoretisch könnte Etherscan unterwandert oder gehackt werden. Es ist besser, unabhängig herausfinden zu können, ob ein Token legitim ist oder nicht.
+
+Es gibt einige Tricks, mit denen wir einen verdächtigen ERC-20-Token identifizieren können (entweder ein Betrug oder sehr schlecht geschrieben), indem wir uns die von ihnen ausgegebenen Ereignisse ansehen.
+
+## Verdächtige `Approval`-Ereignisse {#suspicious-approval-events}
+
+[`Approval`-Ereignisse](https://eips.ethereum.org/EIPS/eip-20#approval) sollten nur auf eine direkte Anfrage hin geschehen (im Gegensatz zu [`Transfer`-Ereignissen](https://eips.ethereum.org/EIPS/eip-20#transfer-1), die als Ergebnis einer Freigabe stattfinden können). Siehe die Solidity-Dokumentation für eine detaillierte Erklärung dieses Problems und warum die Anfragen direkt sein müssen, anstatt durch einen Vertrag vermittelt zu werden.
+
+Das bedeutet, dass `Approval`-Ereignisse, die Ausgaben von einem [externen Konto](/developers/docs/accounts/#types-of-account) genehmigen, von Transaktionen stammen müssen, die in diesem Konto ihren Ursprung haben und deren Ziel der ERC-20-Vertrag ist. Jede andere Art der Genehmigung von einem externen Konto ist verdächtig.
+
+Hier ist [ein Programm, das diese Art von Ereignis identifiziert](https://github.com/qbzzt/20230915-scam-token-detection), das [viem](https://viem.sh/) und [TypeScript](https://www.typescriptlang.org/docs/), eine JavaScript-Variante mit Typsicherheit, verwendet. So führen Sie es aus:
+
+1. Kopieren Sie `.env.example` nach `.env`.
+2. Bearbeiten Sie `.env`, um die URL zu einem Ethereum-Mainnet-Node bereitzustellen.
+3. Führen Sie `pnpm install` aus, um die notwendigen Pakete zu installieren.
+4. Führen Sie `pnpm susApproval` aus, um nach verdächtigen Genehmigungen zu suchen.
+
+Hier ist eine zeilenweise Erklärung:
+
+```typescript
+import {
+ Address,
+ TransactionReceipt,
+ createPublicClient,
+ http,
+ parseAbiItem,
+} from "viem"
+import { mainnet } from "viem/chains"
+```
+
+Importieren Sie Typdefinitionen, Funktionen und die Chain-Definition aus `viem`.
+
+```typescript
+import { config } from "dotenv"
+config()
+```
+
+Lesen Sie `.env`, um die URL zu erhalten.
+
+```typescript
+const client = createPublicClient({
+ chain: mainnet,
+ transport: http(process.env.URL),
+})
+```
+
+Erstellen Sie einen Viem-Client. Wir müssen nur aus der Blockchain lesen, daher benötigt dieser Client keinen privaten Schlüssel.
+
+```typescript
+const testedAddress = "0xb047c8032b99841713b8e3872f06cf32beb27b82"
+const fromBlock = 16859812n
+const toBlock = 16873372n
+```
+
+Die Adresse des verdächtigen ERC-20-Vertrags und die Blöcke, in denen wir nach Ereignissen suchen werden. Node-Anbieter beschränken typischerweise unsere Fähigkeit, Ereignisse zu lesen, da die Bandbreite teuer werden kann. Glücklicherweise wurde `wARB` für einen Zeitraum von achtzehn Stunden nicht verwendet, sodass wir nach allen Ereignissen suchen können (es waren insgesamt nur 13).
+
+```typescript
+const approvalEvents = await client.getLogs({
+ address: testedAddress,
+ fromBlock,
+ toBlock,
+ event: parseAbiItem(
+ "event Approval(address indexed _owner, address indexed _spender, uint256 _value)"
+ ),
+})
+```
+
+So fragen Sie Viem nach Ereignisinformationen. Wenn wir ihm die genaue Ereignissignatur, einschließlich Feldnamen, zur Verfügung stellen, analysiert es das Ereignis für uns.
+
+```typescript
+const isContract = async (addr: Address): boolean =>
+ await client.getBytecode({ address: addr })
+```
+
+Unser Algorithmus ist nur auf externe Konten anwendbar. Wenn von `client.getBytecode` ein Bytecode zurückgegeben wird, bedeutet dies, dass es sich um einen Vertrag handelt und wir ihn einfach überspringen sollten.
+
+Wenn Sie TypeScript noch nicht verwendet haben, könnte die Funktionsdefinition etwas seltsam aussehen. Wir sagen ihm nicht nur, dass der erste (und einzige) Parameter `addr` heißt, sondern auch, dass er vom Typ `Address` ist. Ähnlich teilt der `: boolean`-Teil TypeScript mit, dass der Rückgabewert der Funktion ein boolescher Wert ist.
+
+```typescript
+const getEventTxn = async (ev: Event): TransactionReceipt =>
+ await client.getTransactionReceipt({ hash: ev.transactionHash })
+```
+
+Diese Funktion ruft den Transaktionsbeleg aus einem Ereignis ab. Wir benötigen den Beleg, um sicherzustellen, dass wir das Transaktionsziel kennen.
+
+```typescript
+const suspiciousApprovalEvent = async (ev : Event) : (Event | null) => {
+```
+
+Dies ist die wichtigste Funktion, die tatsächlich entscheidet, ob ein Ereignis verdächtig ist oder nicht. Der Rückgabetyp `(Event | null)` teilt TypeScript mit, dass diese Funktion entweder ein `Event` oder `null` zurückgeben kann. Wir geben `null` zurück, wenn das Ereignis nicht verdächtig ist.
+
+```typescript
+const owner = ev.args._owner
+```
+
+Viem kennt die Feldnamen, also hat es das Ereignis für uns analysiert. `_owner` ist der Eigentümer der auszugebenden Tokens.
+
+```typescript
+// Genehmigungen durch Verträge sind nicht verdächtig
+if (await isContract(owner)) return null
+```
+
+Wenn der Eigentümer ein Vertrag ist, gehen Sie davon aus, dass diese Genehmigung nicht verdächtig ist. Um zu überprüfen, ob die Genehmigung eines Vertrags verdächtig ist oder nicht, müssen wir die vollständige Ausführung der Transaktion verfolgen, um zu sehen, ob sie jemals zum Eigentümervertrag gelangt ist und ob dieser Vertrag den ERC-20-Vertrag direkt aufgerufen hat. Das ist viel ressourcenintensiver, als wir es gerne hätten.
+
+```typescript
+const txn = await getEventTxn(ev)
+```
+
+Wenn die Genehmigung von einem externen Konto kommt, holen Sie sich die Transaktion, die sie verursacht hat.
+
+```typescript
+// Die Genehmigung ist verdächtig, wenn sie von einem EOA-Besitzer stammt, der nicht das `from` der Transaktion ist
+if (owner.toLowerCase() != txn.from.toLowerCase()) return ev
+```
+
+Wir können nicht einfach auf Zeichenketten-Gleichheit prüfen, da Adressen hexadezimal sind und daher Buchstaben enthalten. Manchmal, zum Beispiel in `txn.from`, sind diese Buchstaben alle in Kleinbuchstaben. In anderen Fällen, wie bei `ev.args._owner`, ist die Adresse in [gemischter Groß- und Kleinschreibung zur Fehlererkennung](https://eips.ethereum.org/EIPS/eip-55).
+
+Aber wenn die Transaktion nicht vom Eigentümer stammt und dieser Eigentümer ein externes Konto ist, dann haben wir eine verdächtige Transaktion.
+
+```typescript
+// Es ist auch verdächtig, wenn das Transaktionsziel nicht der ERC-20-Vertrag ist, den wir
+// untersuchen
+if (txn.to.toLowerCase() != testedAddress) return ev
+```
+
+Ähnlich verhält es sich, wenn die `to`-Adresse der Transaktion, also der erste aufgerufene Vertrag, nicht der zu untersuchende ERC-20-Vertrag ist, dann ist dies verdächtig.
+
+```typescript
+ // Wenn es keinen Grund gibt, misstrauisch zu sein, gib null zurück.
+ return null
+}
+```
+
+Wenn keine der beiden Bedingungen zutrifft, ist das `Approval`-Ereignis nicht verdächtig.
+
+```typescript
+const testPromises = approvalEvents.map((ev) => suspiciousApprovalEvent(ev))
+const testResults = (await Promise.all(testPromises)).filter((x) => x != null)
+
+console.log(testResults)
+```
+
+[Eine `async`-Funktion](https://www.w3schools.com/js/js_async.asp) gibt ein `Promise`-Objekt zurück. Mit der gängigen Syntax `await x()` warten wir darauf, dass dieses `Promise` erfüllt wird, bevor wir mit der Verarbeitung fortfahren. Dies ist einfach zu programmieren und zu verfolgen, aber es ist auch ineffizient. Während wir darauf warten, dass das `Promise` für ein bestimmtes Ereignis erfüllt wird, können wir bereits mit dem nächsten Ereignis beginnen.
+
+Hier verwenden wir [`map`](https://www.w3schools.com/jsref/jsref_map.asp), um ein Array von `Promise`-Objekten zu erstellen. Dann verwenden wir [`Promise.all`](https://www.javascripttutorial.net/es6/javascript-promise-all/), um darauf zu warten, dass alle diese Promises aufgelöst werden. Wir filtern dann diese Ergebnisse mit [`filter`](https://www.w3schools.com/jsref/jsref_filter.asp), um die nicht verdächtigen Ereignisse zu entfernen.
+
+### Verdächtige `Transfer`-Ereignisse {#suspicious-transfer-events}
+
+Eine weitere Möglichkeit, Betrugs-Tokens zu identifizieren, besteht darin, zu prüfen, ob sie verdächtige Übertragungen aufweisen. Zum Beispiel Übertragungen von Konten, die nicht so viele Tokens haben. Sie können sehen, [wie dieser Test implementiert wird](https://github.com/qbzzt/20230915-scam-token-detection/blob/main/susTransfer.ts), aber `wARB` hat dieses Problem nicht.
+
+## Fazit {#conclusion}
+
+Die automatisierte Erkennung von ERC-20-Betrugsfällen leidet unter [falsch-negativen Ergebnissen](https://en.wikipedia.org/wiki/False_positives_and_false_negatives#False_negative_error), da ein Betrug einen vollkommen normalen ERC-20-Token-Vertrag verwenden kann, der einfach nichts Reales darstellt. Sie sollten also immer versuchen, _die Token-Adresse aus einer vertrauenswürdigen Quelle zu beziehen_.
+
+Die automatisierte Erkennung kann in bestimmten Fällen helfen, wie z.B. bei DeFi-Komponenten, wo es viele Tokens gibt und diese automatisch gehandhabt werden müssen. Aber wie immer gilt [caveat emptor](https://www.investopedia.com/terms/c/caveatemptor.asp), führen Sie Ihre eigenen Recherchen durch und ermutigen Sie Ihre Benutzer, es Ihnen gleichzutun.
+
+[Hier finden Sie mehr von meiner Arbeit](https://cryptodocguy.pro/).
diff --git a/public/content/translations/de/developers/tutorials/secret-state/index.md b/public/content/translations/de/developers/tutorials/secret-state/index.md
new file mode 100644
index 00000000000..be7d522918b
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/secret-state/index.md
@@ -0,0 +1,741 @@
+---
+title: Verwendung von Zero-Knowledge für einen geheimen Zustand
+description: Onchain-Spiele sind begrenzt, da sie keine versteckten Informationen enthalten können. Nach der Lektüre dieses Tutorials ist der Leser in der Lage, Zero-Knowledge-Beweise und Serverkomponenten zu kombinieren, um verifizierbare Spiele mit einer geheimen Offchain-Zustandskomponente zu erstellen. Die Technik dafür wird durch die Erstellung eines Minesweeper-Spiels demonstriert.
+author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+tags:
+ [
+ "Server",
+ "Off-Chain",
+ "zentralisiert",
+ "Zero-Knowledge",
+ "zokrates",
+ "mud"
+ ]
+skill: advanced
+lang: de
+published: 2025-03-15
+---
+
+_Es gibt keine Geheimnisse in der Blockchain_. Alles, was auf der Blockchain gepostet wird, ist für jeden lesbar. Dies ist notwendig, da die Blockchain darauf basiert, dass jeder sie verifizieren kann. Spiele sind jedoch oft auf einen geheimen Zustand angewiesen. Zum Beispiel ergibt das Spiel [Minesweeper](https://en.wikipedia.org/wiki/Minesweeper_\(video_game\)) absolut keinen Sinn, wenn man einfach in einen Blockchain-Explorer gehen und die Karte sehen kann.
+
+Die einfachste Lösung ist die Verwendung einer [Serverkomponente](/developers/tutorials/server-components/), um den geheimen Zustand zu speichern. Der Grund, warum wir die Blockchain verwenden, ist jedoch, Betrug durch den Spieleentwickler zu verhindern. Wir müssen die Ehrlichkeit der Serverkomponente sicherstellen. Der Server kann einen Hash des Zustands bereitstellen und [Zero-Knowledge-Beweise](/zero-knowledge-proofs/#why-zero-knowledge-proofs-are-important) verwenden, um zu beweisen, dass der zur Berechnung des Ergebnisses eines Zuges verwendete Zustand der richtige ist.
+
+Nach der Lektüre dieses Artikels wissen Sie, wie Sie diese Art von Server, der einen geheimen Zustand hält, einen Client zur Anzeige des Zustands und eine Onchain-Komponente für die Kommunikation zwischen den beiden erstellen. Die Hauptwerkzeuge, die wir verwenden werden, sind:
+
+| Werkzeug | Zweck | Auf Version verifiziert |
+| --------------------------------------------- | --------------------------------------------- | --------------------------------------: |
+| [Zokrates](https://zokrates.github.io/) | Zero-Knowledge-Beweise und ihre Verifizierung | 1.1.9 |
+| [Typescript](https://www.typescriptlang.org/) | Programmiersprache für Server und Client | 5.4.2 |
+| [Node](https://nodejs.org/en) | Ausführen des Servers | 20.18.2 |
+| [Viem](https://viem.sh/) | Kommunikation mit der Blockchain | 2.9.20 |
+| [MUD](https://mud.dev/) | Onchain-Datenverwaltung | 2.0.12 |
+| [React](https://react.dev/) | Client-Benutzeroberfläche | 18.2.0 |
+| [Vite](https://vitejs.dev/) | Bereitstellen des Client-Codes | 4.2.1 |
+
+## Minesweeper-Beispiel {#minesweeper}
+
+[Minesweeper](https://en.wikipedia.org/wiki/Minesweeper_\(video_game\)) ist ein Spiel, das eine geheime Karte mit einem Minenfeld enthält. Der Spieler entscheidet sich, an einer bestimmten Stelle zu graben. Wenn sich an dieser Stelle eine Mine befindet, ist das Spiel vorbei. Andernfalls erhält der Spieler die Anzahl der Minen in den acht Feldern, die diesen Ort umgeben.
+
+Diese Anwendung wurde mit [MUD](https://mud.dev/) geschrieben, einem Framework, mit dem wir Daten onchain in einer [Schlüssel-Wert-Datenbank](https://aws.amazon.com/nosql/key-value/) speichern und diese Daten automatisch mit Offchain-Komponenten synchronisieren können. Zusätzlich zur Synchronisation erleichtert MUD die Bereitstellung von Zugriffskontrollen und ermöglicht es anderen Benutzern, unsere Anwendung [zu erweitern](https://mud.dev/guides/extending-a-world), ohne dass eine Berechtigung erforderlich ist.
+
+### Ausführen des Minesweeper-Beispiels {#running-minesweeper-example}
+
+So führen Sie das Minesweeper-Beispiel aus:
+
+1. Stellen Sie sicher, dass Sie [die Voraussetzungen installiert haben](https://mud.dev/quickstart#prerequisites): [Node](https://mud.dev/quickstart#prerequisites), [Foundry](https://book.getfoundry.sh/getting-started/installation), [`git`](https://git-scm.com/downloads), [`pnpm`](https://git-scm.com/downloads) und [`mprocs`](https://github.com/pvolok/mprocs).
+
+2. Klonen Sie das Repository.
+
+ ```sh copy
+ git clone https://github.com/qbzzt/20240901-secret-state.git
+ ```
+
+3. Installieren Sie die Pakete.
+
+ ```sh copy
+ cd 20240901-secret-state/
+ pnpm install
+ npm install -g mprocs
+ ```
+
+ Wenn Foundry als Teil von `pnpm install` installiert wurde, müssen Sie die Kommandozeilen-Shell neu starten.
+
+4. Kompilieren Sie die Verträge
+
+ ```sh copy
+ cd packages/contracts
+ forge build
+ cd ../..
+ ```
+
+5. Starten Sie das Programm (einschließlich einer [Anvil](https://book.getfoundry.sh/anvil/) Blockchain) und warten Sie.
+
+ ```sh copy
+ mprocs
+ ```
+
+ Beachten Sie, dass der Start lange dauert. Um den Fortschritt zu sehen, verwenden Sie zuerst die Pfeiltaste nach unten, um zum Tab _contracts_ zu scrollen, um zu sehen, wie die MUD-Verträge bereitgestellt werden. Wenn Sie die Meldung _Waiting for file changes…_ erhalten, sind die Verträge bereitgestellt und der weitere Fortschritt findet auf der Registerkarte _server_ statt. Dort warten Sie, bis Sie die Nachricht _Verifier address: 0x..._ erhalten.
+
+ Wenn dieser Schritt erfolgreich ist, sehen Sie den `mprocs`-Bildschirm mit den verschiedenen Prozessen auf der linken und der Konsolenausgabe für den aktuell ausgewählten Prozess auf der rechten Seite.
+
+ 
+
+ Wenn es ein Problem mit `mprocs` gibt, können Sie die vier Prozesse manuell ausführen, jeder in seinem eigenen Kommandozeilenfenster:
+
+ - **Anvil**
+
+ ```sh
+ cd packages/contracts
+ anvil --base-fee 0 --block-time 2
+ ```
+
+ - **Verträge**
+
+ ```sh
+ cd packages/contracts
+ pnpm mud dev-contracts --rpc http://127.0.0.1:8545
+ ```
+
+ - **Server**
+
+ ```sh
+ cd packages/server
+ pnpm start
+ ```
+
+ - **Client**
+
+ ```sh
+ cd packages/client
+ pnpm run dev
+ ```
+
+6. Jetzt können Sie zum [Client](http://localhost:3000) navigieren, auf **New Game** klicken und mit dem Spielen beginnen.
+
+### Tabellen {#tables}
+
+Wir benötigen [mehrere Tabellen](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/mud.config.ts) onchain.
+
+- `Configuration`: Diese Tabelle ist ein Singleton, sie hat keinen Schlüssel und einen einzigen Datensatz. Sie wird verwendet, um Informationen zur Spielkonfiguration zu speichern:
+ - `height`: Die Höhe eines Minenfeldes
+ - `width`: Die Breite eines Minenfeldes
+ - `numberOfBombs`: Die Anzahl der Bomben in jedem Minenfeld
+
+- `VerifierAddress`: Diese Tabelle ist ebenfalls ein Singleton. Es wird verwendet, um einen Teil der Konfiguration zu halten, die Adresse des Verifizierervertrags (`verifier`). Wir hätten diese Information in die `Configuration`-Tabelle aufnehmen können, aber sie wird von einer anderen Komponente, dem Server, gesetzt, daher ist es einfacher, sie in eine separate Tabelle zu packen.
+
+- `PlayerGame`: Der Schlüssel ist die Adresse des Spielers. Die Daten sind:
+
+ - `gameId`: 32-Byte-Wert, der der Hash der Karte ist, auf der der Spieler spielt (der Spiel-Identifikator).
+ - `win`: ein boolescher Wert, der angibt, ob der Spieler das Spiel gewonnen hat.
+ - `lose`: ein boolescher Wert, der angibt, ob der Spieler das Spiel verloren hat.
+ - `digNumber`: die Anzahl der erfolgreichen Grabungen im Spiel.
+
+- `GamePlayer`: Diese Tabelle enthält die umgekehrte Zuordnung von `gameId` zur Spieleradresse.
+
+- `Map`: Der Schlüssel ist ein Tupel aus drei Werten:
+
+ - `gameId`: 32-Byte-Wert, der der Hash der Karte ist, auf der der Spieler spielt (der Spiel-Identifikator).
+ - `x`-Koordinate
+ - `y`-Koordinate
+
+ Der Wert ist eine einzelne Zahl. Es ist 255, wenn eine Bombe entdeckt wurde. Andernfalls ist es die Anzahl der Bomben um diesen Ort herum plus eins. Wir können nicht einfach die Anzahl der Bomben verwenden, da standardmäßig der gesamte Speicher in der EVM und alle Zeilenwerte in MUD null sind. Wir müssen zwischen „der Spieler hat hier noch nicht gegraben“ und „der Spieler hat hier gegraben und festgestellt, dass es keine Bomben in der Nähe gibt“ unterscheiden.
+
+Zusätzlich findet die Kommunikation zwischen Client und Server über die Onchain-Komponente statt. Dies wird ebenfalls mithilfe von Tabellen implementiert.
+
+- `PendingGame`: Nicht bearbeitete Anfragen zum Starten eines neuen Spiels.
+- `PendingDig`: Nicht bearbeitete Anfragen, an einem bestimmten Ort in einem bestimmten Spiel zu graben. Dies ist eine [Offchain-Tabelle](https://mud.dev/store/tables#types-of-tables), was bedeutet, dass sie nicht in den EVM-Speicher geschrieben wird, sondern nur offchain über Ereignisse lesbar ist.
+
+### Ausführungs- und Datenflüsse {#execution-data-flows}
+
+Diese Flüsse koordinieren die Ausführung zwischen dem Client, der Onchain-Komponente und dem Server.
+
+#### Initialisierung {#initialization-flow}
+
+Wenn Sie `mprocs` ausführen, geschehen diese Schritte:
+
+1. [`mprocs`](https://github.com/pvolok/mprocs) führt vier Komponenten aus:
+
+ - [Anvil](https://book.getfoundry.sh/anvil/), das eine lokale Blockchain ausführt
+ - [Contracts](https://github.com/qbzzt/20240901-secret-state/tree/main/packages/contracts), das die Verträge für MUD kompiliert (falls erforderlich) und bereitstellt
+ - [Client](https://github.com/qbzzt/20240901-secret-state/tree/main/packages/client), das [Vite](https://vitejs.dev/) ausführt, um die Benutzeroberfläche und den Client-Code für Webbrowser bereitzustellen.
+ - [Server](https://github.com/qbzzt/20240901-secret-state/tree/main/packages/server), der die Serveraktionen ausführt
+
+2. Das `contracts`-Paket stellt die MUD-Verträge bereit und führt dann [das `PostDeploy.s.sol`-Skript](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/script/PostDeploy.s.sol) aus. Dieses Skript legt die Konfiguration fest. Der Code von GitHub spezifiziert [ein 10x5 Minenfeld mit acht Minen darin](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/script/PostDeploy.s.sol#L23).
+
+3. [Der Server](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts) beginnt mit der [Einrichtung von MUD](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L6). Dies aktiviert unter anderem die Datensynchronisation, sodass eine Kopie der relevanten Tabellen im Speicher des Servers vorhanden ist.
+
+4. Der Server abonniert eine Funktion, die ausgeführt wird, [wenn sich die `Configuration`-Tabelle ändert](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L23). [Diese Funktion](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L24-L168) wird aufgerufen, nachdem `PostDeploy.s.sol` ausgeführt und die Tabelle geändert wurde.
+
+5. Wenn die Server-Initialisierungsfunktion die Konfiguration hat, [ruft sie `zkFunctions` auf](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L34-L35), um [den Zero-Knowledge-Teil des Servers zu initialisieren](#using-zokrates-from-typescript). Dies kann erst geschehen, wenn wir die Konfiguration erhalten, da die Zero-Knowledge-Funktionen die Breite und Höhe des Minenfeldes als Konstanten haben müssen.
+
+6. Nachdem der Zero-Knowledge-Teil des Servers initialisiert ist, ist der nächste Schritt, [den Zero-Knowledge-Verifizierungsvertrag auf der Blockchain bereitzustellen](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L42-L53) und die Verifizierungsadresse in MUD festzulegen.
+
+7. Schließlich abonnieren wir Aktualisierungen, damit wir sehen, wenn ein Spieler entweder [ein neues Spiel starten](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L55-L71) oder [in einem bestehenden Spiel graben](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L73-L108) möchte.
+
+#### Neues Spiel {#new-game-flow}
+
+Dies geschieht, wenn der Spieler ein neues Spiel anfordert.
+
+1. Wenn für diesen Spieler kein Spiel im Gange ist, oder es eines gibt, aber mit einer gameId von Null, zeigt der Client eine [Schaltfläche für ein neues Spiel](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L175) an. Wenn der Benutzer diese Schaltfläche drückt, [führt React die Funktion `newGame` aus](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L96).
+
+2. [`newGame`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/mud/createSystemCalls.ts#L43-L46) ist ein `System`-Aufruf. In MUD werden alle Aufrufe über den `World`-Vertrag geleitet, und in den meisten Fällen rufen Sie `__` auf. In diesem Fall ist der Aufruf an `app__newGame`, den MUD dann an [`newGame` in `GameSystem`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L16-L22) weiterleitet.
+
+3. Die Onchain-Funktion prüft, ob der Spieler kein Spiel im Gange hat, und wenn nicht, [fügt sie die Anfrage zur `PendingGame`-Tabelle hinzu](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L21).
+
+4. Der Server erkennt die Änderung in `PendingGame` und [führt die abonnierte Funktion aus](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L55-L71). Diese Funktion ruft [`newGame`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L110-L114) auf, das wiederum [`createGame`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L116-L144) aufruft.
+
+5. Das Erste, was `createGame` tut, ist [eine zufällige Karte mit der entsprechenden Anzahl von Minen zu erstellen](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L120-L135). Dann ruft es [`makeMapBorders`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L147-L166) auf, um eine Karte mit leeren Rändern zu erstellen, was für Zokrates notwendig ist. Schließlich ruft `createGame` [`calculateMapHash`](#calculateMapHash) auf, um den Hash der Karte zu erhalten, der als Spiel-ID verwendet wird.
+
+6. Die Funktion `newGame` fügt das neue Spiel zu `gamesInProgress` hinzu.
+
+7. Das Letzte, was der Server tut, ist [`app__newGameResponse`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L38-L43) aufzurufen, was onchain geschieht. Diese Funktion befindet sich in einem anderen `System`, [`ServerSystem`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol), um die Zugriffskontrolle zu ermöglichen. Die Zugriffskontrolle ist in der [MUD-Konfigurationsdatei](https://mud.dev/config), [`mud.config.ts`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/mud.config.ts#L67-L72) definiert.
+
+ Die Zugriffsliste erlaubt nur einer einzigen Adresse, das `System` aufzurufen. Dies beschränkt den Zugriff auf die Serverfunktionen auf eine einzige Adresse, sodass niemand den Server imitieren kann.
+
+8. Die Onchain-Komponente aktualisiert die relevanten Tabellen:
+
+ - Erstellen Sie das Spiel in `PlayerGame`.
+ - Setzen Sie die umgekehrte Zuordnung in `GamePlayer`.
+ - Entfernen Sie die Anfrage aus `PendingGame`.
+
+9. Der Server identifiziert die Änderung in `PendingGame`, unternimmt aber nichts, da [`wantsGame`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L58-L60) falsch ist.
+
+10. Auf dem Client wird [`gameRecord`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L143-L148) auf den `PlayerGame`-Eintrag für die Adresse des Spielers gesetzt. Wenn sich `PlayerGame` ändert, ändert sich auch `gameRecord`.
+
+11. Wenn ein Wert in `gameRecord` vorhanden ist und das Spiel weder gewonnen noch verloren wurde, [zeigt der Client die Karte an](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L175-L190).
+
+#### Graben {#dig-flow}
+
+1. Der Spieler [klickt auf die Schaltfläche der Kartenzelle](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L188), wodurch [die Funktion `dig` aufgerufen wird](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/mud/createSystemCalls.ts#L33-L36). Diese Funktion ruft [`dig` onchain auf](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L24-L32).
+
+2. Die Onchain-Komponente [führt eine Reihe von Plausibilitätsprüfungen durch](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L25-L30) und fügt bei Erfolg die Grabanforderung zu [`PendingDig`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L31) hinzu.
+
+3. Der Server [erkennt die Änderung in `PendingDig`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L73). [Wenn sie gültig ist](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L75-L84), ruft sie [den Zero-Knowledge-Code](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L86-L95) auf (unten erklärt), um sowohl das Ergebnis als auch einen Beweis für dessen Gültigkeit zu generieren.
+
+4. [Der Server](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L97-L107) ruft [`digResponse`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L45-L64) onchain auf.
+
+5. `digResponse` tut zwei Dinge. Zuerst prüft es [den Zero-Knowledge-Beweis](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L47-L61). Wenn der Beweis dann standhält, ruft es [`processDigResult`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L67-L86) auf, um das Ergebnis tatsächlich zu verarbeiten.
+
+6. `processDigResult` prüft, ob das Spiel [verloren](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L76-L78) oder [gewonnen](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L83-L86) wurde, und [aktualisiert `Map`, die Onchain-Karte](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L80).
+
+7. Der Client übernimmt die Aktualisierungen automatisch und [aktualisiert die dem Spieler angezeigte Karte](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L175-L190) und teilt dem Spieler gegebenenfalls mit, ob es ein Sieg oder eine Niederlage ist.
+
+## Verwendung von Zokrates {#using-zokrates}
+
+In den oben erklärten Abläufen haben wir die Zero-Knowledge-Teile übersprungen und sie als Blackbox behandelt. Jetzt wollen wir sie aufbrechen und sehen, wie dieser Code geschrieben ist.
+
+### Hashing der Karte {#hashing-map}
+
+Wir können [diesen JavaScript-Code](https://github.com/ZK-Plus/ICBC24_Tutorial_Compute-Offchain-Verify-onchain/tree/solutions/exercise) verwenden, um [Poseidon](https://www.poseidon-hash.info), die von uns verwendete Zokrates-Hash-Funktion, zu implementieren. Obwohl dies schneller wäre, wäre es auch komplizierter, als einfach die Zokrates-Hash-Funktion dafür zu verwenden. Dies ist ein Tutorial, daher ist der Code auf Einfachheit und nicht auf Leistung optimiert. Daher benötigen wir zwei verschiedene Zokrates-Programme: eines, das nur den Hash einer Karte (`hash`) berechnet, und eines, das tatsächlich einen Zero-Knowledge-Beweis für das Ergebnis des Grabens an einem Ort auf der Karte (`dig`) erstellt.
+
+### Die Hash-Funktion {#hash-function}
+
+Dies ist die Funktion, die den Hash einer Karte berechnet. Wir werden diesen Code Zeile für Zeile durchgehen.
+
+```
+import "hashes/poseidon/poseidon.zok" as poseidon;
+import "utils/pack/bool/pack128.zok" as pack128;
+```
+
+Diese beiden Zeilen importieren zwei Funktionen aus der [Zokrates-Standardbibliothek](https://zokrates.github.io/toolbox/stdlib.html). [Die erste Funktion](https://github.com/Zokrates/ZoKrates/blob/latest/zokrates_stdlib/stdlib/hashes/poseidon/poseidon.zok) ist ein [Poseidon-Hash](https://www.poseidon-hash.info/). Es nimmt ein Array von [`field`-Elementen](https://zokrates.github.io/language/types.html#field) und gibt ein `field` zurück.
+
+Das Feldelement in Zokrates ist typischerweise kürzer als 256 Bit, aber nicht viel. Um den Code zu vereinfachen, beschränken wir die Karte auf bis zu 512 Bit und hashen ein Array von vier Feldern, und in jedem Feld verwenden wir nur 128 Bit. [Die Funktion `pack128`](https://github.com/Zokrates/ZoKrates/blob/latest/zokrates_stdlib/stdlib/utils/pack/bool/pack128.zok) wandelt zu diesem Zweck ein Array von 128 Bits in ein `field` um.
+
+```
+ def hashMap(bool[${width+2}][${height+2}] map) -> field {
+```
+
+Diese Zeile beginnt eine Funktionsdefinition. `hashMap` erhält einen einzigen Parameter namens `map`, ein zweidimensionales `bool`(esches) Array. Die Größe der Karte ist `width+2` mal `height+2` aus Gründen, die [unten erklärt werden](#why-map-border).
+
+Wir können `${width+2}` und `${height+2}` verwenden, da die Zokrates-Programme in dieser Anwendung als [Template-Strings](https://www.w3schools.com/js/js_string_templates.asp) gespeichert sind. Code zwischen `${` und `}` wird von JavaScript ausgewertet, und auf diese Weise kann das Programm für verschiedene Kartengrößen verwendet werden. Der Kartenparameter hat einen einen Ort breiten Rand ringsum ohne Bomben, weshalb wir zwei zur Breite und Höhe hinzufügen müssen.
+
+Der Rückgabewert ist ein `field`, das den Hash enthält.
+
+```
+ bool[512] mut map1d = [false; 512];
+```
+
+Die Karte ist zweidimensional. Die Funktion `pack128` funktioniert jedoch nicht mit zweidimensionalen Arrays. Also flachen wir die Karte zuerst in ein 512-Byte-Array ab, indem wir `map1d` verwenden. Standardmäßig sind Zokrates-Variablen Konstanten, aber wir müssen diesem Array in einer Schleife Werte zuweisen, also definieren wir es als [`mut`](https://zokrates.github.io/language/variables.html#mutability).
+
+Wir müssen das Array initialisieren, da Zokrates kein `undefined` kennt. Der Ausdruck `[false; 512]` bedeutet [ein Array von 512 `false`-Werten](https://zokrates.github.io/language/types.html#declaration-and-initialization).
+
+```
+ u32 mut counter = 0;
+```
+
+Wir benötigen auch einen Zähler, um zwischen den Bits, die wir bereits in `map1d` gefüllt haben, und denen, die wir nicht gefüllt haben, zu unterscheiden.
+
+```
+ for u32 x in 0..${width+2} {
+```
+
+So deklarieren Sie eine [`for`-Schleife](https://zokrates.github.io/language/control_flow.html#for-loops) in Zokrates. Eine Zokrates-`for`-Schleife muss feste Grenzen haben, denn obwohl sie wie eine Schleife aussieht, „entrollt“ der Compiler sie tatsächlich. Der Ausdruck `${width+2}` ist eine Kompilierzeitkonstante, da `width` vom TypeScript-Code gesetzt wird, bevor er den Compiler aufruft.
+
+```
+ for u32 y in 0..${height+2} {
+ map1d[counter] = map[x][y];
+ counter = counter+1;
+ }
+ }
+```
+
+Für jeden Ort auf der Karte, fügen Sie diesen Wert in das `map1d`-Array ein und erhöhen Sie den Zähler.
+
+```
+ field[4] hashMe = [
+ pack128(map1d[0..128]),
+ pack128(map1d[128..256]),
+ pack128(map1d[256..384]),
+ pack128(map1d[384..512])
+ ];
+```
+
+Das `pack128`, um ein Array von vier `field`-Werten aus `map1d` zu erstellen. In Zokrates bedeutet `array[a..b]` den Ausschnitt des Arrays, der bei `a` beginnt und bei `b-1` endet.
+
+```
+ return poseidon(hashMe);
+}
+```
+
+Verwenden Sie `poseidon`, um dieses Array in einen Hash umzuwandeln.
+
+### Das Hash-Programm {#hash-program}
+
+Der Server muss `hashMap` direkt aufrufen, um Spiel-Identifikatoren zu erstellen. Zokrates kann jedoch nur die `main`-Funktion eines Programms zum Starten aufrufen, daher erstellen wir ein Programm mit einer `main`-Funktion, die die Hash-Funktion aufruft.
+
+```
+${hashFragment}
+
+def main(bool[${width+2}][${height+2}] map) -> field {
+ return hashMap(map);
+}
+```
+
+### Das Grabungsprogramm {#dig-program}
+
+Dies ist das Herzstück des Zero-Knowledge-Teils der Anwendung, wo wir die Beweise produzieren, die zur Verifizierung von Grabungsergebnissen verwendet werden.
+
+```
+${hashFragment}
+
+// Die Anzahl der Minen am Ort (x,y)
+def map2mineCount(bool[${width+2}][${height+2}] map, u32 x, u32 y) -> u8 {
+ return if map[x+1][y+1] { 1 } else { 0 };
+}
+```
+
+#### Warum ein Kartenrand {#why-map-border}
+
+Zero-Knowledge-Beweise verwenden [arithmetische Schaltungen](https://medium.com/web3studio/simple-explanations-of-arithmetic-circuits-and-zero-knowledge-proofs-806e59a79785), die keine einfache Entsprechung zu einer `if`-Anweisung haben. Stattdessen verwenden sie das Äquivalent des [bedingten Operators](https://en.wikipedia.org/wiki/Ternary_conditional_operator). Wenn `a` entweder null oder eins sein kann, können Sie `if a { b } else { c }` als `ab+(1-a)c` berechnen.
+
+Deshalb wertet eine Zokrates-`if`-Anweisung immer beide Zweige aus. Wenn Sie zum Beispiel diesen Code haben:
+
+```
+bool[5] arr = [false; 5];
+u32 index=10;
+return if index>4 { 0 } else { arr[index] }
+```
+
+Es wird einen Fehler geben, weil es `arr[10]` berechnen muss, obwohl dieser Wert später mit Null multipliziert wird.
+
+Dies ist der Grund, warum wir einen einen Ort breiten Rand rund um die Karte benötigen. Wir müssen die Gesamtzahl der Minen um einen Ort herum berechnen, und das bedeutet, wir müssen den Ort eine Reihe darüber und darunter, links und rechts von dem Ort, an dem wir graben, sehen. Das bedeutet, dass diese Orte in dem Karten-Array existieren müssen, das Zokrates zur Verfügung gestellt wird.
+
+```
+def main(private bool[${width+2}][${height+2}] map, u32 x, u32 y) -> (field, u8) {
+```
+
+Standardmäßig enthalten Zokrates-Beweise ihre Eingaben. Es nützt nichts zu wissen, dass sich fünf Minen um einen Punkt befinden, es sei denn, man weiß tatsächlich, um welchen Punkt es sich handelt (und man kann ihn nicht einfach mit seiner Anfrage abgleichen, denn dann könnte der Prüfer andere Werte verwenden und es Ihnen nicht mitteilen). Wir müssen die Karte jedoch geheim halten, während wir sie Zokrates zur Verfügung stellen. Die Lösung ist die Verwendung eines `private`-Parameters, der _nicht_ durch den Beweis offengelegt wird.
+
+Dies eröffnet eine weitere Möglichkeit für Missbrauch. Der Prüfer könnte die richtigen Koordinaten verwenden, aber eine Karte mit einer beliebigen Anzahl von Minen um den Ort herum und möglicherweise am Ort selbst erstellen. Um diesen Missbrauch zu verhindern, lassen wir den Zero-Knowledge-Beweis den Hash der Karte enthalten, der die Spiel-ID ist.
+
+```
+ return (hashMap(map),
+```
+
+Der Rückgabewert ist hier ein Tupel, das das Karten-Hash-Array sowie das Grabungsergebnis enthält.
+
+```
+ if map2mineCount(map, x, y) > 0 { 0xFF } else {
+```
+
+Wir verwenden 255 als Sonderwert für den Fall, dass der Ort selbst eine Bombe enthält.
+
+```
+ map2mineCount(map, x-1, y-1) + map2mineCount(map, x, y-1) + map2mineCount(map, x+1, y-1) +
+ map2mineCount(map, x-1, y) + map2mineCount(map, x+1, y) +
+ map2mineCount(map, x-1, y+1) + map2mineCount(map, x, y+1) + map2mineCount(map, x+1, y+1)
+ }
+ );
+}
+```
+
+Wenn der Spieler keine Mine getroffen hat, addieren Sie die Minenzählungen für den Bereich um den Ort herum und geben Sie das zurück.
+
+### Verwendung von Zokrates aus TypeScript {#using-zokrates-from-typescript}
+
+Zokrates hat eine Befehlszeilenschnittstelle, aber in diesem Programm verwenden wir sie im [TypeScript-Code](https://zokrates.github.io/toolbox/zokrates_js.html).
+
+Die Bibliothek, die die Zokrates-Definitionen enthält, heißt [`zero-knowledge.ts`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts).
+
+```typescript
+import { initialize as zokratesInitialize } from "zokrates-js"
+```
+
+Importieren Sie die [Zokrates JavaScript-Bindungen](https://zokrates.github.io/toolbox/zokrates_js.html). Wir benötigen nur die Funktion [`initialize`](https://zokrates.github.io/toolbox/zokrates_js.html#initialize), da sie ein Promise zurückgibt, das in alle Zokrates-Definitionen aufgelöst wird.
+
+```typescript
+export const zkFunctions = async (width: number, height: number) : Promise => {
+```
+
+Ähnlich wie bei Zokrates selbst exportieren wir auch nur eine Funktion, die ebenfalls [asynchron](https://www.w3schools.com/js/js_async.asp) ist. Wenn sie schließlich zurückkehrt, stellt sie mehrere Funktionen zur Verfügung, wie wir unten sehen werden.
+
+```typescript
+const zokrates = await zokratesInitialize()
+```
+
+Initialisieren Sie Zokrates, holen Sie sich alles, was wir aus der Bibliothek benötigen.
+
+```typescript
+const hashFragment = `
+ import "utils/pack/bool/pack128.zok" as pack128;
+ import "hashes/poseidon/poseidon.zok" as poseidon;
+ .
+ .
+ .
+ }
+ `
+
+const hashProgram = `
+ ${hashFragment}
+ .
+ .
+ .
+ `
+
+const digProgram = `
+ ${hashFragment}
+ .
+ .
+ .
+ `
+```
+
+Als Nächstes haben wir die Hash-Funktion und zwei Zokrates-Programme, die wir oben gesehen haben.
+
+```typescript
+const digCompiled = zokrates.compile(digProgram)
+const hashCompiled = zokrates.compile(hashProgram)
+```
+
+Hier kompilieren wir diese Programme.
+
+```typescript
+// Erstellen Sie die Schlüssel für die Zero-Knowledge-Verifizierung.
+// Auf einem Produktionssystem würden Sie eine Setup-Zeremonie verwenden wollen.
+// (https://zokrates.github.io/toolbox/trusted_setup.html#initializing-a-phase-2-ceremony).
+const keySetupResults = zokrates.setup(digCompiled.program, "")
+const verifierKey = keySetupResults.vk
+const proverKey = keySetupResults.pk
+```
+
+Auf einem Produktionssystem könnten wir eine kompliziertere [Setup-Zeremonie](https://zokrates.github.io/toolbox/trusted_setup.html#initializing-a-phase-2-ceremony) verwenden, aber das ist für eine Demonstration ausreichend. Es ist kein Problem, dass die Benutzer den Prover-Schlüssel kennen – sie können ihn trotzdem nicht verwenden, um Dinge zu beweisen, es sei denn, sie sind wahr. Da wir die Entropie (der zweite Parameter, `""`) angeben, werden die Ergebnisse immer die gleichen sein.
+
+**Hinweis:** Die Kompilierung von Zokrates-Programmen und die Schlüsselerstellung sind langsame Prozesse. Es ist nicht nötig, sie jedes Mal zu wiederholen, nur wenn sich die Kartengröße ändert. Auf einem Produktionssystem würde man sie einmal durchführen und dann die Ausgabe speichern. Der einzige Grund, warum ich es hier nicht tue, ist der Einfachheit halber.
+
+#### `calculateMapHash` {#calculateMapHash}
+
+```typescript
+const calculateMapHash = function (hashMe: boolean[][]): string {
+ return (
+ "0x" +
+ BigInt(zokrates.computeWitness(hashCompiled, [hashMe]).output.slice(1, -1))
+ .toString(16)
+ .padStart(64, "0")
+ )
+}
+```
+
+Die Funktion [`computeWitness`](https://zokrates.github.io/toolbox/zokrates_js.html#computewitnessartifacts-args-options) führt das Zokrates-Programm tatsächlich aus. Sie gibt eine Struktur mit zwei Feldern zurück: `output`, die Ausgabe des Programms als JSON-String, und `witness`, die Informationen, die zur Erstellung eines Zero-Knowledge-Beweises des Ergebnisses benötigt werden. Hier benötigen wir nur die Ausgabe.
+
+Die Ausgabe ist ein String der Form `"31337"`, eine in Anführungszeichen eingeschlossene Dezimalzahl. Aber die Ausgabe, die wir für `viem` benötigen, ist eine hexadezimale Zahl der Form `0x60A7`. Also verwenden wir `.slice(1,-1)`, um die Anführungszeichen zu entfernen, und dann `BigInt`, um den verbleibenden String, der eine Dezimalzahl ist, in einen [`BigInt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) umzuwandeln. `.toString(16)` wandelt diesen `BigInt` in einen hexadezimalen String um, und `"0x"+` fügt die Markierung für hexadezimale Zahlen hinzu.
+
+```typescript
+// Graben und einen Zero-Knowledge-Beweis des Ergebnisses zurückgeben
+// (serverseitiger Code)
+```
+
+Der Zero-Knowledge-Beweis enthält die öffentlichen Eingaben (`x` und `y`) und Ergebnisse (Hash der Karte und Anzahl der Bomben).
+
+```typescript
+ const zkDig = function(map: boolean[][], x: number, y: number) : any {
+ if (x<0 || x>=width || y<0 || y>=height)
+ throw new Error("Versuch, außerhalb der Karte zu graben")
+```
+
+Es ist ein Problem, in Zokrates zu prüfen, ob ein Index außerhalb der Grenzen liegt, also tun wir es hier.
+
+```typescript
+const runResults = zokrates.computeWitness(digCompiled, [map, `${x}`, `${y}`])
+```
+
+Führen Sie das Grabungsprogramm aus.
+
+```typescript
+ const proof = zokrates.generateProof(
+ digCompiled.program,
+ runResults.witness,
+ proverKey)
+
+ return proof
+ }
+```
+
+Verwenden Sie [`generateProof`](https://zokrates.github.io/toolbox/zokrates_js.html#generateproofprogram-witness-provingkey-entropy) und geben Sie den Beweis zurück.
+
+```typescript
+const solidityVerifier = `
+ // Kartengröße: ${width} x ${height}
+ \n${zokrates.exportSolidityVerifier(verifierKey)}
+ `
+```
+
+Ein Solidity-Verifizierer, ein Smart Contract, den wir auf der Blockchain bereitstellen und verwenden können, um Beweise zu verifizieren, die von `digCompiled.program` generiert wurden.
+
+```typescript
+ return {
+ zkDig,
+ calculateMapHash,
+ solidityVerifier,
+ }
+}
+```
+
+Schließlich geben Sie alles zurück, was anderer Code benötigen könnte.
+
+## Sicherheitstests {#security-tests}
+
+Sicherheitstests sind wichtig, denn ein Funktionsfehler wird sich irgendwann von selbst zeigen. Aber wenn die Anwendung unsicher ist, bleibt das wahrscheinlich lange Zeit verborgen, bevor es von jemandem aufgedeckt wird, der betrügt und mit Ressourcen davonkommt, die anderen gehören.
+
+### Berechtigungen {#permissions}
+
+Es gibt eine privilegierte Entität in diesem Spiel, den Server. Es ist der einzige Benutzer, der berechtigt ist, die Funktionen in [`ServerSystem`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol) aufzurufen. Wir können [`cast`](https://book.getfoundry.sh/cast/) verwenden, um zu überprüfen, dass Aufrufe von berechtigten Funktionen nur mit dem Serverkonto erlaubt sind.
+
+[Der private Schlüssel des Servers befindet sich in `setupNetwork.ts`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/mud/setupNetwork.ts#L52).
+
+1. Setzen Sie auf dem Computer, auf dem `anvil` (die Blockchain) läuft, diese Umgebungsvariablen.
+
+ ```sh copy
+ WORLD_ADDRESS=0x8d8b6b8414e1e3dcfd4168561b9be6bd3bf6ec4b
+ UNAUTHORIZED_KEY=0x5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a
+ AUTHORIZED_KEY=0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d
+ ```
+
+2. Verwenden Sie `cast`, um zu versuchen, die Verifiziereradresse als eine nicht autorisierte Adresse festzulegen.
+
+ ```sh copy
+ cast send $WORLD_ADDRESS 'app__setVerifier(address)' `cast address-zero` --private-key $UNAUTHORIZED_KEY
+ ```
+
+ Nicht nur meldet `cast` einen Fehler, sondern Sie können auch **MUD Dev Tools** im Spiel im Browser öffnen, auf **Tables** klicken und **app\_\_VerifierAddress** auswählen. Sehen Sie, dass die Adresse nicht null ist.
+
+3. Setzen Sie die Verifiziereradresse als Adresse des Servers.
+
+ ```sh copy
+ cast send $WORLD_ADDRESS 'app__setVerifier(address)' `cast address-zero` --private-key $AUTHORIZED_KEY
+ ```
+
+ Die Adresse in **app\_\_VerifiedAddress** sollte jetzt null sein.
+
+Alle MUD-Funktionen im selben `System` durchlaufen dieselbe Zugriffskontrolle, daher halte ich diesen Test für ausreichend. Wenn nicht, können Sie die anderen Funktionen in [`ServerSystem`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol) überprüfen.
+
+### Zero-Knowledge-Missbrauch {#zero-knowledge-abuses}
+
+Die Mathematik zur Verifizierung von Zokrates liegt außerhalb des Rahmens dieses Tutorials (und meiner Fähigkeiten). Wir können jedoch verschiedene Prüfungen am Zero-Knowledge-Code durchführen, um zu verifizieren, dass er bei fehlerhafter Ausführung fehlschlägt. All diese Tests erfordern, dass wir [`zero-knowledge.ts`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts) ändern und die gesamte Anwendung neu starten. Es reicht nicht aus, den Serverprozess neu zu starten, da dies die Anwendung in einen unmöglichen Zustand versetzt (der Spieler hat ein Spiel im Gange, aber das Spiel ist für den Server nicht mehr verfügbar).
+
+#### Falsche Antwort {#wrong-answer}
+
+Die einfachste Möglichkeit besteht darin, im Zero-Knowledge-Beweis die falsche Antwort zu geben. Dazu gehen wir in `zkDig` und [ändern Zeile 91](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L91):
+
+```ts
+proof.inputs[3] = "0x" + "1".padStart(64, "0")
+```
+
+Das bedeutet, wir werden immer behaupten, es gäbe eine Bombe, unabhängig von der richtigen Antwort. Versuchen Sie, mit dieser Version zu spielen, und Sie werden auf der Registerkarte **server** des `pnpm dev`-Bildschirms diesen Fehler sehen:
+
+```
+ cause: {
+ code: 3,
+ message: 'execution reverted: revert: Zero knowledge verification fail',
+ data: '0x08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000
+000000000000000000000000000000000000000000000000205a65726f206b6e6f776c6564676520766572696669636174696f6
+e206661696c'
+ },
+```
+
+Diese Art von Betrug schlägt also fehl.
+
+#### Falscher Beweis {#wrong-proof}
+
+Was passiert, wenn wir die richtigen Informationen liefern, aber nur die falschen Beweisdaten haben? Ersetzen Sie nun Zeile 91 durch:
+
+```ts
+proof.proof = {
+ a: ["0x" + "1".padStart(64, "0"), "0x" + "2".padStart(64, "0")],
+ b: [
+ ["0x" + "1".padStart(64, "0"), "0x" + "2".padStart(64, "0")],
+ ["0x" + "1".padStart(64, "0"), "0x" + "2".padStart(64, "0")],
+ ],
+ c: ["0x" + "1".padStart(64, "0"), "0x" + "2".padStart(64, "0")],
+}
+```
+
+Es schlägt immer noch fehl, aber jetzt schlägt es ohne Grund fehl, weil es während des Verifizierungsaufrufs passiert.
+
+### Wie kann ein Benutzer den Zero-Trust-Code überprüfen? {#user-verify-zero-trust}
+
+Smart Contracts sind relativ einfach zu überprüfen. Typischerweise veröffentlicht der Entwickler den Quellcode in einem Block-Explorer, und der Block-Explorer verifiziert, dass der Quellcode zum Code in der [Vertragsbereitstellungstransaktion](/developers/docs/smart-contracts/deploying/) kompiliert. Im Falle von MUD-`System`en ist dies [etwas komplizierter](https://mud.dev/cli/verify), aber nicht viel.
+
+Mit Zero-Knowledge ist das schwieriger. Der Verifizierer enthält einige Konstanten und führt einige Berechnungen mit ihnen durch. Dies sagt Ihnen nicht, was bewiesen wird.
+
+```solidity
+ function verifyingKey() pure internal returns (VerifyingKey memory vk) {
+ vk.alpha = Pairing.G1Point(uint256(0x0f43f4fe7b5c2326fed4ac6ed2f4003ab9ab4ea6f667c2bdd77afb068617ee16), uint256(0x25a77832283f9726935219b5f4678842cda465631e72dbb24708a97ba5d0ce6f));
+ vk.beta = Pairing.G2Point([uint256(0x2cebd0fbd21aca01910581537b21ae4fed46bc0e524c055059aa164ba0a6b62b), uint256(0x18fd4a7bc386cf03a95af7163d5359165acc4e7961cb46519e6d9ee4a1e2b7e9)], [uint256(0x11449dee0199ef6d8eebfe43b548e875c69e7ce37705ee9a00c81fe52f11a009), uint256(0x066d0c83b32800d3f335bb9e8ed5e2924cf00e77e6ec28178592eac9898e1a00)]);
+```
+
+Die Lösung besteht, zumindest bis Block-Explorer dazu übergehen, Zokrates-Verifizierung zu ihren Benutzeroberflächen hinzuzufügen, darin, dass die Anwendungsentwickler die Zokrates-Programme zur Verfügung stellen und dass zumindest einige Benutzer sie selbst mit dem entsprechenden Verifizierungsschlüssel kompilieren.
+
+Dazu gehen Sie wie folgt vor:
+
+1. [Installieren Sie Zokrates](https://zokrates.github.io/gettingstarted.html).
+
+2. Erstellen Sie eine Datei `dig.zok` mit dem Zokrates-Programm. Der nachstehende Code geht davon aus, dass Sie die ursprüngliche Kartengröße von 10x5 beibehalten haben.
+
+ ```zokrates
+ import "utils/pack/bool/pack128.zok" as pack128;
+ import "hashes/poseidon/poseidon.zok" as poseidon;
+
+ def hashMap(bool[12][7] map) -> field {
+ bool[512] mut map1d = [false; 512];
+ u32 mut counter = 0;
+
+ for u32 x in 0..12 {
+ for u32 y in 0..7 {
+ map1d[counter] = map[x][y];
+ counter = counter+1;
+ }
+ }
+
+ field[4] hashMe = [
+ pack128(map1d[0..128]),
+ pack128(map1d[128..256]),
+ pack128(map1d[256..384]),
+ pack128(map1d[384..512])
+ ];
+
+ return poseidon(hashMe);
+ }
+
+
+ // Die Anzahl der Minen am Ort (x,y)
+ def map2mineCount(bool[12][7] map, u32 x, u32 y) -> u8 {
+ return if map[x+1][y+1] { 1 } else { 0 };
+ }
+
+ def main(private bool[12][7] map, u32 x, u32 y) -> (field, u8) {
+ return (hashMap(map) ,
+ if map2mineCount(map, x, y) > 0 { 0xFF } else {
+ map2mineCount(map, x-1, y-1) + map2mineCount(map, x, y-1) + map2mineCount(map, x+1, y-1) +
+ map2mineCount(map, x-1, y) + map2mineCount(map, x+1, y) +
+ map2mineCount(map, x-1, y+1) + map2mineCount(map, x, y+1) + map2mineCount(map, x+1, y+1)
+ }
+ );
+ }
+ ```
+
+3. Kompilieren Sie den Zokrates-Code und erstellen Sie den Verifizierungsschlüssel. Der Verifizierungsschlüssel muss mit der gleichen Entropie erstellt werden, die im ursprünglichen Server verwendet wurde, [in diesem Fall ein leerer String](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L67).
+
+ ```sh copy
+ zokrates compile --input dig.zok
+ zokrates setup -e ""
+ ```
+
+4. Erstellen Sie den Solidity-Verifizierer selbst und überprüfen Sie, ob er funktionell mit dem auf der Blockchain identisch ist (der Server fügt einen Kommentar hinzu, aber das ist nicht wichtig).
+
+ ```sh copy
+ zokrates export-verifier
+ diff verifier.sol ~/20240901-secret-state/packages/contracts/src/verifier.sol
+ ```
+
+## Designentscheidungen {#design}
+
+In jeder ausreichend komplexen Anwendung gibt es konkurrierende Designziele, die Kompromisse erfordern. Schauen wir uns einige der Kompromisse an und warum die aktuelle Lösung anderen Optionen vorzuziehen ist.
+
+### Warum Zero-Knowledge {#why-zero-knowledge}
+
+Für Minesweeper braucht man nicht wirklich Zero-Knowledge. Der Server kann die Karte immer behalten und sie dann einfach aufdecken, wenn das Spiel vorbei ist. Dann kann der Smart Contract am Ende des Spiels den Karten-Hash berechnen, überprüfen, ob er übereinstimmt, und wenn nicht, den Server bestrafen oder das Spiel vollständig ignorieren.
+
+Ich habe diese einfachere Lösung nicht verwendet, da sie nur für kurze Spiele mit einem genau definierten Endzustand funktioniert. Wenn ein Spiel potenziell unendlich ist (wie im Fall von [autonomen Welten](https://0xparc.org/blog/autonomous-worlds)), benötigen Sie eine Lösung, die den Zustand beweist, _ohne_ ihn preiszugeben.
+
+Als Tutorial benötigte dieser Artikel ein kurzes, leicht verständliches Spiel, aber diese Technik ist am nützlichsten für längere Spiele.
+
+### Warum Zokrates? {#why-zokrates}
+
+[Zokrates](https://zokrates.github.io/) ist nicht die einzige verfügbare Zero-Knowledge-Bibliothek, aber sie ähnelt einer normalen, [imperativen](https://en.wikipedia.org/wiki/Imperative_programming) Programmiersprache und unterstützt boolesche Variablen.
+
+Für Ihre Anwendung, mit unterschiedlichen Anforderungen, bevorzugen Sie möglicherweise die Verwendung von [Circum](https://docs.circom.io/getting-started/installation/) oder [Cairo](https://www.cairo-lang.org/tutorials/getting-started-with-cairo/).
+
+### Wann Zokrates kompilieren {#when-compile-zokrates}
+
+In diesem Programm kompilieren wir die Zokrates-Programme [jedes Mal, wenn der Server startet](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L60-L61). Das ist eindeutig eine Verschwendung von Ressourcen, aber dies ist ein Tutorial, das auf Einfachheit optimiert ist.
+
+Wenn ich eine produktionsreife Anwendung schreiben würde, würde ich prüfen, ob ich eine Datei mit den kompilierten Zokrates-Programmen für diese Minenfeldgröße habe, und wenn ja, diese verwenden. Dasselbe gilt für die Bereitstellung eines Verifizierervertrags onchain.
+
+### Erstellen der Verifizierer- und Prüferschlüssel {#key-creation}
+
+Die [Schlüsselerstellung](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L63-L69) ist eine weitere reine Berechnung, die für eine gegebene Minenfeldgröße nicht mehr als einmal durchgeführt werden muss. Auch hier wird es aus Gründen der Einfachheit nur einmal gemacht.
+
+Zusätzlich könnten wir eine [Setup-Zeremonie](https://zokrates.github.io/toolbox/trusted_setup.html#initializing-a-phase-2-ceremony) verwenden. Der Vorteil einer Setup-Zeremonie besteht darin, dass man entweder die Entropie oder ein Zwischenergebnis von jedem Teilnehmer benötigt, um beim Zero-Knowledge-Beweis zu betrügen. Wenn mindestens ein Teilnehmer der Zeremonie ehrlich ist und diese Informationen löscht, sind die Zero-Knowledge-Beweise vor bestimmten Angriffen sicher. Es gibt jedoch _keinen Mechanismus_, um zu überprüfen, ob Informationen von überall gelöscht wurden. Wenn Zero-Knowledge-Beweise von entscheidender Bedeutung sind, sollten Sie an der Setup-Zeremonie teilnehmen.
+
+Hier verlassen wir uns auf [perpetual powers of tau](https://github.com/privacy-scaling-explorations/perpetualpowersoftau), an denen Dutzende von Teilnehmern beteiligt waren. Es ist wahrscheinlich sicher genug und viel einfacher. Wir fügen auch keine Entropie während der Schlüsselerstellung hinzu, was es den Benutzern erleichtert, die [Zero-Knowledge-Konfiguration zu überprüfen](#user-verify-zero-trust).
+
+### Wo verifizieren {#where-verification}
+
+Wir können die Zero-Knowledge-Beweise entweder onchain (was Gas kostet) oder im Client (mithilfe von [`verify`](https://zokrates.github.io/toolbox/zokrates_js.html#verifyverificationkey-proof)) verifizieren. Ich habe die erste gewählt, da Sie damit [den Verifizierer einmal überprüfen](#user-verify-zero-trust) und dann darauf vertrauen können, dass er sich nicht ändert, solange die Vertragsadresse dafür gleich bleibt. Wenn die Verifizierung auf dem Client durchgeführt würde, müssten Sie den Code jedes Mal überprüfen, wenn Sie den Client herunterladen.
+
+Auch wenn dieses Spiel Einzelspieler ist, sind viele Blockchain-Spiele Mehrspieler. Onchain-Verifizierung bedeutet, dass Sie den Zero-Knowledge-Beweis nur einmal verifizieren. Wenn man es im Client macht, müsste jeder Client unabhängig verifizieren.
+
+### Die Karte in TypeScript oder Zokrates abflachen? {#where-flatten}
+
+Im Allgemeinen ist es besser, die Verarbeitung in TypeScript durchzuführen, wenn sie entweder in TypeScript oder Zokrates erfolgen kann, da TypeScript viel schneller ist und keine Zero-Knowledge-Beweise erfordert. Dies ist zum Beispiel der Grund, warum wir Zokrates nicht den Hash zur Verfügung stellen und ihn überprüfen lassen, ob er korrekt ist. Das Hashing muss innerhalb von Zokrates erfolgen, aber der Abgleich zwischen dem zurückgegebenen Hash und dem Hash onchain kann außerhalb davon stattfinden.
+
+Allerdings [flachen wir die Karte immer noch in Zokrates ab](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L15-L20), obwohl wir es auch in TypeScript hätten tun können. Der Grund ist, dass die anderen Optionen meiner Meinung nach schlechter sind.
+
+- Stellen Sie dem Zokrates-Code ein eindimensionales Array von Booleschen Werten zur Verfügung und verwenden Sie einen Ausdruck wie `x*(height+2)
+ +y`, um die zweidimensionale Karte zu erhalten. Dies würde [den Code](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L44-L47) etwas komplizierter machen, also habe ich entschieden, dass der Leistungsgewinn für ein Tutorial nicht wert ist.
+
+- Senden Sie Zokrates sowohl das eindimensionale als auch das zweidimensionale Array. Diese Lösung bringt uns jedoch nichts. Der Zokrates-Code müsste überprüfen, ob das bereitgestellte eindimensionale Array wirklich die korrekte Darstellung des zweidimensionalen Arrays ist. Es gäbe also keinen Leistungsgewinn.
+
+- Flachen Sie das zweidimensionale Array in Zokrates ab. Dies ist die einfachste Option, also habe ich sie gewählt.
+
+### Wo Karten speichern {#where-store-maps}
+
+In dieser Anwendung ist [`gamesInProgress`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L20) einfach eine Variable im Speicher. Das bedeutet, dass, wenn Ihr Server ausfällt und neu gestartet werden muss, alle gespeicherten Informationen verloren gehen. Spieler können nicht nur ihr Spiel nicht fortsetzen, sie können nicht einmal ein neues Spiel starten, weil die Onchain-Komponente denkt, dass sie noch ein Spiel im Gange haben.
+
+Dies ist eindeutig ein schlechtes Design für ein Produktionssystem, in dem Sie diese Informationen in einer Datenbank speichern würden. Der einzige Grund, warum ich hier eine Variable verwendet habe, ist, dass dies ein Tutorial ist und Einfachheit die Hauptüberlegung ist.
+
+## Fazit: Unter welchen Bedingungen ist dies die geeignete Technik? {#conclusion}
+
+So, jetzt wissen Sie, wie man ein Spiel mit einem Server schreibt, der geheime Zustände speichert, die nicht onchain gehören. Aber in welchen Fällen sollten Sie es tun? Es gibt zwei Hauptüberlegungen.
+
+- _Langlaufendes Spiel_: [Wie oben erwähnt](#why-zero-knowledge), können Sie in einem kurzen Spiel den Zustand einfach veröffentlichen, sobald das Spiel vorbei ist, und dann alles verifizieren lassen. Aber das ist keine Option, wenn das Spiel eine lange oder unbestimmte Zeit dauert und der Zustand geheim bleiben muss.
+
+- _Etwas Zentralisierung akzeptabel_: Zero-Knowledge-Beweise können die Integrität überprüfen, dass eine Entität die Ergebnisse nicht fälscht. Was sie nicht tun können, ist sicherzustellen, dass die Entität weiterhin verfügbar ist und auf Nachrichten antwortet. In Situationen, in denen die Verfügbarkeit auch dezentralisiert sein muss, sind Zero-Knowledge-Beweise keine ausreichende Lösung, und Sie benötigen eine [Mehrparteienberechnung](https://en.wikipedia.org/wiki/Secure_multi-party_computation).
+
+[Hier finden Sie mehr von meiner Arbeit](https://cryptodocguy.pro/).
+
+### Anerkennungen {#acknowledgements}
+
+- Alvaro Alonso las einen Entwurf dieses Artikels und klärte einige meiner Missverständnisse über Zokrates auf.
+
+Alle verbleibenden Fehler liegen in meiner Verantwortung.
diff --git a/public/content/translations/de/developers/tutorials/secure-development-workflow/index.md b/public/content/translations/de/developers/tutorials/secure-development-workflow/index.md
new file mode 100644
index 00000000000..8053e043a96
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/secure-development-workflow/index.md
@@ -0,0 +1,52 @@
+---
+title: Smart-Contract-Sicherheitscheckliste
+description: Ein empfohlener Workflow zum Schreiben sicherer Smart Contracts
+author: "Spuren von bits"
+tags: [ "Smart Contracts", "Sicherheit", "Solidity" ]
+skill: intermediate
+lang: de
+published: 07.09.2020
+source: Aufbau sicherer Verträge
+sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/workflow.md
+---
+
+## Smart-Contract-Entwicklungscheckliste {#smart-contract-development-checklist}
+
+Nachfolgend finden Sie einen allgemeinen Prozess, dessen Befolgung wir beim Schreiben Ihrer Smart Contracts empfehlen.
+
+Auf bekannte Sicherheitsprobleme prüfen:
+
+- Überprüfen Sie Ihre Verträge mit [Slither](https://github.com/crytic/slither). Es verfügt über mehr als 40 integrierte Detektoren für häufige Schwachstellen. Führen Sie es bei jedem Check-in mit neuem Code aus und stellen Sie sicher, dass Sie einen fehlerfreien Bericht erhalten (oder verwenden Sie den Triage-Modus, um bestimmte Probleme auszublenden).
+- Überprüfen Sie Ihre Verträge mit [Crytic](https://crytic.io/). Es prüft auf 50 Probleme, die von Slither nicht geprüft werden. Crytic kann Ihrem Team auch dabei helfen, den Überblick zu behalten, indem es Sicherheitsprobleme in Pull-Requests auf GitHub leicht aufdeckt.
+
+Berücksichtigen Sie die besonderen Merkmale Ihres Vertrags:
+
+- Sind Ihre Verträge upgradefähig? Überprüfen Sie Ihren Upgradefähigkeits-Code auf Fehler mit [`slither-check-upgradeability`](https://github.com/crytic/slither/wiki/Upgradeability-Checks) oder [Crytic](https://blog.trailofbits.com/2020/06/12/upgradeable-contracts-made-safer-with-crytic/). Wir haben 17 Möglichkeiten dokumentiert, wie Upgrades fehlschlagen können.
+- Erheben Ihre Verträge den Anspruch, ERC-konform zu sein? Überprüfen Sie sie mit [`slither-check-erc`](https://github.com/crytic/slither/wiki/ERC-Conformance). Dieses Tool erkennt sofort Abweichungen von sechs gängigen Spezifikationen.
+- Integrieren Sie Token von Drittanbietern? Lesen Sie unsere [Checkliste für die Token-Integration](/developers/tutorials/token-integration-checklist/), bevor Sie sich auf externe Verträge verlassen.
+
+Überprüfen Sie die kritischen Sicherheitsmerkmale Ihres Codes visuell:
+
+- Überprüfen Sie den [inheritance-graph](https://github.com/trailofbits/slither/wiki/Printer-documentation#inheritance-graph)-Printer von Slither. Vermeiden Sie unbeabsichtigtes Shadowing und Probleme mit der C3-Linearisierung.
+- Überprüfen Sie den [function-summary](https://github.com/trailofbits/slither/wiki/Printer-documentation#function-summary)-Printer von Slither. Er meldet die Sichtbarkeit von Funktionen und die Zugriffskontrollen.
+- Überprüfen Sie den [vars-and-auth](https://github.com/trailofbits/slither/wiki/Printer-documentation#variables-written-and-authorization)-Printer von Slither. Er meldet die Zugriffskontrollen für Zustandsvariablen.
+
+Dokumentieren Sie kritische Sicherheitseigenschaften und verwenden Sie automatisierte Testgeneratoren, um sie zu bewerten:
+
+- Lernen Sie, [wie Sie Sicherheitseigenschaften für Ihren Code dokumentieren](/developers/tutorials/guide-to-smart-contract-security-tools/). Anfangs ist es schwierig, aber es ist die wichtigste Tätigkeit, um ein gutes Ergebnis zu erzielen. Es ist auch eine Voraussetzung für die Anwendung der fortgeschrittenen Techniken in diesem Tutorial.
+- Definieren Sie Sicherheitseigenschaften in Solidity, zur Verwendung mit [Echidna](https://github.com/crytic/echidna) und [Manticore](https://manticore.readthedocs.io/en/latest/verifier.html). Konzentrieren Sie sich auf Ihre Statusmaschine, Zugriffskontrollen, arithmetische Operationen, externe Interaktionen und die Einhaltung von Standards.
+- Definieren Sie Sicherheitseigenschaften mit der [Python-API von Slither](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/). Konzentrieren Sie sich auf Vererbung, Variablenabhängigkeiten, Zugriffskontrollen und andere strukturelle Probleme.
+- Führen Sie Ihre Eigenschaftstests bei jedem Commit mit [Crytic](https://crytic.io) aus. Crytic kann Tests von Sicherheitseigenschaften verarbeiten und auswerten, sodass jeder in Ihrem Team auf GitHub leicht sehen kann, dass sie erfolgreich sind. Fehlgeschlagene Tests können Commits blockieren.
+
+Achten Sie schließlich auf Probleme, die automatisierte Werkzeuge nicht leicht finden können:
+
+- Mangelnde Privatsphäre: Alle anderen können Ihre Transaktionen sehen, während sie sich im Pool in der Warteschlange befinden.
+- Front-Running von Transaktionen
+- Kryptografische Operationen
+- Riskante Interaktionen mit externen DeFi-Komponenten
+
+## Bitten Sie um Hilfe {#ask-for-help}
+
+Die [Ethereum-Sprechstunden](https://calendly.com/dan-trailofbits/office-hours) finden jeden Dienstagnachmittag statt. Diese einstündigen Einzelsitzungen sind eine Gelegenheit, uns alle Ihre Fragen zur Sicherheit zu stellen, Probleme bei der Verwendung unserer Werkzeuge zu beheben und Feedback von Experten zu Ihrem aktuellen Ansatz zu erhalten. Wir helfen Ihnen, diesen Leitfaden durchzuarbeiten.
+
+Treten Sie unserem Slack bei: [Empire Hacking](https://join.slack.com/t/empirehacking/shared_invite/zt-h97bbrj8-1jwuiU33nnzg67JcvIciUw). Wir sind immer in den Kanälen #crytic und #ethereum erreichbar, wenn Sie Fragen haben.
diff --git a/public/content/translations/de/developers/tutorials/send-token-ethersjs/index.md b/public/content/translations/de/developers/tutorials/send-token-ethersjs/index.md
new file mode 100644
index 00000000000..60bfab22670
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/send-token-ethersjs/index.md
@@ -0,0 +1,210 @@
+---
+title: Senden von Token mit ethers.js
+description: Einsteigerfreundliche Anleitung zum Senden von Token mit ethers.js.
+author: Kim YongJun
+tags: [ "ETHERS.JS", "ERC-20", "TOKENS" ]
+skill: beginner
+lang: de
+published: 2021-04-06
+---
+
+## Token senden mit ethers.js (5.0) {#send-token}
+
+### In diesem Tutorial erfahren Sie, wie Sie {#you-learn-about}
+
+- Ethers.js importieren
+- Token transferieren
+- Gas-Preis entsprechend der Netzwerkauslastung festlegen
+
+### Erste Schritte {#to-get-started}
+
+Zu Beginn müssen wir zunächst die ethers.js-Bibliothek in unser Javascript importieren
+Binden Sie ethers.js (5.0) ein
+
+### Installation {#install-ethersjs}
+
+```shell
+/home/ricmoo> npm install --save ethers
+```
+
+ES6 im Browser
+
+```html
+
+```
+
+ES3(UMD) im Browser
+
+```html
+
+```
+
+### Parameter {#param}
+
+1. **`contract_address`**: Token-Vertragsadresse (die Vertragsadresse wird benötigt, wenn der Token, den Sie übertragen möchten, nicht Ether ist)
+2. **`send_token_amount`**: Der Betrag, den Sie an den Empfänger senden möchten
+3. **`to_address`**: Die Adresse des Empfängers
+4. **`send_account`**: Die Adresse des Absenders
+5. **`private_key`**: Privater Schlüssel des Absenders, um die Transaktion zu signieren und die Token tatsächlich zu übertragen
+
+## Hinweis {#notice}
+
+`signTransaction(tx)` wird entfernt, da `sendTransaction()` dies intern erledigt.
+
+## Sendeablauf {#procedure}
+
+### 1. Mit dem Netzwerk (Testnet) verbinden {#connect-to-network}
+
+#### Provider festlegen (Infura) {#set-provider}
+
+Mit dem Ropsten-Testnet verbinden
+
+```javascript
+window.ethersProvider = new ethers.providers.InfuraProvider("ropsten")
+```
+
+### 2. Wallet erstellen {#create-wallet}
+
+```javascript
+let wallet = new ethers.Wallet(private_key)
+```
+
+### 3. Wallet mit dem Netzwerk verbinden {#connect-wallet-to-net}
+
+```javascript
+let walletSigner = wallet.connect(window.ethersProvider)
+```
+
+### 4. Aktuellen Gas-Preis abrufen {#get-gas}
+
+```javascript
+window.ethersProvider.getGasPrice() // gasPrice
+```
+
+### 5. Transaktion definieren {#define-transaction}
+
+Die unten definierten Variablen sind von `send_token()` abhängig
+
+### Transaktionsparameter {#transaction-params}
+
+1. **`send_account`**: Adresse des Token-Absenders
+2. **`to_address`**: Adresse des Token-Empfängers
+3. **`send_token_amount`**: die Anzahl der zu sendenden Token
+4. **`gas_limit`**: Gaslimit
+5. **`gas_price`**: Gas-Preis
+
+[Siehe unten zur Verwendung](#how-to-use)
+
+```javascript
+const tx = {
+ from: send_account,
+ to: to_address,
+ value: ethers.utils.parseEther(send_token_amount),
+ nonce: window.ethersProvider.getTransactionCount(send_account, "latest"),
+ gasLimit: ethers.utils.hexlify(gas_limit), // 100000
+ gasPrice: gas_price,
+}
+```
+
+### 6. Übertragung {#transfer}
+
+```javascript
+walletSigner.sendTransaction(tx).then((transaction) => {
+ console.dir(transaction)
+ alert("Senden abgeschlossen!")
+})
+```
+
+## Verwendung {#how-to-use}
+
+```javascript
+let private_key =
+ "41559d28e936dc92104ff30691519693fc753ffbee6251a611b9aa1878f12a4d"
+let send_token_amount = "1"
+let to_address = "0x4c10D2734Fb76D3236E522509181CC3Ba8DE0e80"
+let send_address = "0xda27a282B5B6c5229699891CfA6b900A716539E6"
+let gas_limit = "0x100000"
+let wallet = new ethers.Wallet(private_key)
+let walletSigner = wallet.connect(window.ethersProvider)
+let contract_address = ""
+window.ethersProvider = new ethers.providers.InfuraProvider("ropsten")
+
+send_token(
+ contract_address,
+ send_token_amount,
+ to_address,
+ send_address,
+ private_key
+)
+```
+
+### Erfolg! {#success}
+
+
+
+## send_token() {#send-token-method}
+
+```javascript
+function send_token(
+ contract_address,
+ send_token_amount,
+ to_address,
+ send_account,
+ private_key
+) {
+ let wallet = new ethers.Wallet(private_key)
+ let walletSigner = wallet.connect(window.ethersProvider)
+
+ window.ethersProvider.getGasPrice().then((currentGasPrice) => {
+ let gas_price = ethers.utils.hexlify(parseInt(currentGasPrice))
+ console.log(`gas_price: ${gas_price}`)
+
+ if (contract_address) {
+ // allgemeiner Token-Versand
+ let contract = new ethers.Contract(
+ contract_address,
+ send_abi,
+ walletSigner
+ )
+
+ // Wie viele Token?
+ let numberOfTokens = ethers.utils.parseUnits(send_token_amount, 18)
+ console.log(`numberOfTokens: ${numberOfTokens}`)
+
+ // Token senden
+ contract.transfer(to_address, numberOfTokens).then((transferResult) => {
+ console.dir(transferResult)
+ alert("Token gesendet")
+ })
+ } // Ether senden
+ else {
+ const tx = {
+ from: send_account,
+ to: to_address,
+ value: ethers.utils.parseEther(send_token_amount),
+ nonce: window.ethersProvider.getTransactionCount(
+ send_account,
+ "latest"
+ ),
+ gasLimit: ethers.utils.hexlify(gas_limit), // 100000
+ gasPrice: gas_price,
+ }
+ console.dir(tx)
+ try {
+ walletSigner.sendTransaction(tx).then((transaction) => {
+ console.dir(transaction)
+ alert("Senden abgeschlossen!")
+ })
+ } catch (error) {
+ alert("Senden fehlgeschlagen!!")
+ }
+ }
+ })
+}
+```
diff --git a/public/content/translations/de/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md b/public/content/translations/de/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md
new file mode 100644
index 00000000000..79f858b6f76
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md
@@ -0,0 +1,208 @@
+---
+title: Versenden von Transaktionen mit Web3
+description: "Dies ist eine anfängerfreundliche Anleitung zum Versenden von Ethereum-Transaktionen mit Web3. Es gibt drei Hauptschritte, um eine Transaktion an die Ethereum-Blockchain zu senden: Erstellen, Signieren und Übertragen. Wir werden alle drei durchgehen."
+author: "Elan Halpern"
+tags: [ "Transaktionen", "web3.js", "Alchemy" ]
+skill: beginner
+lang: de
+published: 2020-11-04
+source: Alchemie Dokumente
+sourceUrl: https://www.alchemy.com/docs/how-to-send-transactions-on-ethereum
+---
+
+Dies ist eine anfängerfreundliche Anleitung zum Versenden von Ethereum-Transaktionen mit Web3. Es gibt drei Hauptschritte, um eine Transaktion an die Ethereum-Blockchain zu senden: Erstellen, Signieren und Übertragen. Wir gehen auf alle drei Punkte ein und beantworten hoffentlich alle Fragen, die Sie haben! In diesem Tutorial verwenden wir [Alchemy](https://www.alchemy.com/), um unsere Transaktionen an die Ethereum-Chain zu senden. Sie können [hier ein kostenloses Alchemy-Konto erstellen](https://auth.alchemyapi.io/signup).
+
+**HINWEIS:** Diese Anleitung ist für das Signieren Ihrer Transaktionen auf dem _Backend_ Ihrer App. Wenn Sie das Signieren Ihrer Transaktionen im Frontend integrieren möchten, sehen Sie sich die Integration von [Web3 mit einem Browser-Anbieter](https://docs.alchemy.com/reference/api-overview#with-a-browser-provider) an.
+
+## Die Grundlagen {#the-basics}
+
+Wie die meisten Blockchain-Entwickler, wenn sie anfangen, haben Sie vielleicht recherchiert, wie man eine Transaktion sendet (etwas, das ziemlich einfach sein sollte), und sind auf eine Fülle von Anleitungen gestoßen, von denen jede etwas anderes besagt und Sie etwas überfordert und verwirrt zurücklässt. Wenn Sie im selben Boot sitzen, keine Sorge – wir alle waren irgendwann einmal an diesem Punkt! Bevor wir also beginnen, sollten wir ein paar Dinge klarstellen:
+
+### 1. Alchemy speichert Ihre privaten Schlüssel nicht {#alchemy-does-not-store-your-private-keys}
+
+- Das bedeutet, dass Alchemy keine Transaktionen in Ihrem Namen signieren und senden kann. Dies geschieht aus Sicherheitsgründen. Alchemy wird Sie niemals darum bitten, Ihren privaten Schlüssel mitzuteilen, und Sie sollten Ihren privaten Schlüssel niemals mit einem gehosteten Node (oder überhaupt jemandem) teilen.
+- Sie können mit der Core-API von Alchemy aus der Blockchain lesen, aber um darauf zu schreiben, müssen Sie etwas anderes verwenden, um Ihre Transaktionen zu signieren, bevor Sie sie über Alchemy senden (dies gilt für jeden anderen [Node-Service](/developers/docs/nodes-and-clients/nodes-as-a-service/)).
+
+### 2. Was ist ein „Signer“? {#what-is-a-signer}
+
+- Signer signieren Transaktionen für Sie mit Ihrem privaten Schlüssel. In diesem Tutorial verwenden wir [Alchemy Web3](https://docs.alchemyapi.io/alchemy/documentation/alchemy-web3), um unsere Transaktion zu signieren, aber Sie könnten auch jede andere Web3-Bibliothek verwenden.
+- Ein gutes Beispiel für einen Signer im Frontend wäre [MetaMask](https://metamask.io/), das Transaktionen in Ihrem Namen signiert und sendet.
+
+### 3. Warum muss ich meine Transaktionen signieren? {#why-do-i-need-to-sign-my-transactions}
+
+- Jeder Benutzer, der eine Transaktion über das Ethereum-Netzwerk senden möchte, muss die Transaktion (mit seinem privaten Schlüssel) signieren, um zu validieren, dass der Ursprung der Transaktion auch der ist, den er vorgibt zu sein.
+- Es ist extrem wichtig, diesen privaten Schlüssel zu schützen, da der Zugriff darauf die volle Kontrolle über Ihr Ethereum-Konto gewährt und es Ihnen (oder jedem mit Zugriff) ermöglicht, Transaktionen in Ihrem Namen durchzuführen.
+
+### 4. Wie schütze ich meinen privaten Schlüssel? {#how-do-i-protect-my-private-key}
+
+- Es gibt viele Möglichkeiten, Ihren privaten Schlüssel zu schützen und ihn zum Senden von Transaktionen zu verwenden. In diesem Tutorial werden wir eine `.env`-Datei verwenden. Sie können jedoch auch einen separaten Anbieter verwenden, der private Schlüssel speichert, eine Keystore-Datei nutzen oder andere Optionen wählen.
+
+### 5. Was ist der Unterschied zwischen `eth_sendTransaction` und `eth_sendRawTransaction`? {#difference-between-send-and-send-raw}
+
+`eth_sendTransaction` und `eth_sendRawTransaction` sind beides Ethereum-API-Funktionen, die eine Transaktion an das Ethereum-Netzwerk senden, sodass sie einem zukünftigen Block hinzugefügt wird. Sie unterscheiden sich in der Art und Weise, wie sie das Signieren der Transaktionen handhaben.
+
+- [`eth_sendTransaction`](https://docs.web3js.org/api/web3-eth/function/sendTransaction) wird für das Senden von _unsignierten_ Transaktionen verwendet. Das bedeutet, der Node, an den Sie senden, muss Ihren privaten Schlüssel verwalten, damit er die Transaktion signieren kann, bevor er sie an die Chain sendet. Da Alchemy die privaten Schlüssel der Benutzer nicht speichert, wird diese Methode nicht unterstützt.
+- [`eth_sendRawTransaction`](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc#eth_sendrawtransaction) wird verwendet, um bereits signierte Transaktionen zu senden. Das bedeutet, Sie müssen zuerst [`signTransaction(tx, private_key)`](https://docs.web3js.org/api/web3-eth-accounts/function/signTransaction) verwenden und dann das Ergebnis an `eth_sendRawTransaction` übergeben.
+
+Bei Verwendung von Web3 wird auf `eth_sendRawTransaction` durch den Aufruf der Funktion [web3.eth.sendSignedTransaction](https://docs.web3js.org/api/web3-eth/function/sendSignedTransaction) zugegriffen.
+
+Das werden wir in diesem Tutorial verwenden.
+
+### 6. Was ist die Web3-Bibliothek? {#what-is-the-web3-library}
+
+- Web3.js ist eine Wrapper-Bibliothek für die standardmäßigen JSON-RPC-Aufrufe, die in der Ethereum-Entwicklung sehr verbreitet ist.
+- Es gibt viele Web3-Bibliotheken für verschiedene Sprachen. In diesem Tutorial verwenden wir [Alchemy Web3](https://docs.alchemy.com/reference/api-overview), das in JavaScript geschrieben ist. Sie können sich [hier](https://docs.alchemyapi.io/guides/getting-started#other-web3-libraries) andere Optionen wie [ethers.js](https://docs.ethers.org/v5/) ansehen.
+
+Okay, nachdem wir nun einige dieser Fragen aus dem Weg geräumt haben, fahren wir mit dem Tutorial fort. Fragen können Sie jederzeit im Alchemy-[Discord](https://discord.gg/gWuC7zB) stellen!
+
+### 7. Wie sendet man sichere, gas-optimierte und private Transaktionen? {#how-to-send-secure-gas-optimized-and-private-transactions}
+
+- [Alchemy verfügt über eine Reihe von Transact-APIs](https://docs.alchemy.com/reference/transact-api-quickstart). Sie können diese verwenden, um verstärkte Transaktionen zu senden, Transaktionen vorab zu simulieren, private Transaktionen zu senden und gasoptimierte Transaktionen zu senden.
+- Sie können auch die [Notify API](https://docs.alchemy.com/docs/alchemy-notify) verwenden, um benachrichtigt zu werden, wenn Ihre Transaktion aus dem Mempool geholt und zur Chain hinzugefügt wird.
+
+**HINWEIS:** Diese Anleitung erfordert ein Alchemy-Konto, eine Ethereum-Adresse oder eine MetaMask-Wallet sowie installiertes NodeJs und npm. Falls nicht, folgen Sie diesen Schritten:
+
+1. [Erstellen Sie ein kostenloses Alchemy-Konto](https://auth.alchemyapi.io/signup)
+2. [MetaMask-Konto erstellen](https://metamask.io/) (oder eine Ethereum-Adresse erhalten)
+3. [Befolgen Sie diese Schritte, um NodeJs und NPM zu installieren](https://docs.alchemy.com/alchemy/guides/alchemy-for-macs)
+
+## Schritte zum Senden Ihrer Transaktion {#steps-to-sending-your-transaction}
+
+### 1. Erstellen Sie eine Alchemy-App auf dem Sepolia-Testnet {#create-an-alchemy-app-on-the-sepolia-testnet}
+
+Navigieren Sie zu Ihrem [Alchemy Dashboard](https://dashboard.alchemyapi.io/) und erstellen Sie eine neue App, indem Sie Sepolia (oder ein anderes Testnet) als Netzwerk auswählen.
+
+### 2. ETH vom Sepolia-Faucet anfordern {#request-eth-from-sepolia-faucet}
+
+Folgen Sie den Anweisungen auf dem [Alchemy Sepolia Faucet](https://www.sepoliafaucet.com/), um ETH zu erhalten. Stellen Sie sicher, dass Sie Ihre **Sepolia**-Ethereum-Adresse (von MetaMask) und nicht die eines anderen Netzwerks angeben. Nachdem Sie die Anweisungen befolgt haben, überprüfen Sie, ob Sie die ETH in Ihrer Wallet erhalten haben.
+
+### 3. Erstellen Sie ein neues Projektverzeichnis und wechseln Sie mit `cd` hinein {#create-a-new-project-direction}
+
+Erstellen Sie ein neues Projektverzeichnis in der Befehlszeile (Terminal für Macs) und navigieren Sie hinein:
+
+```
+mkdir sendtx-example
+cd sendtx-example
+```
+
+### 4. Alchemy Web3 (oder eine beliebige Web3-Bibliothek) installieren {#install-alchemy-web3}
+
+Führen Sie den folgenden Befehl in Ihrem Projektverzeichnis aus, um [Alchemy Web3](https://docs.alchemy.com/reference/api-overview) zu installieren:
+
+Hinweis: Wenn Sie die ethers.js-Bibliothek verwenden möchten, [folgen Sie den Anweisungen hier](https://docs.alchemy.com/docs/how-to-send-transactions-on-ethereum).
+
+```
+npm install @alch/alchemy-web3
+```
+
+### 5. dotenv installieren {#install-dotenv}
+
+Wir verwenden eine `.env`-Datei, um unseren API-Schlüssel und unseren privaten Schlüssel sicher zu speichern.
+
+```
+npm install dotenv --save
+```
+
+### 6. Die `.env`-Datei erstellen {#create-the-dotenv-file}
+
+Erstellen Sie eine `.env`-Datei in Ihrem Projektverzeichnis und fügen Sie Folgendes hinzu (ersetzen Sie „`your-api-url`“ und „`your-private-key`“)
+
+- Um Ihre Alchemy-API-URL zu finden, navigieren Sie zur Detailseite der App, die Sie gerade in Ihrem Dashboard erstellt haben, klicken Sie oben rechts auf „View Key“ und kopieren Sie die HTTP-URL.
+- Um Ihren privaten Schlüssel mit MetaMask zu finden, sehen Sie sich diese [Anleitung](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key) an.
+
+```
+API_URL = "your-api-url"
+PRIVATE_KEY = "your-private-key"
+```
+
+
+
+
+Führen Sie keinen Commit für .env aus! Bitte stellen Sie sicher, dass Sie Ihre .env-Datei niemals an Dritte weitergeben oder offenlegen, da Sie dadurch Ihre Geheimnisse preisgeben. Wenn Sie eine Versionskontrolle verwenden, fügen Sie Ihre .env-Datei einer gitignore-Datei hinzu.
+
+
+
+
+### 7. `sendTx.js`-Datei erstellen {#create-sendtx-js}
+
+Großartig, jetzt, da unsere sensiblen Daten in einer `.env`-Datei geschützt sind, können wir mit dem Programmieren beginnen. Für unser Beispiel zum Senden von Transaktionen senden wir ETH an den Sepolia-Faucet zurück.
+
+Erstellen Sie eine `sendTx.js`-Datei, in der wir unsere Beispieltransaktion konfigurieren und senden, und fügen Sie die folgenden Codezeilen hinzu:
+
+```
+async function main() {
+ require('dotenv').config();
+ const { API_URL, PRIVATE_KEY } = process.env;
+ const { createAlchemyWeb3 } = require("@alch/alchemy-web3");
+ const web3 = createAlchemyWeb3(API_URL);
+ const myAddress = '0x610Ae88399fc1687FA7530Aac28eC2539c7d6d63' //TODO: Ersetzen Sie diese Adresse durch Ihre eigene öffentliche Adresse
+
+ const nonce = await web3.eth.getTransactionCount(myAddress, 'latest'); // Nonce beginnt bei 0 zu zählen
+
+ const transaction = {
+ 'to': '0x31B98D14007bDEe637298086988A0bBd31184523', // Faucet-Adresse, um ETH zurückzugeben
+ 'value': 1000000000000000000, // 1 ETH
+ 'gas': 30000,
+ 'nonce': nonce,
+ // optionales Datenfeld zum Senden einer Nachricht oder Ausführen eines Smart Contracts
+ };
+
+ const signedTx = await web3.eth.accounts.signTransaction(transaction, PRIVATE_KEY);
+
+ web3.eth.sendSignedTransaction(signedTx.rawTransaction, function(error, hash) {
+ if (!error) {
+ console.log("🎉 Der Hash Ihrer Transaktion lautet: ", hash, "\n Sehen Sie sich Alchemys Mempool an, um den Status Ihrer Transaktion zu überprüfen!");
+ } else {
+ console.log("❗Beim Senden Ihrer Transaktion ist ein Fehler aufgetreten:", error)
+ }
+ });
+}
+
+main();
+```
+
+Ersetzen Sie die Adresse in **Zeile 6** unbedingt durch Ihre eigene öffentliche Adresse.
+
+Bevor wir diesen Code ausführen, lassen Sie uns über einige der Komponenten hier sprechen.
+
+- `nonce`: Die Nonce-Spezifikation wird verwendet, um die Anzahl der von Ihrer Adresse gesendeten Transaktionen zu verfolgen. Wir benötigen dies aus Sicherheitsgründen und um [Replay-Angriffe](https://docs.alchemyapi.io/resources/blockchain-glossary#account-nonce) zu verhindern. Um die Anzahl der von Ihrer Adresse gesendeten Transaktionen zu ermitteln, verwenden wir [getTransactionCount](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc#eth_gettransactioncount).
+- `transaction`: Das Transaktionsobjekt hat einige Aspekte, die wir spezifizieren müssen.
+ - `to`: Dies ist die Adresse, an die wir ETH senden möchten. In diesem Fall senden wir ETH an den [Sepolia Faucet](https://sepoliafaucet.com/) zurück, von dem wir sie ursprünglich angefordert haben.
+ - `value`: Dies ist der Betrag, den wir senden möchten, angegeben in Wei, wobei 10^18 Wei = 1 ETH.
+ - `gas`: Es gibt viele Möglichkeiten, die richtige Menge an Gas für Ihre Transaktion zu bestimmen. Alchemy hat sogar einen [Gaspreis-Webhook](https://docs.alchemyapi.io/guides/alchemy-notify#address-activity-1), der Sie benachrichtigt, wenn der Gaspreis unter einen bestimmten Schwellenwert fällt. Für Mainnet-Transaktionen ist es eine gute Praxis, einen Gas-Schätzer wie [ETH Gas Station](https://ethgasstation.info/) zu Rate zu ziehen, um die richtige Menge an Gas zu bestimmen. 21000 ist die Mindestmenge an Gas, die eine Operation auf Ethereum verbraucht. Um sicherzustellen, dass unsere Transaktion ausgeführt wird, geben wir hier 30000 an.
+ - `nonce`: siehe Nonce-Definition oben. Die Nonce-Zählung beginnt bei Null.
+ - [OPTIONAL] data: Wird zum Senden zusätzlicher Informationen mit Ihrer Übertragung oder zum Aufrufen eines Smart Contracts verwendet. Für Guthabenübertragungen nicht erforderlich, siehe Hinweis unten.
+- `signedTx`: Um unser Transaktionsobjekt zu signieren, verwenden wir die `signTransaction`-Methode mit unserem `PRIVATE_KEY`.
+- `sendSignedTransaction`: Sobald wir eine signierte Transaktion haben, können wir sie mit `sendSignedTransaction` versenden, damit sie in einen nachfolgenden Block aufgenommen wird.
+
+**Ein Hinweis zu Daten**
+Es gibt zwei Haupttypen von Transaktionen, die in Ethereum gesendet werden können.
+
+- Guthabenübertragung: Senden Sie ETH von einer Adresse zu einer anderen. Kein Datenfeld erforderlich. Wenn Sie jedoch zusätzliche Informationen mit Ihrer Transaktion senden möchten, können Sie diese Informationen in diesem Feld im HEX-Format angeben.
+ - Nehmen wir zum Beispiel an, wir wollten den Hash eines IPFS-Dokuments in die Ethereum-Chain schreiben, um ihm einen unveränderlichen Zeitstempel zu geben. Unser Datenfeld sollte dann so aussehen: data: `web3.utils.toHex('IPFS-Hash')`. Und jetzt kann jeder die Chain abfragen und sehen, wann dieses Dokument hinzugefügt wurde.
+- Smart-Contract-Transaktion: Führen Sie einen Smart-Contract-Code auf der Chain aus. In diesem Fall sollte das Datenfeld die Smart-Funktion, die Sie ausführen möchten, sowie alle Parameter enthalten.
+ - Ein praktisches Beispiel finden Sie in Schritt 8 in diesem [Hello-World-Tutorial](https://docs.alchemyapi.io/alchemy/tutorials/hello-world-smart-contract#step-8-create-the-transaction).
+
+### 8. Den Code mit `node sendTx.js` ausführen {#run-the-code-using-node-sendtx-js}
+
+Navigieren Sie zurück zu Ihrem Terminal oder Ihrer Befehlszeile und führen Sie Folgendes aus:
+
+```
+node sendTx.js
+```
+
+### 9. Sehen Sie Ihre Transaktion im Mempool {#see-your-transaction-in-the-mempool}
+
+Öffnen Sie die [Mempool-Seite](https://dashboard.alchemyapi.io/mempool) in Ihrem Alchemy-Dashboard und filtern Sie nach der von Ihnen erstellten App, um Ihre Transaktion zu finden. Hier können wir den Übergang unserer Transaktion vom Status „ausstehend“ zum Status „gemined“ (bei Erfolg) oder „verworfen“ (bei Misserfolg) beobachten. Stellen Sie sicher, dass die Einstellung auf „Alle“ (All) bleibt, damit Sie „geminte“ (mined), „ausstehende“ (pending) und „verworfene“ (dropped) Transaktionen erfassen. Sie können auch nach Ihrer Transaktion suchen, indem Sie nach Transaktionen suchen, die an die Adresse `0x31b98d14007bdee637298086988a0bbd31184523` gesendet wurden.
+
+Um die Details Ihrer Transaktion anzuzeigen, nachdem Sie sie gefunden haben, wählen Sie den Transaktions-Hash aus. Sie sollten dann zu einer Ansicht gelangen, die wie folgt aussieht:
+
+
+
+Von dort aus können Sie Ihre Transaktion auf Etherscan einsehen, indem Sie auf das rot eingekreiste Symbol klicken!
+
+**Juhuuu!** Sie haben gerade Ihre erste Ethereum-Transaktion mit Alchemy gesendet 🎉\*\*
+
+_Für Feedback und Vorschläge zu dieser Anleitung schreiben Sie bitte eine Nachricht an Elan auf Alchemys [Discord](https://discord.gg/A39JVCM)!_
+
+_Ursprünglich veröffentlicht unter [https://docs.alchemyapi.io/tutorials/sending-transactions-using-web3-and-alchemy](https://docs.alchemyapi.io/tutorials/sending-transactions-using-web3-and-alchemy)_
diff --git a/public/content/translations/de/developers/tutorials/server-components/index.md b/public/content/translations/de/developers/tutorials/server-components/index.md
new file mode 100644
index 00000000000..25859af76d9
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/server-components/index.md
@@ -0,0 +1,295 @@
+---
+title: "Server-Komponenten und Agenten für Web3-Apps"
+description: Nach dem Lesen dieses Tutorials können Sie TypeScript-Server schreiben, die auf Ereignisse auf einer Blockchain lauschen und entsprechend mit ihren eigenen Transaktionen reagieren. Dies ermöglicht es Ihnen, zentralisierte Anwendungen zu schreiben (da der Server ein Single Point of Failure ist), die jedoch mit Web3-Entitäten interagieren können. Die gleichen Techniken können auch verwendet werden, um einen Agenten zu schreiben, der auf On-Chain-Ereignisse ohne menschliches Eingreifen reagiert.
+
+author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+lang: de
+tags: [ "Agent", "Server", "Off-Chain" ]
+skill: beginner
+published: 2024-07-15
+---
+
+## Einführung {#introduction}
+
+In den meisten Fällen verwendet eine dezentralisierte App einen Server, um die Software zu verteilen, aber die eigentliche Interaktion findet zwischen dem Client (typischerweise einem Webbrowser) und der Blockchain statt.
+
+
+
+Es gibt jedoch einige Fälle, in denen eine Anwendung davon profitieren würde, eine unabhängig laufende Server-Komponente zu haben. Ein solcher Server wäre in der Lage, auf Ereignisse und auf Anfragen von anderen Quellen, wie z. B. einer API, zu reagieren, indem er Transaktionen ausstellt.
+
+
+
+Es gibt mehrere mögliche Aufgaben, die ein solcher Server erfüllen könnte.
+
+- Inhaber eines geheimen Zustands. Bei Spielen ist es oft nützlich, den Spielern nicht alle Informationen zur Verfügung zu stellen, die das Spiel kennt. Allerdings _gibt es keine Geheimnisse auf der Blockchain_, jede Information, die sich auf der Blockchain befindet, kann von jedem leicht herausgefunden werden. Wenn also ein Teil des Spielzustands geheim gehalten werden soll, muss er an anderer Stelle gespeichert werden (und die Auswirkungen dieses Zustands möglicherweise mit [Zero-Knowledge-Beweisen](/zero-knowledge-proofs) verifiziert werden).
+
+- Zentralisiertes Orakel. Wenn die Einsätze ausreichend niedrig sind, kann ein externer Server, der einige Informationen online liest und sie dann in die Chain postet, ausreichend sein, um als [Orakel](/developers/docs/oracles/) verwendet zu werden.
+
+- Agent. Auf der Blockchain passiert nichts ohne eine Transaktion, die es aktiviert. Ein Server kann im Namen eines Benutzers handeln, um Aktionen wie [Arbitrage](/developers/docs/mev/#mev-examples-dex-arbitrage) durchzuführen, wenn sich die Gelegenheit dazu bietet.
+
+## Beispielprogramm {#sample-program}
+
+Sie können einen Beispielserver [auf GitHub](https://github.com/qbzzt/20240715-server-component) sehen. Dieser Server lauscht auf Ereignisse, die von [diesem Vertrag](https://eth-holesky.blockscout.com/address/0xB8f6460Dc30c44401Be26B0d6eD250873d8a50A6?tab=contract_code) stammen, einer modifizierten Version des Greeters von Hardhat. Wenn die Begrüßung geändert wird, ändert er sie wieder zurück.
+
+So führen Sie es aus:
+
+1. Klonen Sie das Repository.
+
+ ```sh copy
+ git clone https://github.com/qbzzt/20240715-server-component.git
+ cd 20240715-server-component
+ ```
+
+2. Installieren Sie die erforderlichen Pakete. Wenn Sie es noch nicht haben, [installieren Sie zuerst Node](https://nodejs.org/en/download/package-manager).
+
+ ```sh copy
+ npm install
+ ```
+
+3. Bearbeiten Sie `.env`, um den privaten Schlüssel eines Kontos anzugeben, das ETH im Holesky-Testnet hat. Wenn Sie keine ETH auf Holesky haben, können Sie [diesen Faucet](https://holesky-faucet.pk910.de/) verwenden.
+
+ ```sh filename=".env" copy
+ PRIVATE_KEY=0x
+ ```
+
+4. Starten Sie den Server.
+
+ ```sh copy
+ npm start
+ ```
+
+5. Gehen Sie zu [einem Block-Explorer](https://eth-holesky.blockscout.com/address/0xB8f6460Dc30c44401Be26B0d6eD250873d8a50A6?tab=write_contract) und ändern Sie mit einer anderen Adresse als derjenigen, die den privaten Schlüssel hat, die Begrüßung. Sie werden sehen, dass die Begrüßung automatisch zurückgeändert wird.
+
+### Wie funktioniert das? {#how-it-works}
+
+Der einfachste Weg, um zu verstehen, wie man eine Server-Komponente schreibt, ist, das Beispiel Zeile für Zeile durchzugehen.
+
+#### `src/app.ts` {#src-app-ts}
+
+Der überwiegende Teil des Programms ist in [`src/app.ts`](https://github.com/qbzzt/20240715-server-component/blob/main/src/app.ts) enthalten.
+
+##### Erstellen der erforderlichen Objekte
+
+```typescript
+import {
+ createPublicClient,
+ createWalletClient,
+ getContract,
+ http,
+ Address,
+} from "viem"
+```
+
+Dies sind die [Viem](https://viem.sh/)-Entitäten, die wir benötigen, Funktionen und [der `Address`-Typ](https://viem.sh/docs/glossary/types#address). Dieser Server ist in [TypeScript](https://www.typescriptlang.org/) geschrieben, einer Erweiterung von JavaScript, die es [stark typisiert](https://en.wikipedia.org/wiki/Strong_and_weak_typing).
+
+```typescript
+import { privateKeyToAccount } from "viem/accounts"
+```
+
+[Diese Funktion](https://viem.sh/docs/accounts/privateKey) ermöglicht es uns, die Wallet-Informationen, einschließlich der Adresse, zu generieren, die einem privaten Schlüssel entsprechen.
+
+```typescript
+import { holesky } from "viem/chains"
+```
+
+Um eine Blockchain in Viem zu verwenden, müssen Sie ihre Definition importieren. In diesem Fall wollen wir uns mit der [Holesky](https://github.com/eth-clients/holesky)-Test-Blockchain verbinden.
+
+```typescript
+// So fügen wir die Definitionen in .env zu process.env hinzu.
+import * as dotenv from "dotenv"
+dotenv.config()
+```
+
+So lesen wir `.env` in die Umgebung ein. Wir brauchen es für den privaten Schlüssel (siehe später).
+
+```typescript
+const greeterAddress : Address = "0xB8f6460Dc30c44401Be26B0d6eD250873d8a50A6"
+const greeterABI = [
+ {
+ "inputs": [
+ {
+ "internalType": "string",
+ "name": "_greeting",
+ "type": "string"
+ }
+ ],
+ "stateMutability": "nonpayable",
+ "type": "constructor"
+ },
+ .
+ .
+ .
+ {
+ "inputs": [
+ {
+ "internalType": "string",
+ "name": "_greeting",
+ "type": "string"
+ }
+ ],
+ "name": "setGreeting",
+ "outputs": [],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ }
+] as const
+```
+
+Um einen Vertrag zu verwenden, benötigen wir seine Adresse und die [ABI](/glossary/#abi) dafür. Wir stellen hier beides zur Verfügung.
+
+In JavaScript (und damit auch in TypeScript) kann man einer Konstante keinen neuen Wert zuweisen, aber man _kann_ das Objekt, das darin gespeichert ist, ändern. Durch die Verwendung des Suffixes `as const` teilen wir TypeScript mit, dass die Liste selbst konstant ist und nicht geändert werden darf.
+
+```typescript
+const publicClient = createPublicClient({
+ chain: holesky,
+ transport: http(),
+})
+```
+
+Erstellen Sie einen [öffentlichen Client](https://viem.sh/docs/clients/public.html) von Viem. Öffentliche Clients haben keinen angehängten privaten Schlüssel und können daher keine Transaktionen senden. Sie können [`view`-Funktionen](https://www.tutorialspoint.com/solidity/solidity_view_functions.htm) aufrufen, Kontostände lesen usw.
+
+```typescript
+const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`)
+```
+
+Die Umgebungsvariablen sind in [`process.env`](https://www.totaltypescript.com/how-to-strongly-type-process-env) verfügbar. TypeScript ist jedoch stark typisiert. Eine Umgebungsvariable kann eine beliebige Zeichenkette oder leer sein, daher ist der Typ für eine Umgebungsvariable `string | undefined`. Ein Schlüssel ist in Viem jedoch als `0x${string}` (`0x` gefolgt von einer Zeichenkette) definiert. Hier teilen wir TypeScript mit, dass die Umgebungsvariable `PRIVATE_KEY` von diesem Typ sein wird. Wenn dies nicht der Fall ist, erhalten wir einen Laufzeitfehler.
+
+Die Funktion [`privateKeyToAccount`](https://viem.sh/docs/accounts/privateKey) verwendet dann diesen privaten Schlüssel, um ein vollständiges Kontoobjekt zu erstellen.
+
+```typescript
+const walletClient = createWalletClient({
+ account,
+ chain: holesky,
+ transport: http(),
+})
+```
+
+Als Nächstes verwenden wir das Kontoobjekt, um einen [Wallet-Client](https://viem.sh/docs/clients/wallet) zu erstellen. Dieser Client hat einen privaten Schlüssel und eine Adresse, sodass er zum Senden von Transaktionen verwendet werden kann.
+
+```typescript
+const greeter = getContract({
+ address: greeterAddress,
+ abi: greeterABI,
+ client: { public: publicClient, wallet: walletClient },
+})
+```
+
+Nachdem wir nun alle Voraussetzungen haben, können wir endlich eine [Vertragsinstanz](https://viem.sh/docs/contract/getContract) erstellen. Wir werden diese Vertragsinstanz verwenden, um mit dem On-Chain-Vertrag zu kommunizieren.
+
+##### Lesen von der Blockchain
+
+```typescript
+console.log(`Current greeting:`, await greeter.read.greet())
+```
+
+Die Vertragsfunktionen, die schreibgeschützt sind ([`view`](https://www.tutorialspoint.com/solidity/solidity_view_functions.htm) und [`pure`](https://www.tutorialspoint.com/solidity/solidity_pure_functions.htm)), sind unter `read` verfügbar. In diesem Fall verwenden wir es für den Zugriff auf die Funktion [`greet`](https://eth-holesky.blockscout.com/address/0xB8f6460Dc30c44401Be26B0d6eD250873d8a50A6?tab=read_contract#cfae3217), die die Begrüßung zurückgibt.
+
+JavaScript ist single-threaded. Wenn wir also einen lang andauernden Prozess starten, müssen wir [angeben, dass wir dies asynchron tun](https://eloquentjavascript.net/11_async.html#h-XvLsfAhtsE). Der Aufruf der Blockchain, selbst für einen schreibgeschützten Vorgang, erfordert einen Round-Trip zwischen dem Computer und einem Blockchain-Knoten. Das ist der Grund, warum wir hier angeben, dass der Code auf das Ergebnis `await` (warten) muss.
+
+Wenn Sie daran interessiert sind, wie das funktioniert, können Sie [hier darüber lesen](https://www.w3schools.com/js/js_promise.asp), aber in der Praxis müssen Sie nur wissen, dass Sie auf die Ergebnisse `await` (warten), wenn Sie eine Operation starten, die lange dauert, und dass jede Funktion, die dies tut, als `async` deklariert werden muss.
+
+##### Ausstellen von Transaktionen
+
+```typescript
+const setGreeting = async (greeting: string): Promise => {
+```
+
+Dies ist die Funktion, die Sie aufrufen, um eine Transaktion auszustellen, die die Begrüßung ändert. Da dies eine langwierige Operation ist, ist die Funktion als `async` deklariert. Aufgrund der internen Implementierung muss jede `async`-Funktion ein `Promise`-Objekt zurückgeben. In diesem Fall bedeutet `Promise`, dass wir nicht genau angeben, was in dem `Promise` zurückgegeben wird.
+
+```typescript
+const txHash = await greeter.write.setGreeting([greeting])
+```
+
+Das `write`-Feld der Vertragsinstanz hat alle Funktionen, die in den Blockchain-Zustand schreiben (diejenigen, die das Senden einer Transaktion erfordern), wie z. B. [`setGreeting`](https://eth-holesky.blockscout.com/address/0xB8f6460Dc30c44401Be26B0d6eD250873d8a50A6?tab=write_contract#a4136862). Die Parameter werden, falls vorhanden, als Liste bereitgestellt, und die Funktion gibt den Hash der Transaktion zurück.
+
+```typescript
+ console.log(`Arbeite an einer Korrektur, siehe https://eth-holesky.blockscout.com/tx/${txHash}`)
+
+ return txHash
+}
+```
+
+Melden Sie den Hash der Transaktion (als Teil einer URL zum Block-Explorer, um ihn anzuzeigen) und geben Sie ihn zurück.
+
+##### Reaktion auf Ereignisse
+
+```typescript
+greeter.watchEvent.SetGreeting({
+```
+
+[Die `watchEvent`-Funktion](https://viem.sh/docs/actions/public/watchEvent) lässt Sie festlegen, dass eine Funktion ausgeführt werden soll, wenn ein Ereignis ausgegeben wird. Wenn Sie sich nur für eine Art von Ereignis interessieren (in diesem Fall `SetGreeting`), können Sie diese Syntax verwenden, um sich auf diesen Ereignistyp zu beschränken.
+
+```typescript
+ onLogs: logs => {
+```
+
+Die `onLogs`-Funktion wird aufgerufen, wenn Protokolleinträge vorhanden sind. In Ethereum sind „Protokoll“ und „Ereignis“ in der Regel austauschbar.
+
+```typescript
+console.log(
+ `Adresse ${logs[0].args.sender} hat die Begrüßung in ${logs[0].args.greeting} geändert`
+)
+```
+
+Es könnte mehrere Ereignisse geben, aber der Einfachheit halber kümmern wir uns nur um das erste. `logs[0].args` sind die Argumente des Ereignisses, in diesem Fall `sender` und `greeting`.
+
+```typescript
+ if (logs[0].args.sender != account.address)
+ setGreeting(`${account.address} besteht darauf, dass es Hallo! heißt`)
+ }
+})
+```
+
+Wenn der Absender _nicht_ dieser Server ist, verwenden Sie `setGreeting`, um die Begrüßung zu ändern.
+
+#### `package.json` {#package-json}
+
+[Diese Datei](https://github.com/qbzzt/20240715-server-component/blob/main/package.json) steuert die [Node.js](https://nodejs.org/en)-Konfiguration. Dieser Artikel erklärt nur die wichtigen Definitionen.
+
+```json
+{
+ "main": "dist/index.js",
+```
+
+Diese Definition gibt an, welche JavaScript-Datei ausgeführt werden soll.
+
+```json
+ "scripts": {
+ "start": "tsc && node dist/app.js",
+ },
+```
+
+Die Skripte sind verschiedene Aktionen der Anwendung. In diesem Fall haben wir nur `start`, was den Server kompiliert und dann ausführt. Der `tsc`-Befehl ist Teil des `typescript`-Pakets und kompiliert TypeScript in JavaScript. Wenn Sie es manuell ausführen möchten, befindet es sich in `node_modules/.bin`. Der zweite Befehl führt den Server aus.
+
+```json
+ "type": "module",
+```
+
+Es gibt mehrere Arten von JavaScript-Node-Anwendungen. Der `module`-Typ ermöglicht es uns, `await` im Code der obersten Ebene zu haben, was wichtig ist, wenn Sie langsame (und daher asynchrone) Operationen durchführen.
+
+```json
+ "devDependencies": {
+ "@types/node": "^20.14.2",
+ "typescript": "^5.4.5"
+ },
+```
+
+Dies sind Pakete, die nur für die Entwicklung benötigt werden. Hier benötigen wir `typescript`, und da wir es mit Node.js verwenden, erhalten wir auch die Typen für Node-Variablen und -Objekte, wie z. B. `process`. [Die `^`-Notation](https://github.com/npm/node-semver?tab=readme-ov-file#caret-ranges-123-025-004) bedeutet diese Version oder eine höhere Version, die keine Breaking Changes enthält. Weitere Informationen zur Bedeutung von Versionsnummern finden Sie [hier](https://semver.org).
+
+```json
+ "dependencies": {
+ "dotenv": "^16.4.5",
+ "viem": "2.14.1"
+ }
+}
+```
+
+Dies sind Pakete, die zur Laufzeit benötigt werden, wenn `dist/app.js` ausgeführt wird.
+
+## Fazit {#conclusion}
+
+Der zentralisierte Server, den wir hier erstellt haben, erfüllt seine Aufgabe, nämlich als Agent für einen Benutzer zu agieren. Jeder andere, der möchte, dass die Dapp weiterhin funktioniert, und bereit ist, das Gas auszugeben, kann eine neue Instanz des Servers mit seiner eigenen Adresse ausführen.
+
+Dies funktioniert jedoch nur, wenn die Aktionen des zentralisierten Servers leicht überprüft werden können. Wenn der zentralisierte Server geheime Zustandsinformationen hat oder schwierige Berechnungen durchführt, ist er eine zentralisierte Entität, der Sie vertrauen müssen, um die Anwendung zu nutzen, was genau das ist, was Blockchains zu vermeiden versuchen. In einem zukünftigen Artikel plane ich zu zeigen, wie man [Zero-Knowledge-Beweise](/zero-knowledge-proofs) verwendet, um dieses Problem zu umgehen.
+
+[Hier finden Sie mehr von meiner Arbeit](https://cryptodocguy.pro/).
diff --git a/public/content/translations/de/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/index.md b/public/content/translations/de/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/index.md
new file mode 100644
index 00000000000..852b38deea1
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/index.md
@@ -0,0 +1,92 @@
+---
+title: Einrichtung von web3.js zur Verwendung der Ethereum-Blockchain in JavaScript
+description: Erfahren Sie, wie Sie die web3.js-Bibliothek einrichten und konfigurieren, um von JavaScript-Anwendungen aus mit der Ethereum-Blockchain zu interagieren.
+author: "jdourlens"
+tags: [ "web3.js", "javascript" ]
+skill: beginner
+lang: de
+published: 2020-04-11
+source: EthereumDev
+sourceUrl: https://ethereumdev.io/setup-web3js-to-use-the-ethereum-blockchain-in-javascript/
+address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
+---
+
+In diesem Tutorial erfahren Sie, wie Sie die ersten Schritte mit [web3.js](https://web3js.readthedocs.io/) machen, um mit der Ethereum-Blockchain zu interagieren. Web3.js kann sowohl in Frontends als auch in Backends verwendet werden, um Daten aus der Blockchain zu lesen, Transaktionen durchzuführen und sogar Smart Contracts bereitzustellen.
+
+Der erste Schritt ist, web3.js in Ihr Projekt einzubinden. Um es auf einer Webseite zu verwenden, können Sie die Bibliothek direkt über ein CDN wie JSDeliver importieren.
+
+```html
+
+```
+
+Wenn Sie es vorziehen, die Bibliothek für die Verwendung in Ihrem Backend oder einem Frontend-Projekt mit Build-Prozess zu installieren, können Sie sie mit npm installieren:
+
+```bash
+npm install web3 --save
+```
+
+Um Web3.js in ein Node.js-Skript oder ein Browserify-Frontend-Projekt zu importieren, können Sie dann die folgende JavaScript-Zeile verwenden:
+
+```js
+const Web3 = require("web3")
+```
+
+Da wir die Bibliothek nun in das Projekt eingebunden haben, müssen wir sie initialisieren. Ihr Projekt muss in der Lage sein, mit der Blockchain zu kommunizieren. Die meisten Ethereum-Bibliotheken kommunizieren über RPC-Calls mit einem [Node](/developers/docs/nodes-and-clients/). Um unseren Web3-Provider zu initiieren, instanziieren wir eine Web3-Instanz und übergeben dem Konstruktor die URL des Providers. Wenn Sie einen Node oder eine [auf Ihrem Computer laufende Ganache-Instanz](https://ethereumdev.io/testing-your-smart-contract-with-existing-protocols-ganache-fork/) haben, sieht es so aus:
+
+```js
+const web3 = new Web3("http://localhost:8545")
+```
+
+Wenn Sie direkt auf einen gehosteten Node zugreifen möchten, finden Sie Optionen unter [Nodes-as-a-Service](/developers/docs/nodes-and-clients/nodes-as-a-service).
+
+```js
+const web3 = new Web3("https://cloudflare-eth.com")
+```
+
+Um zu testen, ob wir unsere Web3-Instanz korrekt konfiguriert haben, versuchen wir, die aktuellste Blocknummer mit der Funktion `getBlockNumber` abzurufen. Diese Funktion akzeptiert einen Callback als Parameter und gibt die Blocknummer als Integer zurück.
+
+```js
+var Web3 = require("web3")
+const web3 = new Web3("https://cloudflare-eth.com")
+
+web3.eth.getBlockNumber(function (error, result) {
+ console.log(result)
+})
+```
+
+Wenn Sie dieses Programm ausführen, wird einfach die aktuellste Blocknummer ausgegeben: die Spitze der Blockchain. Sie können auch `await/async`-Funktionsaufrufe verwenden, um die Verschachtelung von Callbacks in Ihrem Code zu vermeiden:
+
+```js
+async function getBlockNumber() {
+ const latestBlockNumber = await web3.eth.getBlockNumber()
+ console.log(latestBlockNumber)
+ return latestBlockNumber
+}
+
+getBlockNumber()
+```
+
+Sie finden alle auf der Web3-Instanz verfügbaren Funktionen in der [offiziellen web3.js-Dokumentation](https://docs.web3js.org/).
+
+Die meisten Web3-Bibliotheken sind asynchron, da die Bibliothek im Hintergrund JSON-RPC-Aufrufe an den Node durchführt, der das Ergebnis zurücksendet.
+
+(,...).`
+
+```solidity
+
+ _retVal = _retVal >> (256-length*8);
+```
+
+Nur die höchstwertigen `length` Bytes sind Teil des Feldes, daher verwenden wir eine [Rechtsverschiebung](https://en.wikipedia.org/wiki/Logical_shift), um die anderen Werte zu entfernen.
+Dies hat den zusätzlichen Vorteil, dass der Wert nach rechts im Feld verschoben wird, sodass es der Wert selbst ist und nicht der Wert mal 256irgendwas.
+
+```solidity
+
+ return _retVal;
+ }
+
+
+ fallback() external {
+```
+
+Wenn ein Aufruf an einen Solidity-Vertrag keiner der Funktionssignaturen entspricht, ruft er [die `fallback()`-Funktion](https://docs.soliditylang.org/en/v0.8.12/contracts.html#fallback-function) auf (sofern eine vorhanden ist).
+Im Fall von `CalldataInterpreter` landet _jeder_ Aufruf hier, da es keine anderen `external`- oder `public`-Funktionen gibt.
+
+```solidity
+ uint _func;
+
+ _func = calldataVal(0, 1);
+```
+
+Lesen Sie das erste Byte der Calldata, das uns die Funktion mitteilt.
+Es gibt zwei Gründe, warum eine Funktion hier nicht verfügbar wäre:
+
+1. Funktionen, die `pure` oder `view` sind, ändern den Zustand nicht und kosten kein Gas (wenn sie offchain aufgerufen werden).
+ Es macht keinen Sinn, ihre Gas-Kosten zu reduzieren.
+2. Funktionen, die auf [`msg.sender`](https://docs.soliditylang.org/en/v0.8.12/units-and-global-variables.html#block-and-transaction-properties) angewiesen sind.
+ Der Wert von `msg.sender` wird die Adresse von `CalldataInterpreter` sein, nicht die des Aufrufers.
+
+Leider, [wenn man sich die ERC-20-Spezifikationen ansieht](https://eips.ethereum.org/EIPS/eip-20), bleibt nur eine Funktion übrig, `transfer`.
+Damit bleiben uns nur zwei Funktionen: `transfer` (weil wir `transferFrom` aufrufen können) und `faucet` (weil wir die Tokens an denjenigen zurücküberweisen können, der uns aufgerufen hat).
+
+```solidity
+
+ // Rufen Sie die zustandsändernden Methoden von Token auf mit
+ // Informationen aus den Calldata
+
+ // Faucet
+ if (_func == 1) {
+```
+
+Ein Aufruf an `faucet()`, der keine Parameter hat.
+
+```solidity
+ token.faucet();
+ token.transfer(msg.sender,
+ token.balanceOf(address(this)));
+ }
+```
+
+Nachdem wir `token.faucet()` aufgerufen haben, erhalten wir Tokens. Als Proxy-Vertrag **benötigen** wir jedoch keine Tokens.
+Das EOA (externally owned account) oder der Vertrag, der uns aufgerufen hat, schon.
+Also überweisen wir alle unsere Tokens an denjenigen, der uns angerufen hat.
+
+```solidity
+ // Überweisung (angenommen, wir haben eine Freigabe dafür)
+ if (_func == 2) {
+```
+
+Das Überweisen von Tokens erfordert zwei Parameter: die Zieladresse und den Betrag.
+
+```solidity
+ token.transferFrom(
+ msg.sender,
+```
+
+Wir erlauben Anrufern nur, Tokens zu überweisen, die sie besitzen
+
+```solidity
+ address(uint160(calldataVal(1, 20))),
+```
+
+Die Zieladresse beginnt bei Byte #1 (Byte #0 ist die Funktion).
+Als Adresse ist sie 20 Bytes lang.
+
+```solidity
+ calldataVal(21, 2)
+```
+
+Für diesen speziellen Vertrag gehen wir davon aus, dass die maximale Anzahl von Tokens, die jemand überweisen möchte, in zwei Bytes passt (weniger als 65.536).
+
+```solidity
+ );
+ }
+```
+
+Insgesamt benötigt eine Überweisung 35 Bytes an Calldata:
+
+| Abschnitt | Länge | Bytes |
+| ----------------- | ----: | ----: |
+| Funktionsselektor | 1 | 0 |
+| Zieladresse | 32 | 1-32 |
+| Betrag | 2 | 33-34 |
+
+```solidity
+ } // Fallback
+
+} // Vertrag CalldataInterpreter
+```
+
+### test.js {#test-js}
+
+[Dieser JavaScript-Unit-Test](https://github.com/qbzzt/ethereum.org-20220330-shortABI/blob/master/test/test.js) zeigt uns, wie dieser Mechanismus verwendet wird (und wie man seine korrekte Funktionsweise überprüft).
+Ich gehe davon aus, dass Sie [chai](https://www.chaijs.com/) und [ethers](https://docs.ethers.io/v5/) verstehen und erkläre nur die Teile, die sich speziell auf den Vertrag beziehen.
+
+```js
+const { expect } = require("chai");
+
+describe("CalldataInterpreter", function () {
+ it("Sollte uns die Verwendung von Tokens ermöglichen", async function () {
+ const Token = await ethers.getContractFactory("OrisUselessToken")
+ const token = await Token.deploy()
+ await token.deployed()
+ console.log("Token-Adresse:", token.address)
+
+ const Cdi = await ethers.getContractFactory("CalldataInterpreter")
+ const cdi = await Cdi.deploy(token.address)
+ await cdi.deployed()
+ console.log("CalldataInterpreter-Adresse:", cdi.address)
+
+ const signer = await ethers.getSigner()
+```
+
+Wir beginnen mit der Bereitstellung beider Verträge.
+
+```javascript
+ // Holen Sie sich Tokens zum Herumspielen
+ const faucetTx = {
+```
+
+Wir können nicht die übergeordneten Funktionen verwenden, die wir normalerweise verwenden würden (wie z. B. `token.faucet()`), um Transaktionen zu erstellen, da wir uns nicht an das ABI halten.
+Stattdessen müssen wir die Transaktion selbst erstellen und dann senden.
+
+```javascript
+ to: cdi.address,
+ data: "0x01"
+```
+
+Es gibt zwei Parameter, die wir für die Transaktion angeben müssen:
+
+1. `to`, die Zieladresse.
+ Dies ist der Calldata-Interpreter-Vertrag.
+2. `data`, die zu sendenden Calldata.
+ Im Falle eines Faucet-Aufrufs bestehen die Daten aus einem einzigen Byte, `0x01`.
+
+```javascript
+
+ }
+ await (await signer.sendTransaction(faucetTx)).wait()
+```
+
+Wir rufen die `sendTransaction`-Methode [des Signierers](https://docs.ethers.io/v5/api/signer/#Signer-sendTransaction) auf, da wir das Ziel (`faucetTx.to`) bereits angegeben haben und die Transaktion signiert werden muss.
+
+```javascript
+// Überprüfen Sie, ob der Faucet die Tokens korrekt bereitstellt
+expect(await token.balanceOf(signer.address)).to.equal(1000)
+```
+
+Hier überprüfen wir den Kontostand.
+Bei `view`-Funktionen muss kein Gas gespart werden, daher führen wir sie ganz normal aus.
+
+```javascript
+// Dem CDI eine Freigabe erteilen (Freigaben können nicht über einen Proxy geleitet werden)
+const approveTX = await token.approve(cdi.address, 10000)
+await approveTX.wait()
+expect(await token.allowance(signer.address, cdi.address)).to.equal(10000)
+```
+
+Geben Sie dem Calldata-Interpreter eine Freigabe, um Überweisungen durchführen zu können.
+
+```javascript
+// Tokens überweisen
+const destAddr = "0xf5a6ead936fb47f342bb63e676479bddf26ebe1d"
+const transferTx = {
+ to: cdi.address,
+ data: "0x02" + destAddr.slice(2, 42) + "0100",
+}
+```
+
+Erstellen Sie eine Überweisungstransaktion. Das erste Byte ist „0x02“, gefolgt von der Zieladresse und schließlich dem Betrag (0x0100, was dezimal 256 entspricht).
+
+```javascript
+ await (await signer.sendTransaction(transferTx)).wait()
+
+ // Überprüfen, ob wir 256 Tokens weniger haben
+ expect (await token.balanceOf(signer.address)).to.equal(1000-256)
+
+ // Und dass unser Ziel sie erhalten hat
+ expect (await token.balanceOf(destAddr)).to.equal(256)
+ }) // es
+}) // beschreiben
+```
+
+## Kostenreduzierung, wenn Sie den Zielvertrag kontrollieren {#reducing-the-cost-when-you-do-control-the-destination-contract}
+
+Wenn Sie die Kontrolle über den Zielvertrag haben, können Sie Funktionen erstellen, die die `msg.sender`-Prüfungen umgehen, da sie dem Calldata-Interpreter vertrauen.
+[Ein Beispiel dafür, wie das funktioniert, finden Sie hier im `control-contract`-Branch](https://github.com/qbzzt/ethereum.org-20220330-shortABI/tree/control-contract).
+
+Wenn der Vertrag nur auf externe Transaktionen reagieren würde, könnten wir mit nur einem Vertrag auskommen.
+Dies würde jedoch die [Komponierbarkeit](/developers/docs/smart-contracts/composability/) beeinträchtigen.
+Es ist viel besser, einen Vertrag zu haben, der auf normale ERC-20-Aufrufe reagiert, und einen anderen Vertrag, der auf Transaktionen mit kurzen Anrufdaten reagiert.
+
+### Token.sol {#token-sol-2}
+
+In diesem Beispiel können wir `Token.sol` modifizieren.
+Dies ermöglicht uns, eine Reihe von Funktionen zu haben, die nur der Proxy aufrufen darf.
+Hier sind die neuen Teile:
+
+```solidity
+ // Die einzige Adresse, die die CalldataInterpreter-Adresse angeben darf
+ address owner;
+
+ // Die CalldataInterpreter-Adresse
+ address proxy = address(0);
+```
+
+Der ERC-20-Vertrag muss die Identität des autorisierten Proxys kennen.
+Wir können diese Variable jedoch nicht im Konstruktor festlegen, da wir den Wert noch nicht kennen.
+Dieser Vertrag wird zuerst instanziiert, da der Proxy die Adresse des Tokens in seinem Konstruktor erwartet.
+
+```solidity
+ /**
+ * @dev Ruft den ERC20-Konstruktor auf.
+ */
+ constructor(
+ ) ERC20("Oris nutzloser Token-2", "OUT-2") {
+ owner = msg.sender;
+ }
+```
+
+Die Adresse des Erstellers (genannt `owner`) wird hier gespeichert, da dies die einzige Adresse ist, die den Proxy festlegen darf.
+
+```solidity
+ /**
+ * @dev Legt die Adresse für den Proxy (den CalldataInterpreter) fest.
+ * Kann nur einmal vom Eigentümer aufgerufen werden
+ */
+ function setProxy(address _proxy) external {
+ require(msg.sender == owner, "Kann nur vom Eigentümer aufgerufen werden");
+ require(proxy == address(0), "Proxy ist bereits festgelegt");
+
+ proxy = _proxy;
+ } // Funktion setProxy
+```
+
+Der Proxy hat privilegierten Zugriff, da er Sicherheitsprüfungen umgehen kann.
+Um sicherzustellen, dass wir dem Proxy vertrauen können, lassen wir nur `owner` diese Funktion aufrufen, und das nur einmal.
+Sobald `proxy` einen echten Wert hat (nicht null), kann dieser Wert nicht mehr geändert werden. Selbst wenn der Besitzer bösartig wird oder die Mnemonik dafür bekannt wird, sind wir immer noch sicher.
+
+```solidity
+ /**
+ * @dev Einige Funktionen dürfen nur vom Proxy aufgerufen werden.
+ */
+ modifier onlyProxy {
+```
+
+Dies ist eine [`modifier`-Funktion](https://www.tutorialspoint.com/solidity/solidity_function_modifiers.htm), sie modifiziert die Funktionsweise anderer Funktionen.
+
+```solidity
+ require(msg.sender == proxy);
+```
+
+Überprüfen Sie zuerst, ob wir vom Proxy und von niemand anderem aufgerufen wurden.
+Wenn nicht, `revert`.
+
+```solidity
+ _;
+ }
+```
+
+Wenn ja, führen Sie die Funktion aus, die wir ändern.
+
+```solidity
+ /* Funktionen, die es dem Proxy ermöglichen, tatsächlich für Konten zu fungieren */
+
+ function transferProxy(address from, address to, uint256 amount)
+ public virtual onlyProxy() returns (bool)
+ {
+ _transfer(from, to, amount);
+ return true;
+ }
+
+ function approveProxy(address from, address spender, uint256 amount)
+ public virtual onlyProxy() returns (bool)
+ {
+ _approve(from, spender, amount);
+ return true;
+ }
+
+ function transferFromProxy(
+ address spender,
+ address from,
+ address to,
+ uint256 amount
+ ) public virtual onlyProxy() returns (bool)
+ {
+ _spendAllowance(from, spender, amount);
+ _transfer(from, to, amount);
+ return true;
+ }
+```
+
+Dies sind drei Operationen, bei denen die Nachricht normalerweise direkt von der Entität kommen muss, die Tokens überweist oder eine Freigabe genehmigt.
+Hier haben wir eine Proxy-Version dieser Operationen, die:
+
+1. durch `onlyProxy()` modifiziert ist, sodass niemand anderes sie kontrollieren darf.
+2. die Adresse, die normalerweise `msg.sender` wäre, als zusätzlichen Parameter erhält.
+
+### CalldataInterpreter.sol {#calldatainterpreter-sol-2}
+
+Der Calldata-Interpreter ist fast identisch mit dem oben genannten, außer dass die über den Proxy geleiteten Funktionen einen `msg.sender`-Parameter erhalten und keine Freigabe für `transfer` erforderlich ist.
+
+```solidity
+ // Überweisung (keine Freigabe erforderlich)
+ if (_func == 2) {
+ token.transferProxy(
+ msg.sender,
+ address(uint160(calldataVal(1, 20))),
+ calldataVal(21, 2)
+ );
+ }
+
+ // genehmigen
+ if (_func == 3) {
+ token.approveProxy(
+ msg.sender,
+ address(uint160(calldataVal(1, 20))),
+ calldataVal(21, 2)
+ );
+ }
+
+ // transferFrom
+ if (_func == 4) {
+ token.transferFromProxy(
+ msg.sender,
+ address(uint160(calldataVal( 1, 20))),
+ address(uint160(calldataVal(21, 20))),
+ calldataVal(41, 2)
+ );
+ }
+```
+
+### Test.js {#test-js-2}
+
+Es gibt einige Änderungen zwischen dem vorherigen Testcode und diesem.
+
+```js
+const Cdi = await ethers.getContractFactory("CalldataInterpreter")
+const cdi = await Cdi.deploy(token.address)
+await cdi.deployed()
+await token.setProxy(cdi.address)
+```
+
+Wir müssen dem ERC-20-Vertrag mitteilen, welchem Proxy er vertrauen soll
+
+```js
+console.log("CalldataInterpreter-Adresse:", cdi.address)
+
+// Benötigen zwei Unterzeichner, um die Zulagen zu überprüfen
+const signers = await ethers.getSigners()
+const signer = signers[0]
+const poorSigner = signers[1]
+```
+
+Um `approve()` und `transferFrom()` zu überprüfen, benötigen wir einen zweiten Unterzeichner.
+Wir nennen ihn `poorSigner` (armer Unterzeichner), weil er keine unserer Tokens erhält (er muss natürlich ETH haben).
+
+```js
+// Tokens überweisen
+const destAddr = "0xf5a6ead936fb47f342bb63e676479bddf26ebe1d"
+const transferTx = {
+ to: cdi.address,
+ data: "0x02" + destAddr.slice(2, 42) + "0100",
+}
+await (await signer.sendTransaction(transferTx)).wait()
+```
+
+Da der ERC-20-Vertrag dem Proxy (`cdi`) vertraut, benötigen wir keine Freigabe für die Weiterleitung von Überweisungen.
+
+```js
+// Freigabe und transferFrom
+const approveTx = {
+ to: cdi.address,
+ data: "0x03" + poorSigner.address.slice(2, 42) + "00FF",
+}
+await (await signer.sendTransaction(approveTx)).wait()
+
+const destAddr2 = "0xE1165C689C0c3e9642cA7606F5287e708d846206"
+
+const transferFromTx = {
+ to: cdi.address,
+ data: "0x04" + signer.address.slice(2, 42) + destAddr2.slice(2, 42) + "00FF",
+}
+await (await poorSigner.sendTransaction(transferFromTx)).wait()
+
+// Überprüfen, ob die Kombination aus Freigabe und transferFrom korrekt ausgeführt wurde
+expect(await token.balanceOf(destAddr2)).to.equal(255)
+```
+
+Testen Sie die beiden neuen Funktionen.
+Beachten Sie, dass `transferFromTx` zwei Adressparameter erfordert: den Geber der Freigabe und den Empfänger.
+
+## Fazit {#conclusion}
+
+Sowohl [Optimism](https://medium.com/ethereum-optimism/the-road-to-sub-dollar-transactions-part-2-compression-edition-6bb2890e3e92) als auch [Arbitrum](https://developer.offchainlabs.com/docs/special_features) suchen nach Wegen, die Größe der auf L1 geschriebenen Calldata und damit die Kosten von Transaktionen zu reduzieren.
+Als Infrastrukturanbieter, die nach generischen Lösungen suchen, sind unsere Möglichkeiten jedoch begrenzt.
+Als Dapp-Entwickler verfügen Sie über anwendungsspezifisches Wissen, mit dem Sie Ihre Calldata viel besser optimieren können, als wir es in einer generischen Lösung könnten.
+Hoffentlich hilft Ihnen dieser Artikel, die ideale Lösung für Ihre Bedürfnisse zu finden.
+
+[Hier finden Sie mehr von meiner Arbeit](https://cryptodocguy.pro/).
+
diff --git a/public/content/translations/de/developers/tutorials/smart-contract-security-guidelines/index.md b/public/content/translations/de/developers/tutorials/smart-contract-security-guidelines/index.md
new file mode 100644
index 00000000000..c54e39a3bd8
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/smart-contract-security-guidelines/index.md
@@ -0,0 +1,91 @@
+---
+title: Smart-Contract-Sicherheitsrichtlinien
+description: Eine Checkliste der Sicherheitsrichtlinien, die beim Erstellen Ihrer dapp berücksichtigt werden sollen
+author: "Spuren von bits"
+tags: [ "solidity", "Smart Contracts", "Sicherheit" ]
+skill: intermediate
+lang: de
+published: 06.09.2020
+source: Aufbau sicherer Verträge
+sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/guidelines.md
+---
+
+Befolgen Sie diese High-Level Empfehlungen, um sicherere Smart Contracts zu schreiben.
+
+## Design-Richtlinien {#design-guidelines}
+
+Bevor Code geschrieben wird, sollte die Gestaltung des Smart Contracts sollte diskutiert werden.
+
+### Dokumentation und Spezifikationen {#documentation-and-specifications}
+
+Dokumentationen können auf verschiedenen Ebenen geschrieben werden und sollten bei der Umsetzung von Contracts aktualisiert werden:
+
+- **Eine einfache englische Beschreibung des Systems**, die beschreibt, was die Verträge tun und welche Annahmen bezüglich der Codebasis getroffen werden.
+- **Schema- und Architekturdiagramme**, einschließlich der Vertragsinteraktionen und der Zustandsmaschine des Systems. [Slither-Printers](https://github.com/crytic/slither/wiki/Printer-documentation) können helfen, diese Schemata zu generieren.
+- **Eine gründliche Code-Dokumentation**, für die in Solidity das [Natspec-Format](https://docs.soliditylang.org/en/develop/natspec-format.html) verwendet werden kann.
+
+### On-Chain- vs. Off-Chain-Berechnungen {#onchain-vs-offchain-computation}
+
+- **Halten Sie so viel Code wie möglich Off-Chain.** Halten Sie die On-Chain-Ebene klein. Verarbeiten Sie Daten mit Code Off-Chain so vor, dass die Verifizierung On-Chain einfach ist. Brauchst du eine sortierte Liste? Sortieren Sie die Liste off-chain, um anschließend nur noch nie Reihenfolge on-chain zu überprüfen.
+
+### Upgrade-Fähigkeit {#upgradeability}
+
+Wir haben die verschiedenen Lösungen zur Upgrade-Fähigkeit in [unserem Blogbeitrag](https://blog.trailofbits.com/2018/09/05/contract-upgrade-anti-patterns/) diskutiert. Entscheiden Sie sich bewusst für oder gegen die Erweiterbarkeit Ihres Codes. Diese Entscheidung wird beeinflussen, wie Sie Ihren Code strukturieren. Generell empfehlen wir:
+
+- **Bevorzugen Sie die [Vertragsmigration](https://blog.trailofbits.com/2018/10/29/how-contract-migration-works/) gegenüber der Upgrade-Fähigkeit.** Migrationssysteme haben viele der gleichen Vorteile wie upgrade-fähige Systeme, aber nicht deren Nachteile.
+- **Verwenden Sie das Datentrennungsmuster anstelle des delegatecallproxy-Musters.** Wenn Ihr Projekt eine klare Trennung der Abstraktionsebenen aufweist, erfordert die Upgrade-Fähigkeit mittels Datentrennung nur wenige Anpassungen. Das delegatecallproxy Muster ist sehr fehleranfällig, da EVM Expertise gefragt ist.
+- **Dokumentieren Sie das Migrations-/Upgrade-Verfahren vor dem Deployment.** Wenn Sie unter Stress ohne Richtlinien reagieren müssen, machen Sie Fehler. Schreiben Sie die Aktualisierungsrichtlinien also rechtzeitig. Es sollte berücksichtig werden:
+ - Aufrufe welche die neuen Smart Contracts initialisieren
+ - Speicherort der Schlüssel und wie auf sie zugegriffen werden kann
+ - Wie die Bereitstellung überprüft werden kann! Entwickeln und testen Sie ein Post-Bereitstellungs-Skript.
+
+## Implementierungsrichtlinien {#implementation-guidelines}
+
+**Streben Sie nach Einfachheit.** Verwenden Sie immer die einfachste Lösung, die Ihren Zweck erfüllt. Jedes Mitglied Ihres Teams sollte Ihre Lösung verstehen können.
+
+### Funktionskomposition {#function-composition}
+
+Die Architektur Ihrer Codebasis sollte eine einfache Überprüfung Ihres Codes ermöglichen. Vermeiden Sie Architekturentscheidungen, die es erschweren, die Korrektheit nachzuvollziehen.
+
+- **Teilen Sie die Logik Ihres Systems auf**, entweder durch mehrere Verträge oder durch die Gruppierung ähnlicher Funktionen (z. B. Authentifizierung, Arithmetik, ...).
+- **Schreiben Sie kleine Funktionen mit einem klaren Zweck.** Dies erleichtert die Überprüfung und ermöglicht das Testen einzelner Komponenten.
+
+### Vererbung {#inheritance}
+
+- **Halten Sie die Vererbung überschaubar.** Vererbung sollte zur Aufteilung der Logik verwendet werden, Ihr Projekt sollte jedoch darauf abzielen, die Tiefe und Breite des Vererbungsbaums zu minimieren.
+- **Verwenden Sie den [Vererbungs-Printer von Slither](https://github.com/crytic/slither/wiki/Printer-documentation#inheritance-graph), um die Vertragshierarchie zu überprüfen.** Der Vererbungs-Printer hilft Ihnen bei der Überprüfung der Größe der Hierarchie.
+
+### Ereignisse {#events}
+
+- **Protokollieren Sie alle wichtigen Vorgänge.** Ereignisse (Events) helfen, den Vertrag während der Entwicklung zu debuggen und ihn nach der Bereitstellung zu überwachen.
+
+### Bekannte Fallstricke vermeiden {#avoid-known-pitfalls}
+
+- **Seien Sie sich der häufigsten Sicherheitsprobleme bewusst.** Es gibt viele Online-Ressourcen, um sich über häufige Probleme zu informieren, wie z. B. [Ethernaut CTF](https://ethernaut.openzeppelin.com/), [Capture the Ether](https://capturetheether.com/) oder [Not so smart contracts](https://github.com/crytic/not-so-smart-contracts/).
+- **Beachten Sie die Warnhinweise in der [Solidity-Dokumentation](https://docs.soliditylang.org/en/latest/).** Die Warnhinweise informieren Sie über nicht offensichtliches Verhalten der Sprache.
+
+### Abhängigkeiten {#dependencies}
+
+- **Verwenden Sie gut getestete Bibliotheken.** Das Importieren von Code aus gut getesteten Bibliotheken verringert die Wahrscheinlichkeit, dass Sie fehlerhaften Code schreiben. Wenn Sie einen ERC20-Vertrag schreiben möchten, verwenden Sie [OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20).
+- **Verwenden Sie einen Abhängigkeitsmanager; vermeiden Sie das Kopieren und Einfügen von Code.** Wenn Sie sich auf eine externe Quelle verlassen, müssen Sie diese mit der Originalquelle auf dem neuesten Stand halten.
+
+### Testen und Verifizierung {#testing-and-verification}
+
+- **Schreiben Sie gründliche Unit-Tests.** Eine umfangreiche Test-Suite ist entscheidend für die Entwicklung hochwertiger Software.
+- **Schreiben Sie benutzerdefinierte Prüfungen und Eigenschaften für [Slither](https://github.com/crytic/slither), [Echidna](https://github.com/crytic/echidna) und [Manticore](https://github.com/trailofbits/manticore).** Automatisierte Tools helfen sicherzustellen, dass Ihr Vertrag sicher ist. Lesen Sie den Rest dieses Leitfadens, um zu erfahren, wie Sie effiziente Prüfungen und Eigenschaften schreiben.
+- **Verwenden Sie [crytic.io](https://crytic.io/).** Crytic lässt sich in GitHub integrieren, bietet Zugriff auf private Slither-Detektoren und führt benutzerdefinierte Eigenschaftsprüfungen von Echidna aus.
+
+### Solidity {#solidity}
+
+- **Bevorzugen Sie Solidity 0.5 gegenüber 0.4 und 0.6.** Unserer Meinung nach ist Solidity 0.5 sicherer und verfügt über bessere integrierte Praktiken als 0.4. Solidity 0.6 hat sich für den Produktionseinsatz als zu instabil erwiesen und benötigt Zeit zur Reifung.
+- **Verwenden Sie eine stabile Version zum Kompilieren; verwenden Sie die neueste Version zur Überprüfung auf Warnungen.** Stellen Sie sicher, dass Ihr Code keine gemeldeten Probleme mit der neuesten Compiler-Version aufweist. Allerdings hat Solidity einen schnellen Release-Zyklus und eine Vorgeschichte von Compiler-Bugs, daher empfehlen wir nicht die neueste Version für das Deployment (siehe Slithers [solc-Versionsempfehlung](https://github.com/crytic/slither/wiki/Detector-Documentation#recommendation-33)).
+- **Verwenden Sie kein Inline-Assembly.** Assembly erfordert EVM-Fachwissen. Schreiben Sie keinen EVM-Code, wenn Sie das Yellow Paper nicht _gemeistert_ haben.
+
+## Deployment-Richtlinien {#deployment-guidelines}
+
+Nach Entwicklung und Bereitstellung eines Smart Contracts:
+
+- **Überwachen Sie Ihre Verträge.** Beobachten Sie die Protokolle und seien Sie bereit, im Falle einer Kompromittierung des Vertrags oder der Wallet zu reagieren.
+- **Fügen Sie Ihre Kontaktinformationen zu [blockchain-security-contacts](https://github.com/crytic/blockchain-security-contacts) hinzu.** Diese Liste hilft Dritten, Sie zu kontaktieren, wenn eine Sicherheitslücke entdeckt wird.
+- **Sichern Sie die Wallets von privilegierten Benutzern.** Befolgen Sie unsere [Best Practices](https://blog.trailofbits.com/2018/11/27/10-rules-for-the-secure-use-of-cryptocurrency-hardware-wallets/), wenn Sie Schlüssel in Hardware-Wallets speichern.
+- **Haben Sie einen Plan für die Reaktion auf Vorfälle.** Bedenken Sie, dass Ihre Smart Contracts kompromittiert werden können. Selbst wenn Ihre Verträge fehlerfrei sind, kann ein Angreifer die Kontrolle über die Schlüssel des Vertragsinhabers übernehmen.
diff --git a/public/content/translations/de/developers/tutorials/stealth-addr/index.md b/public/content/translations/de/developers/tutorials/stealth-addr/index.md
new file mode 100644
index 00000000000..6eea3375006
--- /dev/null
+++ b/public/content/translations/de/developers/tutorials/stealth-addr/index.md
@@ -0,0 +1,443 @@
+---
+title: "Verwendung von Stealth-Adressen"
+description: "Stealth-Adressen ermöglichen es Benutzern, Vermögenswerte anonym zu übertragen. Nach der Lektüre dieses Artikels werden Sie in der Lage sein: zu erklären, was Stealth-Adressen sind und wie sie funktionieren, zu verstehen, wie man Stealth-Adressen so verwendet, dass die Anonymität gewahrt bleibt, und eine webbasierte Anwendung zu schreiben, die Stealth-Adressen verwendet."
+author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+tags:
+ [
+ "Stealth-Adresse",
+ "Privatsphäre",
+ "Kryptographie",
+ "rust",
+ "wasm"
+ ]
+skill: intermediate
+published: 2025-11-30
+lang: de
+sidebarDepth: 3
+---
+
+Sie sind Bill. Aus Gründen, auf die wir nicht näher eingehen werden, möchten Sie für die Kampagne "Alice für die Königin der Welt" spenden, und Alice soll wissen, dass Sie gespendet haben, damit sie Sie belohnt, wenn sie gewinnt. Leider ist ihr Sieg nicht garantiert. Es gibt eine konkurrierende Kampagne, "Carol für die Kaiserin des Sonnensystems". Wenn Carol gewinnt und herausfindet, dass Sie an Alice gespendet haben, werden Sie in Schwierigkeiten geraten. Sie können also nicht einfach 200 ETH von Ihrem Konto auf das von Alice überweisen.
+
+[ERC-5564](https://eips.ethereum.org/EIPS/eip-5564) hat die Lösung. Dieser ERC erklärt, wie [Stealth-Adressen](https://nerolation.github.io/stealth-utils) für anonyme Übertragungen verwendet werden.
+
+**Warnung**: Die Kryptographie hinter Stealth-Adressen ist, soweit wir wissen, solide. Es gibt jedoch potenzielle Seitenkanalangriffe. [Unten](#go-wrong), werden Sie sehen, was Sie tun können, um dieses Risiko zu verringern.
+
+## Wie Stealth-Adressen funktionieren {#how}
+
+Dieser Artikel wird versuchen, Stealth-Adressen auf zwei Arten zu erklären. Die erste ist, [wie man sie benutzt](#how-use). Dieser Teil ist ausreichend, um den Rest des Artikels zu verstehen. Dann gibt es [eine Erklärung der dahinterstehenden Mathematik](#how-math). Wenn Sie sich für Kryptographie interessieren, lesen Sie auch diesen Teil.
+
+### Die einfache Version (wie man Stealth-Adressen benutzt) {#how-use}
+
+Alice erstellt zwei private Schlüssel und veröffentlicht die entsprechenden öffentlichen Schlüssel (die zu einer einzigen Meta-Adresse doppelter Länge kombiniert werden können). Bill erstellt ebenfalls einen privaten Schlüssel und veröffentlicht den entsprechenden öffentlichen Schlüssel.
+
+Mit dem öffentlichen Schlüssel einer Partei und dem privaten Schlüssel der anderen können Sie ein gemeinsames Geheimnis ableiten, das nur Alice und Bill bekannt ist (es kann nicht allein aus den öffentlichen Schlüsseln abgeleitet werden). Mit diesem gemeinsamen Geheimnis erhält Bill die Stealth-Adresse und kann Vermögenswerte an sie senden.
+
+Alice erhält die Adresse ebenfalls aus dem gemeinsamen Geheimnis, aber da sie die privaten Schlüssel zu den von ihr veröffentlichten öffentlichen Schlüsseln kennt, kann sie auch den privaten Schlüssel erhalten, mit dem sie von dieser Adresse abheben kann.
+
+### Die Mathematik (warum Stealth-Adressen so funktionieren) {#how-math}
+
+Standard-Stealth-Adressen verwenden [Elliptische-Kurven-Kryptographie (ECC)](https://blog.cloudflare.com/a-relatively-easy-to-understand-primer-on-elliptic-curve-cryptography/#elliptic-curves-building-blocks-of-a-better-trapdoor), um eine bessere Leistung mit weniger Schlüsselbits zu erzielen und gleichzeitig das gleiche Sicherheitsniveau beizubehalten. Aber größtenteils können wir das ignorieren und so tun, als ob wir normale Arithmetik verwenden.
+
+Es gibt eine Zahl, die jeder kennt, _G_. Man kann mit _G_ multiplizieren. Aber aufgrund der Natur von ECC ist es praktisch unmöglich, durch _G_ zu teilen. Die Art und Weise, wie die Public-Key-Kryptographie im Allgemeinen in Ethereum funktioniert, ist, dass Sie einen privaten Schlüssel, _Ppriv_, verwenden können, um Transaktionen zu signieren, die dann durch einen öffentlichen Schlüssel, _Ppub = GPpriv_, verifiziert werden.
+
+Alice erstellt zwei private Schlüssel, _Kpriv_ und _Vpriv_. _Kpriv_ wird verwendet, um Geld von der Stealth-Adresse auszugeben, und _Vpriv_, um die Adressen anzuzeigen, die Alice gehören. Alice veröffentlicht dann die öffentlichen Schlüssel: _Kpub = GKpriv_ und _Vpub = GVpriv_
+
+Bill erstellt einen dritten privaten Schlüssel, _Rpriv_, und veröffentlicht _Rpub = GRpriv_ in einem zentralen Register (Bill hätte ihn auch an Alice senden können, aber wir gehen davon aus, dass Carol zuhört).
+
+Bill berechnet _RprivVpub = GRprivVpriv_, von dem er erwartet, dass Alice es ebenfalls kennt (wird unten erklärt). Dieser Wert wird _S_ genannt, das gemeinsame Geheimnis. Dies gibt Bill einen öffentlichen Schlüssel, _Ppub = Kpub+G\*hash(S)_. Von diesem öffentlichen Schlüssel aus kann er eine Adresse berechnen und beliebige Ressourcen an sie senden. Wenn Alice in Zukunft gewinnt, kann Bill ihr _Rpriv_ mitteilen, um zu beweisen, dass die Ressourcen von ihm stammen.
+
+Alice berechnet _RpubVpriv = GRprivVpriv_. Dies gibt ihr das gleiche gemeinsame Geheimnis, _S_. Da sie den privaten Schlüssel _Kpriv_ kennt, kann sie _Ppriv = Kpriv+hash(S)_ berechnen. Dieser Schlüssel ermöglicht ihr den Zugriff auf Vermögenswerte in der Adresse, die sich aus _Ppub = GPpriv = GKpriv+G\*hash(S) = Kpub+G\*hash(S)_ ergibt.
+
+Wir haben einen separaten Ansichtsschlüssel, damit Alice die World Domination Campaign Services von Dave unterbeauftragen kann. Alice ist bereit, Dave die öffentlichen Adressen mitzuteilen und sie zu informieren, wenn mehr Geld verfügbar ist, aber sie möchte nicht, dass er ihr Kampagnengeld ausgibt.
+
+Da für das Anzeigen und Ausgeben separate Schlüssel verwendet werden, kann Alice Dave _Vpriv_ geben. Dann kann Dave _S = RpubVpriv = GRprivVpriv_ berechnen und auf diese Weise die öffentlichen Schlüssel (_Ppub = Kpub+G\*hash(S)_) erhalten. Aber ohne _Kpriv_ kann Dave den privaten Schlüssel nicht erhalten.
+
+Zusammenfassend sind dies die Werte, die den verschiedenen Teilnehmern bekannt sind.
+
+| Alice | Veröffentlicht | Bill | Dave | |
+| ------------------------------------------------------------------------- | ----------------- | ------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ----------------------------------------------- |
+| G | G | G | G | |
+| _Kpriv_ | – | – | – | |
+| _Vpriv_ | – | – | _Vpriv_ | |
+| _Kpub = GKpriv_ | _Kpub_ | _Kpub_ | _Kpub_ | |
+| _Vpub = GVpriv_ | _Vpub_ | _Vpub_ | _Vpub_ | |
+| – | – | _Rpriv_ | – | |
+| _Rpub_ | _Rpub_ | _Rpub = GRpriv_ | _Rpub_ | |
+| _S = RpubVpriv = GRprivVpriv_ | – | _S = RprivVpub = GRprivVpriv_ | _S = _RpubVpriv_ = GRprivVpriv_ | |
+| _Ppub = Kpub+G\*hash(S)_ | – | _Ppub = Kpub+G\*hash(S)_ | _Ppub = Kpub+G\*hash(S)_ | |
+| _Address=f(Ppub)_ | – | _Address=f(Ppub)_ | _Address=f(Ppub)_ | _Address=f(Ppub)_ |
+| _Ppriv = Kpriv+hash(S)_ | – | – | – | |
+
+## Wenn bei Stealth-Adressen etwas schief geht {#go-wrong}
+
+_Es gibt keine Geheimnisse auf der Blockchain_. Obwohl Stealth-Adressen Ihnen Privatsphäre bieten können, ist diese Privatsphäre anfällig für Verkehrsanalyse. Um ein triviales Beispiel zu nennen: Stellen Sie sich vor, Bill finanziert eine Adresse und sendet sofort eine Transaktion, um einen _Rpub_-Wert zu veröffentlichen. Ohne Alices _Vpriv_ können wir nicht sicher sein, dass dies eine Stealth-Adresse ist, aber es ist die wahrscheinlichste Annahme. Dann sehen wir eine weitere Transaktion, die alle ETH von dieser Adresse auf die Adresse des Kampagnenfonds von Alice überträgt. Wir können es vielleicht nicht beweisen, aber es ist wahrscheinlich, dass Bill gerade an Alices Kampagne gespendet hat. Carol würde das sicher auch denken.
+
+Es ist einfach für Bill, die Veröffentlichung von _Rpub_ von der Finanzierung der Stealth-Adresse zu trennen (indem er sie zu verschiedenen Zeiten und von verschiedenen Adressen aus durchführt). Das ist jedoch nicht ausreichend. Das Muster, nach dem Carol sucht, ist, dass Bill eine Adresse finanziert und dann der Kampagnenfonds von Alice von ihr abhebt.
+
+Eine Lösung ist, dass Alices Kampagne das Geld nicht direkt abhebt, sondern es verwendet, um einen Dritten zu bezahlen. Wenn Alices Kampagne 10 ETH an Daves World Domination Campaign Services sendet, weiß Carol nur, dass Bill an einen von Daves Kunden gespendet hat. Wenn Dave genügend Kunden hat, könnte Carol nicht wissen, ob Bill an Alice gespendet hat, die mit ihr konkurriert, oder an Adam, Albert oder Abigail, die Carol egal sind. Alice kann der Zahlung einen gehashten Wert beifügen und Dave dann das Urbild zur Verfügung stellen, um zu beweisen, dass es ihre Spende war. Alternativ, wie oben erwähnt, wenn Alice Dave ihr _Vpriv_ gibt, weiß er bereits, von wem die Zahlung kam.
+
+Das Hauptproblem bei dieser Lösung ist, dass Alice sich um die Geheimhaltung kümmern muss, wenn diese Geheimhaltung Bill zugutekommt. Alice möchte vielleicht ihren Ruf wahren, damit auch Bills Freund Bob an sie spendet. Aber es ist auch möglich, dass es ihr nichts ausmachen würde, Bill zu entlarven, denn dann hätte er Angst davor, was passieren wird, wenn Carol gewinnt. Bill könnte Alice am Ende sogar noch mehr Unterstützung gewähren.
+
+### Verwendung mehrerer Stealth-Ebenen {#multi-layer}
+
+Anstatt sich darauf zu verlassen, dass Alice Bills Privatsphäre schützt, kann Bill dies selbst tun. Er kann mehrere Meta-Adressen für fiktive Personen, Bob und Bella, generieren. Bill sendet dann ETH an Bob, und "Bob" (der eigentlich Bill ist) sendet sie an Bella. "Bella" (ebenfalls Bill) sendet es an Alice.
+
+Carol kann immer noch eine Verkehrsanalyse durchführen und die Pipeline von Bill zu Bob zu Bella zu Alice sehen. Wenn "Bob" und "Bella" ETH jedoch auch für andere Zwecke verwenden, wird es nicht so aussehen, als hätte Bill etwas an Alice überwiesen, selbst wenn Alice sofort von der Stealth-Adresse auf ihre bekannte Kampagnenadresse abhebt.
+
+## Schreiben einer Stealth-Adressen-Anwendung {#write-app}
+
+Dieser Artikel erklärt eine Stealth-Adressen-Anwendung, die [auf GitHub verfügbar ist](https://github.com/qbzzt/251022-stealth-addresses.git).
+
+### Werkzeuge {#tools}
+
+Es gibt [eine TypeScript Stealth-Adressen-Bibliothek](https://github.com/ScopeLift/stealth-address-sdk), die wir verwenden könnten. Kryptographische Operationen können jedoch CPU-intensiv sein. Ich bevorzuge es, sie in einer kompilierten Sprache wie [Rust](https://rust-lang.org/) zu implementieren und [WASM](https://webassembly.org/) zu verwenden, um den Code im Browser auszuführen.
+
+Wir werden [Vite](https://vite.dev/) und [React](https://react.dev/) verwenden. Dies sind branchenübliche Werkzeuge; wenn Sie mit ihnen nicht vertraut sind, können Sie [dieses Tutorial](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/) verwenden. Um Vite zu verwenden, benötigen wir Node.
+
+### Stealth-Adressen in Aktion sehen {#in-action}
+
+1. Installieren Sie die notwendigen Werkzeuge: [Rust](https://rust-lang.org/tools/install/) und [Node](https://nodejs.org/en/download).
+
+2. Klonen Sie das GitHub-Repository.
+
+ ```sh
+ git clone https://github.com/qbzzt/251022-stealth-addresses.git
+ cd 251022-stealth-addresses
+ ```
+
+3. Installieren Sie die Voraussetzungen und kompilieren Sie den Rust-Code.
+
+ ```sh
+ cd src/rust-wasm
+ rustup target add wasm32-unknown-unknown
+ cargo install wasm-pack
+ wasm-pack build --target web
+ ```
+
+4. Starten Sie den Webserver.
+
+ ```sh
+ cd ../..
+ npm install
+ npm run dev
+ ```
+
+5. Rufen Sie [die Anwendung](http://localhost:5173/) auf. Diese Anwendungsseite hat zwei Frames: einen für Alices Benutzeroberfläche und den anderen für die von Bill. Die beiden Frames kommunizieren nicht; sie befinden sich nur aus praktischen Gründen auf derselben Seite.
+
+6. Klicken Sie als Alice auf **Eine Stealth-Meta-Adresse generieren**. Dadurch werden die neue Stealth-Adresse und die entsprechenden privaten Schlüssel angezeigt. Kopieren Sie die Stealth-Meta-Adresse in die Zwischenablage.
+
+7. Fügen Sie als Bill die neue Stealth-Meta-Adresse ein und klicken Sie auf **Eine Adresse generieren**. Dies gibt Ihnen die Adresse, die Sie für Alice finanzieren sollen.
+
+8. Kopieren Sie die Adresse und Bills öffentlichen Schlüssel und fügen Sie sie in den Bereich "Privater Schlüssel für von Bill generierte Adresse" in Alices Benutzeroberfläche ein. Sobald diese Felder ausgefüllt sind, sehen Sie den privaten Schlüssel für den Zugriff auf Vermögenswerte unter dieser Adresse.
+
+9. Sie können [einen Online-Rechner](https://iancoleman.net/ethereum-private-key-to-address/) verwenden, um sicherzustellen, dass der private Schlüssel mit der Adresse übereinstimmt.
+
+### Wie das Programm funktioniert {#how-the-program-works}
+
+#### Die WASM-Komponente {#wasm}
+
+Der Quellcode, der zu WASM kompiliert wird, ist in [Rust](https://rust-lang.org/) geschrieben. Sie können es in [`src/rust_wasm/src/lib.rs`](https://github.com/qbzzt/251022-stealth-addresses/blob/main/src/rust-wasm/src/lib.rs) sehen. Dieser Code ist in erster Linie eine Schnittstelle zwischen dem JavaScript-Code und [der `eth-stealth-addresses`-Bibliothek](https://github.com/kassandraoftroy/eth-stealth-addresses).
+
+**`Cargo.toml`**
+
+[`Cargo.toml`](https://doc.rust-lang.org/cargo/reference/manifest.html) in Rust ist analog zu [`package.json`](https://docs.npmjs.com/cli/v9/configuring-npm/package-json) in JavaScript. Es enthält Paketinformationen, Abhängigkeitsdeklarationen usw.
+
+```toml
+[package]
+name = "rust-wasm"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+eth-stealth-addresses = "0.1.0"
+hex = "0.4.3"
+wasm-bindgen = "0.2.104"
+getrandom = { version = "0.2", features = ["js"] }
+```
+
+Das [`getrandom`](https://docs.rs/getrandom/latest/getrandom/)-Paket muss Zufallswerte generieren. Dies kann nicht durch rein algorithmische Mittel geschehen; es erfordert den Zugriff auf einen physikalischen Prozess als Quelle der Entropie. Diese Definition legt fest, dass wir diese Entropie erhalten, indem wir den Browser abfragen, in dem wir laufen.
+
+```toml
+console_error_panic_hook = "0.1.7"
+```
+
+[Diese Bibliothek](https://docs.rs/console_error_panic_hook/latest/console_error_panic_hook/) gibt uns aussagekräftigere Fehlermeldungen, wenn der WASM-Code in Panik gerät und nicht fortfahren kann.
+
+```toml
+[lib]
+crate-type = ["cdylib", "rlib"]
+```
+
+Der Ausgabetyp, der zur Erzeugung von WASM-Code erforderlich ist.
+
+**`lib.rs`**
+
+Das ist der eigentliche Rust-Code.
+
+```rust
+use wasm_bindgen::prelude::*;
+```
+
+Die Definitionen zum Erstellen eines WASM-Pakets aus Rust. Sie sind [hier](https://wasm-bindgen.github.io/wasm-bindgen/reference/attributes/index.html) dokumentiert.
+
+```rust
+use eth_stealth_addresses::{
+ generate_stealth_meta_address,
+ generate_stealth_address,
+ compute_stealth_key
+};
+```
+
+Die Funktionen, die wir aus [der `eth-stealth-addresses`-Bibliothek](https://github.com/kassandraoftroy/eth-stealth-addresses) benötigen.
+
+```rust
+use hex::{decode,encode};
+```
+
+Rust verwendet normalerweise Byte-[Arrays](https://doc.rust-lang.org/std/primitive.array.html) (`[u8; ]`) für Werte. Aber in JavaScript verwenden wir normalerweise hexadezimale Zeichenketten. [Die `hex`-Bibliothek](https://docs.rs/hex/latest/hex/) übersetzt für uns von einer Darstellung in die andere.
+
+```rust
+#[wasm_bindgen]
+```
+
+Generieren Sie WASM-Bindungen, um diese Funktion von JavaScript aus aufrufen zu können.
+
+```rust
+pub fn wasm_generate_stealth_meta_address() -> String {
+```
+
+Der einfachste Weg, ein Objekt mit mehreren Feldern zurückzugeben, ist die Rückgabe einer JSON-Zeichenkette.
+
+```rust
+ let (address, spend_private_key, view_private_key) =
+ generate_stealth_meta_address();
+```
+
+Die [`generate_stealth_meta_address`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.generate_stealth_meta_address.html) gibt drei Felder zurück:
+
+- Die Meta-Adresse (_Kpub_ und _Vpub_)
+- Der private Ansichtsschlüssel (_Vpriv_)
+- Der private Ausgabenschlüssel (_Kpriv_)
+
+Die [Tupel](https://doc.rust-lang.org/std/primitive.tuple.html)-Syntax lässt uns diese Werte wieder trennen.
+
+```rust
+ format!("{{\"address\":\"{}\",\"view_private_key\":\"{}\",\"spend_private_key\":\"{}\"}}",
+ encode(address),
+ encode(view_private_key),
+ encode(spend_private_key)
+ )
+}
+```
+
+Verwenden Sie das [`format!`](https://doc.rust-lang.org/std/fmt/index.html)-Makro, um die JSON-kodierte Zeichenkette zu generieren. Verwenden Sie [`hex::encode`](https://docs.rs/hex/latest/hex/fn.encode.html), um die Arrays in Hex-Strings zu ändern.
+
+```rust
+fn str_to_array(s: &str) -> Option<[u8; N]> {
+```
+
+Diese Funktion wandelt eine Hex-Zeichenkette (von JavaScript bereitgestellt) in ein Byte-Array um. Wir verwenden sie, um Werte zu parsen, die vom JavaScript-Code bereitgestellt werden. Diese Funktion ist kompliziert, weil Rust mit Arrays und Vektoren umgeht.
+
+Der Ausdruck `` wird als [Generic](https://doc.rust-lang.org/book/ch10-01-syntax.html) bezeichnet. `N` ist ein Parameter, der die Länge des zurückgegebenen Arrays steuert. Die Funktion wird eigentlich `str_to_array::` genannt, wobei `n` die Array-Länge ist.
+
+Der Rückgabewert ist `Option<[u8; N]>`, was bedeutet, dass das zurückgegebene Array [optional](https://doc.rust-lang.org/std/option/) ist. Dies ist ein typisches Muster in Rust für Funktionen, die fehlschlagen können.
+
+Wenn wir zum Beispiel `str_to_array::10("bad060a7")` aufrufen, soll die Funktion ein Array mit zehn Werten zurückgeben, aber die Eingabe besteht nur aus vier Bytes. Die Funktion muss fehlschlagen, und das tut sie, indem sie `None` zurückgibt. Der Rückgabewert für `str_to_array::4("bad060a7")` wäre `Some<[0xba, 0xd0, 0x60, 0xa7]>`.
+
+```rust
+ // decode returns Result, _>
+ let vec = decode(s).ok()?;
+```
+
+Die [`hex::decode`](https://docs.rs/hex/latest/hex/fn.decode.html)-Funktion gibt ein `Result, FromHexError>` zurück. Der Typ [`Result`](https://doc.rust-lang.org/std/result/) kann entweder ein erfolgreiches Ergebnis (`Ok(value)`) oder einen Fehler (`Err(error)`) enthalten.
+
+Die `.ok()`-Methode wandelt das `Result` in eine `Option` um, deren Wert entweder der `Ok()`-Wert ist, wenn erfolgreich, oder `None`, wenn nicht. Schließlich bricht der [Fragezeichen-Operator](https://doc.rust-lang.org/std/option/#the-question-mark-operator-) die aktuelle Funktion ab und gibt ein `None` zurück, wenn die `Option` leer ist. Andernfalls entpackt er den Wert und gibt diesen zurück (in diesem Fall, um `vec` einen Wert zuzuweisen).
+
+Dies sieht nach einer seltsam verschlungenen Methode zur Fehlerbehandlung aus, aber `Result` und `Option` stellen sicher, dass alle Fehler auf die eine oder andere Weise behandelt werden.
+
+```rust
+ if vec.len() != N { return None; }
+```
+
+Wenn die Anzahl der Bytes falsch ist, ist das ein Fehler, und wir geben `None` zurück.
+
+```rust
+ // try_into consumes vec and attempts to make [u8; N]
+ let array: [u8; N] = vec.try_into().ok()?;
+```
+
+Rust hat zwei Array-Typen. [Arrays](https://doc.rust-lang.org/std/primitive.array.html) haben eine feste Größe. [Vektoren](https://doc.rust-lang.org/std/vec/index.html) können wachsen und schrumpfen. `hex::decode` gibt einen Vektor zurück, aber die `eth_stealth_addresses`-Bibliothek möchte Arrays empfangen. [`.try_into()`](https://doc.rust-lang.org/std/convert/trait.TryInto.html#required-methods) konvertiert einen Wert in einen anderen Typ, zum Beispiel einen Vektor in ein Array.
+
+```rust
+ Some(array)
+}
+```
+
+Rust erfordert nicht, dass Sie das Schlüsselwort [`return`](https://doc.rust-lang.org/std/keyword.return.html) verwenden, wenn Sie am Ende einer Funktion einen Wert zurückgeben.
+
+```rust
+#[wasm_bindgen]
+pub fn wasm_generate_stealth_address(stealth_address: &str) -> Option {
+```
+
+Diese Funktion empfängt eine öffentliche Meta-Adresse, die sowohl _Vpub_ als auch _Kpub_ enthält. Sie gibt die Stealth-Adresse, den zu veröffentlichenden öffentlichen Schlüssel (_Rpub_) und einen Ein-Byte-Scan-Wert zurück, der die Identifizierung beschleunigt, welche veröffentlichten Adressen Alice gehören könnten.
+
+Der Scan-Wert ist Teil des gemeinsamen Geheimnisses (_S = GRprivVpriv_). Dieser Wert steht Alice zur Verfügung, und seine Überprüfung ist viel schneller als die Überprüfung, ob _f(Kpub+G\*hash(S))_ mit der veröffentlichten Adresse übereinstimmt.
+
+```rust
+ let (address, r_pub, scan) =
+ generate_stealth_address(&str_to_array::<66>(stealth_address)?);
+```
+
+Wir verwenden [`generate_stealth_address`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.generate_stealth_address.html) der Bibliothek.
+
+```rust
+ format!("{{\"address\":\"{}\",\"rPub\":\"{}\",\"scan\":\"{}\"}}",
+ encode(address),
+ encode(r_pub),
+ encode(&[scan])
+ ).into()
+}
+```
+
+Bereiten Sie die JSON-kodierte Ausgabezeichenkette vor.
+
+```rust
+#[wasm_bindgen]
+pub fn wasm_compute_stealth_key(
+ address: &str,
+ bill_pub_key: &str,
+ view_private_key: &str,
+ spend_private_key: &str
+) -> Option {
+ .
+ .
+ .
+}
+```
+
+Diese Funktion verwendet die [`compute_stealth_key`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.compute_stealth_key.html)-Funktion der Bibliothek, um den privaten Schlüssel zum Abheben von der Adresse (_Rpriv_) zu berechnen. Diese Berechnung erfordert diese Werte:
+
+- Die Adresse (_Address=f(Ppub)_)
+- Der von Bill generierte öffentliche Schlüssel (_Rpub_)
+- Der private Ansichtsschlüssel (_Vpriv_)
+- Der private Ausgabenschlüssel (_Kpriv_)
+
+```rust
+#[wasm_bindgen(start)]
+```
+
+[`#[wasm_bindgen(start)]`](https://wasm-bindgen.github.io/wasm-bindgen/reference/attributes/on-rust-exports/start.html) legt fest, dass die Funktion ausgeführt wird, wenn der WASM-Code initialisiert wird.
+
+```rust
+pub fn main() {
+ console_error_panic_hook::set_once();
+}
+```
+
+Dieser Code legt fest, dass die Panikausgabe an die JavaScript-Konsole gesendet wird. Um es in Aktion zu sehen, verwenden Sie die Anwendung und geben Sie Bill eine ungültige Meta-Adresse (ändern Sie einfach eine hexadezimale Ziffer). Sie werden diesen Fehler in der JavaScript-Konsole sehen:
+
+```
+rust_wasm.js:236 panicked at /home/ori/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/subtle-2.6.1/src/lib.rs:701:9:
+assertion `left == right` failed
+ left: 0
+ right: 1
+```
+
+Gefolgt von einem Stack-Trace. Geben Sie Bill dann die gültige Meta-Adresse und Alice entweder eine ungültige Adresse oder einen ungültigen öffentlichen Schlüssel. Sie werden diesen Fehler sehen:
+
+```
+rust_wasm.js:236 panicked at /home/ori/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/eth-stealth-addresses-0.1.0/src/lib.rs:78:9:
+keys do not generate stealth address
+```
+
+Wiederum gefolgt von einem Stack-Trace.
+
+#### Die Benutzeroberfläche {#ui}
+
+Die Benutzeroberfläche ist mit [React](https://react.dev/) geschrieben und wird von [Vite](https://vite.dev/) bereitgestellt. Sie können sich mit [diesem Tutorial](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/) darüber informieren. Es besteht hier keine Notwendigkeit für [WAGMI](https://wagmi.sh/), da wir nicht direkt mit einer Blockchain oder einer Wallet interagieren.
+
+Der einzige nicht offensichtliche Teil der Benutzeroberfläche ist die WASM-Konnektivität. So funktioniert es.
+
+**`vite.config.js`**
+
+Diese Datei enthält [die Vite-Konfiguration](https://vite.dev/config/).
+
+```js
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import wasm from "vite-plugin-wasm";
+
+// https://vite.dev/config/
+export default defineConfig({
+ plugins: [react(), wasm()],
+})
+```
+
+Wir benötigen zwei Vite-Plugins: [react](https://www.npmjs.com/package/@vitejs/plugin-react) und [wasm](https://github.com/Menci/vite-plugin-wasm#readme).
+
+**`App.jsx`**
+
+Diese Datei ist die Hauptkomponente der Anwendung. Es ist ein Container, der zwei Komponenten enthält: `Alice` und `Bill`, die Benutzeroberflächen für diese Benutzer. Der für WASM relevante Teil ist der Initialisierungscode.
+
+```jsx
+import init from './rust-wasm/pkg/rust_wasm.js'
+```
+
+Wenn wir [`wasm-pack`](https://rustwasm.github.io/docs/wasm-pack/) verwenden, erstellt es zwei Dateien, die wir hier verwenden: eine wasm-Datei mit dem eigentlichen Code (hier `src/rust-wasm/pkg/rust_wasm_bg.wasm`) und eine JavaScript-Datei mit den Definitionen zur Verwendung (hier `src/rust_wasm/pkg/rust_wasm.js`). Der Standardexport dieser JavaScript-Datei ist Code, der zur Initiierung von WASM ausgeführt werden muss.
+
+```jsx
+function App() {
+ .
+ .
+ .
+ useEffect(() => {
+ const loadWasm = async () => {
+ try {
+ await init();
+ setWasmReady(true)
+ } catch (err) {
+ console.error('Error loading wasm:', err)
+ alert("Wasm error: " + err)
+ }
+ }
+
+ loadWasm()
+ }, []
+ )
+```
+
+Der [`useEffect`-Hook](https://react.dev/reference/react/useEffect) ermöglicht es Ihnen, eine Funktion anzugeben, die ausgeführt wird, wenn sich Zustandsvariablen ändern. Hier ist die Liste der Zustandsvariablen leer (`[]`), sodass diese Funktion nur einmal ausgeführt wird, wenn die Seite geladen wird.
+
+Die Effektfunktion muss sofort zurückkehren. Um asynchronen Code wie das WASM-`init` zu verwenden (das die `.wasm`-Datei laden muss und daher Zeit benötigt), definieren wir eine interne [`async`](https://en.wikipedia.org/wiki/Async/await)-Funktion und führen sie ohne `await` aus.
+
+**`Bill.jsx`**
+
+Dies ist die Benutzeroberfläche für Bill. Es hat eine einzige Aktion, das Erstellen einer Adresse basierend auf der von Alice bereitgestellten Stealth-Meta-Adresse.
+
+```jsx
+import { wasm_generate_stealth_address } from './rust-wasm/pkg/rust_wasm.js'
+```
+
+Zusätzlich zum Standardexport exportiert der von `wasm-pack` generierte JavaScript-Code eine Funktion für jede Funktion im WASM-Code.
+
+```jsx
+
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
+title="ETH issuance tldr">
-- Vor der Umstellung auf Proof-of-Stake erhielten Miner etwa 13.000 ETH/Tag
-- Staker erhalten etwa 1.700 ETH/Tag, basierend auf etwa 14 Millionen insgesamt gestakten ETH
-- Die genaue Staking-Ausgabe schwankt je nach der Gesamtmenge an gestakten ETH
-- Seit The Merge bleibt nur noch die ~1.700 ETH/Tag, wodurch die gesamte neue ETH-Ausgabe um ~88% gesunken ist
-- Das Verbrennen: Dies schwankt je nach Netzwerkanforderung. _Wenn_ für einen bestimmten Tag ein durchschnittlicher Gaspreis von mindestens 16 Gwei beobachtet wird, kompensiert dies effektiv die ~1.700 ETH, die an die Validatoren ausgegeben werden, und bringt die Netto-ETH-Inflation für diesen Tag auf Null oder weniger.
+- Vor dem Übergang zu Proof-of-Stake betrug die Emission für Miner ungefähr 13.000 ETH/Tag.
+- Die Emission für Staker beträgt ungefähr 1.700 ETH/Tag, basierend auf insgesamt etwa 14 Millionen gestaketen ETH.
+- Die genaue Staking-Emission schwankt je nach der Gesamtmenge der gestaketen ETH.
+- **Seit The Merge verbleiben nur noch die ~1.700 ETH/Tag, wodurch die gesamte neue ETH-Emission um ~88 % sinkt.**
+- Die Verbrennung: Diese schwankt je nach Netzwerknachfrage. _Wenn_ für einen bestimmten Tag ein durchschnittlicher Gaspreis von mindestens 16 Gwei beobachtet wird, kompensiert dies effektiv die ~1.700 ETH, die an die Validatoren ausgegeben werden, und bringt die Netto-ETH-Inflation für diesen Tag auf Null oder weniger.
## Vor dem Merge (historisch) {#pre-merge}
-### Ausgabe auf der Ausführungsschicht {#el-issuance-pre-merge}
+### Emission der Ausführungsebene {#el-issuance-pre-merge}
-Unter dem Proof-of-Work-System interagierten die Miner nur mit der Ausführungsschicht und wurden mit Blockbelohnungen belohnt, wenn sie die ersten Miner waren, die den nächsten Block gelöst haben. Seit dem [Constantinople-Upgrade](/ethereum-forks/#constantinople) im Jahr 2019 betrug diese Belohnung 2 ETH pro Block. Miner wurden auch für die Veröffentlichung von [Ommer-Blöcken](/glossary/#ommer) belohnt, das waren gültige Blöcke, die nicht in der längsten/kanonischen Kette landeten. Diese Belohnungen erreichten maximal 1,75 ETH pro Ommer und wurden zusätzlich zu der Belohnung aus dem kanonischen Block ausgegeben. Das Mining war eine wirtschaftlich intensive Tätigkeit, die historisch gesehen ein hohes Niveau an ETH-Ausgabe erforderte, um sie aufrechtzuerhalten.
+Unter dem Proof-of-Work-System interagierten die Miner nur mit der Ausführungsschicht und wurden mit Blockbelohnungen belohnt, wenn sie die ersten Miner waren, die den nächsten Block gelöst haben. Seit dem [Constantinople-Upgrade](/ethereum-forks/#constantinople) im Jahr 2019 betrug diese Belohnung 2 ETH pro Block. Miner wurden auch für die Veröffentlichung von [ommer](/glossary/#ommer)-Blöcken belohnt, das waren gültige Blöcke, die nicht in der längsten/kanonischen Kette landeten. Diese Belohnungen betrugen maximal 1,75 ETH pro Ommer und wurden _zusätzlich zu_ der Belohnung aus dem kanonischen Block emittiert. Das Mining war eine wirtschaftlich intensive Tätigkeit, die historisch gesehen ein hohes Niveau an ETH-Ausgabe erforderte, um sie aufrechtzuerhalten.
-### Ausgabe der Konsensschicht {#cl-issuance-pre-merge}
+### Emission der Konsensebene {#cl-issuance-pre-merge}
-Die [Beacon Chain](/ethereum-forks/#beacon-chain-genesis) wurde 2020 gestartet. Anstelle von Minern wird sie durch Validatoren mittels Proof-of-Stake gesichert. Diese Kette wurde initiiert, indem Ethereum-Nutzer ETH in einen Smart Contract auf dem Mainnet (der Ausführungsschicht) einzahlten. Die Beacon Chain reagiert darauf und schreibt den Nutzern eine entsprechende Menge ETH auf der neuen Kette gut. Bis zur Durchführung von The Merge verarbeiteten die Validatoren der Beacon Chain keine Transaktionen und kamen im Wesentlichen zu einem Konsens über den Zustand des Validator-Pools selbst.
+Die [Beacon Chain](/ethereum-forks/#beacon-chain-genesis) ging 2020 live. Anstelle von Minern wird sie durch Validatoren mittels Proof-of-Stake gesichert. Diese Kette wurde initiiert, indem Ethereum-Nutzer ETH in einen Smart Contract auf dem Mainnet (der Ausführungsschicht) einzahlten. Die Beacon Chain reagiert darauf und schreibt den Nutzern eine entsprechende Menge ETH auf der neuen Kette gut. Bis zur Durchführung von The Merge verarbeiteten die Validatoren der Beacon Chain keine Transaktionen und kamen im Wesentlichen zu einem Konsens über den Zustand des Validator-Pools selbst.
-Validatoren auf der Beacon Chain werden mit ETH belohnt, wenn sie den Zustand der Kette bestätigen und Blöcke vorschlagen. Belohnungen (oder Strafen) werden bei jedem Zeitalter (alle 6,4 Minuten) basierend auf der Leistung der Validatoren berechnet und verteilt. Die Belohnungen für Validatoren sind erheblich geringer als die zuvor unter dem Proof-of-Work-Verfahren ausgeschütteten Mining-Belohnungen (2 ETH alle etwa 13,5 Sekunden), da der Betrieb eines Validierungsknotens nicht so wirtschaftlich intensiv ist und daher keine so hohe Belohnung erfordert oder rechtfertigt.
+Validatoren auf der Beacon Chain werden mit ETH belohnt, wenn sie den Zustand der Kette bestätigen und Blöcke vorschlagen. Belohnungen (oder Strafen) werden bei jedem Zeitalter (alle 6,4 Minuten) basierend auf der Leistung der Validatoren berechnet und verteilt. Die Belohnungen für Validatoren sind **deutlich** geringer als die Mining-Belohnungen, die zuvor unter Proof-of-Work emittiert wurden (2 ETH alle ~13,5 Sekunden), da der Betrieb eines Validierungsknotens wirtschaftlich nicht so intensiv ist und daher keine so hohe Belohnung erfordert oder rechtfertigt.
-### Die Verteilung der Ausgabe vor dem Merge lässt sich wie folgt darstellen: {#pre-merge-issuance-breakdown}
+### Aufschlüsselung der Emissionen vor dem Merge {#pre-merge-issuance-breakdown}
-Gesamt ETH Angebot: **~120,520,000 ETH** (zum Zeitpunkt von The Merge im September 2022)
+Gesamtes ETH-Angebot: **~120.520.000 ETH** (zum Zeitpunkt von The Merge im September 2022)
-**Ausgabe in der Ausführungsschicht:**
+**Ausgabe der Ausführungs-Ebene:**
-- Wurde auf 2,08 ETH pro 13,3 Sekunden* geschätzt: **~4,930,000** ETH wurden in einem Jahr ausgegeben
-- Führte zu einer Inflationsrate von **etwa 4.09%** (4,93 Mio. pro Jahr / 120,5 Mio. Gesamt)
-- \*Dies beinhaltet die 2 ETH pro kanonischem Block, plus durchschnittlich 0,08 ETH über die Zeit von Ommer-Blöcken. Es verwendet auch 13,3 Sekunden, die Zielzeit für den Baseline-Block ohne jeglichen Einfluss durch eine ["Difficulty Bomb"](/glossary/#difficulty-bomb). ([Siehe Quelle](https://bitinfocharts.com/ethereum/))
+- Wurde auf 2,08 ETH pro 13,3 Sekunden\* geschätzt: **~4.930.000** ETH pro Jahr emittiert
+- Ergab eine Inflationsrate von **ungefähr 4,09 %** (4,93 Mio. pro Jahr / 120,5 Mio. gesamt)
+- \*Dies beinhaltet die 2 ETH pro kanonischem Block, plus durchschnittlich 0,08 ETH über die Zeit von Ommer-Blöcken. Verwendet ebenfalls 13,3 Sekunden, die angestrebte Basis-Blockzeit ohne jeglichen Einfluss durch eine [Difficulty Bomb](/glossary/#difficulty-bomb). ([Quelle ansehen](https://bitinfocharts.com/ethereum/))
**Konsensschicht-Ausgabe:**
-- Bei insgesamt 14.000.000 gestakten ETH beträgt die Rate der ETH-Ausgabe etwa 1700 ETH/Tag ([Quelle siehe hier](https://ultrasound.money/))
-- Ergibt **~620,500** ETH herausgegeben in einem Jahr
-- Daraus ergibt sich eine Inflationsrate von **ungefähr 0.52%** (620.5K pro Jahr / 119.3M insgesamt)
+- Bei insgesamt 14.000.000 gestaketen ETH beträgt die ETH-Emissionsrate ungefähr 1700 ETH/Tag ([Quelle ansehen](https://ultrasound.money/))
+- Ergibt **~620.500** ETH, die pro Jahr emittiert werden
+- Ergab eine Inflationsrate von **ungefähr 0,52 %** (620,5 Tsd. pro Jahr / 119,3 Mio. gesamt)
-**Jährlicher Gesamtausgabesatz (Pre-Merge): ~4.61%** (4.09% + 0.52%)
+**Gesamte annualisierte Emissionsrate (vor dem Merge): ~4,61 %** (4,09 % + 0,52 %)
-**~88.7%** der Ausgabe ging an die Miner auf der Ausführungs-Ebene (4.09 / 4.61 * 100)
+**~88,7 %** der Emission ging an Miner auf der Ausführungsebene (4,09 / 4,61 \* 100)
-**~11.3%** wurde an Staker auf der Konsensus-Ebene ausgegeben (0.52 / 4.61 * 100)
-
-
-
+**~11,3 %** wurden an Staker auf der Konsensebene emittiert (0,52 / 4,61 \* 100)
-## Post-Merge (Gegenwart) {#post-merge}
+## Nach dem Merge (heute) {#post-merge}
-### Ausgabe auf der Ausführungsschicht {#el-issuance-post-merge}
+### Emission der Ausführungsebene {#el-issuance-post-merge}
-Ausgabe auf der Ausführungs-Ebene seit dem Merge ist Null. Proof-of-Work ist nach den verbesserten KonsensusRegeln kein gültiges Mittel zur Blockproduktion mehr. Alle Aktivitäten der Ausführungsebene werden in "Beacon-Blöcke" verpackt, die veröffentlicht und von Proof-of-Stake-Validatoren bestätigt werden. Belohnungen für die Bescheinigung und Veröffentlichung von Beacon-Blöcken werden auf der Konsensus-Ebene separat berücksichtigt.
+Die Emission der Ausführungsebene seit The Merge ist null. Proof-of-Work ist nach den aktualisierten Konsensregeln kein gültiges Mittel zur Blockproduktion mehr. Alle Aktivitäten der Ausführungsebene werden in „Beacon-Blöcke“ verpackt, die von Proof-of-Stake-Validatoren veröffentlicht und bezeugt werden. Belohnungen für das Bezeugen und Veröffentlichen von Beacon-Blöcken werden auf der Konsensebene separat verbucht.
-### Ausgabe der Konsensschicht {#cl-issuance-post-merge}
+### Emission der Konsensebene {#cl-issuance-post-merge}
-Die Ausgabe der Konsensus-Ebene wird heute wie vor dem Merge fortgesetzt, mit kleinen Belohnungen für Validatoren, die Blöcke bestätigen und vorschlagen. Validatoren-Belohnungen fließen weiterhin in _Validatoren-Guthaben_ ein, die innerhalb der Konsensus-Ebene verwaltet werden. Im Gegensatz zu den laufenden Konten ("Ausführungskonten"), die im Mainnet Transaktionen durchführen können, sind diese separaten Ethereum-Konten nicht in der Lage, frei mit anderen Ethereum-Konten zu handeln. Die Gelder auf diesen Konten können nur an eine einzige angegebene Ausführungsadresse abgehoben werden.
+Die Emission der Konsensebene wird heute wie vor The Merge fortgesetzt, mit kleinen Belohnungen für Validatoren, die Blöcke bezeugen und vorschlagen. Validatoren-Belohnungen fließen weiterhin in _Validatoren-Guthaben_, die innerhalb der Konsensebene verwaltet werden. Im Gegensatz zu den aktuellen Konten („Ausführungskonten“), mit denen auf dem Mainnet Transaktionen durchgeführt werden können, können diese separaten Ethereum-Konten keine freien Transaktionen mit anderen Ethereum-Konten durchführen. Die Gelder auf diesen Konten können nur an eine einzige angegebene Ausführungsadresse abgehoben werden.
-Seit des Shanghai/Capella Upgrades im April 2023 sind diese Rücknahmen für Staker möglich. Für Staker besteht ein Anreiz, ihre _Gewinne/Belohnungen (Guthaben über 32 ETH)_ zu entfernen, da diese Gelder ansonsten nicht zu ihren Einsätzen (die maximal 32 beträgt) beitragen.
+Seit dem Shanghai/Capella-Upgrade, das im April 2023 stattfand, sind diese Abhebungen für Staker möglich. Staker haben einen Anreiz, ihre _Erträge/Belohnungen (Guthaben über 32 ETH)_ abzuheben, da diese Gelder andernfalls nicht zu ihrer Stake-Gewichtung beitragen (die bei 32 gedeckelt ist).
Die Staker können sich auch dafür entscheiden, auszusteigen und ihr gesamtes Validatoren-Guthaben abzuheben. Um die Stabilität von Ethereum zu gewährleisten, ist die Anzahl der gleichzeitig ausscheidenden Validatoren begrenzt.
-Etwa 0,33 % der Gesamtzahl der Validatoren können an einem bestimmten Tag ausscheiden. Standardmäßig können vier (4) Validatoren pro Epoche aussteigen (alle 6,4 Minuten oder 900 pro Tag). Ein weiterer (1) Validator darf für jeden 65,536 (216) zusätzlichen Validator über 262,144 (218) aussteigen. Bei über 327.680 Validatoren können zum Beispiel fünf (5) pro Epoche (1.125 pro Tag) ausscheiden. Sechs (6) werden zugelassen, wenn die Gesamtzahl der aktiven Validatoren 393.216 übersteigt, und so weiter.
+Ungefähr 0,33 % der Gesamtzahl der Validatoren können an einem bestimmten Tag aussteigen. Standardmäßig können vier (4) Validatoren pro Epoche (alle 6,4 Minuten oder 900 pro Tag) aussteigen. Ein zusätzlicher (1) Validator darf pro 65.536 (216) zusätzlicher Validatoren über 262.144 (218) aussteigen. Bei über 327.680 Validatoren können zum Beispiel fünf (5) pro Epoche (1.125 pro Tag) ausscheiden. Sechs (6) werden zugelassen, wenn die Gesamtzahl der aktiven Validatoren 393.216 übersteigt, und so weiter.
-Wenn mehr Validatoren aussteigen, wird die maximale Anzahl der ausscheidenden Validatoren schrittweise auf ein Minimum von vier reduziert, um absichtlich zu verhindern, dass große, destabilisierende Mengen an eingesetztem ETH gleichzeitig abgezogen werden.
+Wenn mehr Validatoren aussteigen, wird die maximale Anzahl der ausscheidenden Validatoren schrittweise auf ein Minimum von vier reduziert, um absichtlich zu verhindern, dass große, destabilisierende Mengen an gestaketem ETH gleichzeitig abgehoben werden.
-### Post-Merge Aufschlüsselung der Inflation {#post-merge-inflation-breakdown}
+### Inflationsaufschlüsselung nach dem Merge {#post-merge-inflation-breakdown}
-- Gesamt ETH Angebot: **~120,520,000 ETH** (zum Zeitpunkt von The Merge im September 2022)
-- Ausgabe der Ausführungs-Ebene: **0**
-- Ausgabe der Konsensus-Ebene: Wie oben beschrieben, **~0.52%** Jährliche Emissionsrate (mit insgesamt 14 Millionen ETH in Staking)
+- Gesamtes ETH-Angebot: **~120.520.000 ETH** (zum Zeitpunkt von The Merge im September 2022)
+- Emission der Ausführungsebene: **0**
+- Emission der Konsensebene: Wie oben, **~0,52 %** annualisierte Emissionsrate (bei 14 Millionen gestaketen ETH insgesamt)
-Jährlicher Gesamtausgabesatz: **~0.52%**
+Gesamte annualisierte Emissionsrate: **~0,52 %**
-Netto-Reduktion der jährlichen ETH-Emissionen: **~88.7%** ((4.61% - 0.52%) / 4.61% * 100)
-
-
-
+Nettorückgang der jährlichen ETH-Emission: **~88,7 %** ((4,61 % - 0,52 %) / 4,61 % \* 100)
-##
-Die Verbrennung von Gebühren wurde mit dem [the London Upgrade](/ethereum-forks/#london) im August 2021 in Betrieb genommen und bleibt seit dem Merge unverändert.
-
-
-
+
+Das Verbrennen von Gebühren wurde mit dem [London-Upgrade](/ethereum-forks/#london) im August 2021 eingeführt und ist seit The Merge unverändert.
Zusätzlich zu den Gebühren, die durch das London Upgrade verbrannt werden, können Validatoren auch mit Strafen belegt werden, wenn sie offline sind, oder schlimmer noch, ihr Stake kann gekürzt werden, wenn sie gegen bestimmte Regeln verstoßen, die die Netzsicherheit gefährden. Diese Strafen führen zu einer Verringerung des ETH-Guthabens dieses Validators, das nicht auf ein anderes Konto überwiesen wird, sondern effektiv verbrannt/aus dem Verkehr gezogen wird.
-### Berechnung des durchschnittlichen Gaspreises bei Deflation {#calculating-average-gas-price-for-deflation}
+### Berechnung des durchschnittlichen Gaspreises für die Deflation {#calculating-average-gas-price-for-deflation}
Wie bereits erwähnt, hängt die Menge der an einem bestimmten Tag ausgegebenen ETH von den insgesamt für Staking eingesetzten ETH ab. Zum Zeitpunkt der Erstellung dieses Artikels sind dies etwa 1700 ETH/Tag.
@@ -124,26 +116,26 @@ Um den durchschnittlichen Gaspreis zu ermitteln, der erforderlich ist, um diese
- `(5 Blöcke/Minute) * (60 Minuten/Stunde) = 300 Blöcke/Stunde`
- `(300 Blöcke/Stunde) * (24 Stunden/Tag) = 7200 Blöcke/Tag`
-Jeder Block zielt darauf ab `15x10^6 Gas/Block` ([mehr zum Thema Gas](/developers/docs/gas/)). Auf diese Weise können wir den durchschnittlichen Gaspreis (in Einheiten von gwei/Gas) ermitteln, der erforderlich ist, um die Ausgabe auszugleichen, wenn die tägliche ETH-Ausgabe insgesamt 1700 ETH beträgt:
+Jeder Block zielt auf `15x10^6 Gas/Block` ab ([mehr zu Gas](/developers/docs/gas/)). Auf diese Weise können wir den durchschnittlichen Gaspreis (in Einheiten von gwei/Gas) ermitteln, der erforderlich ist, um die Ausgabe auszugleichen, wenn die tägliche ETH-Ausgabe insgesamt 1700 ETH beträgt:
-- `7200 Blöcke/Tag * 15x10^6 Gas/Block *`**`Y gwei/gas`**`* 1 ETH/ 10^9 gwei = 1700 ETH/Tag`
+- `7200 Blöcke/Tag * 15x10^6 Gas/Block * `**`Y Gwei/Gas`**` * 1 ETH/ 10^9 Gwei = 1700 ETH/Tag`
Auflösen nach `Y`:
-- `Y = (1700(10^9))/(7200 * 15(10^6)) = (17x10^3)/(72 * 15) = 16 gwei` (Rundung auf nur zwei signifikante Ziffern)
+- `Y = (1700(10^9))/(7200 * 15(10^6)) = (17x10^3)/(72 * 15) = 16 Gwei` (Rundung auf nur zwei signifikante Ziffern)
-Eine andere Möglichkeit, diesen letzten Schritt umzugestalten, wäre die Ersetzung von `1700` mit einer Variablen `X` die die tägliche ETH-Ausgabe darstellt, und den Rest zu vereinfachen:
+Eine andere Möglichkeit, diesen letzten Schritt umzustellen, wäre, `1700` durch eine Variable `X` zu ersetzen, die die tägliche ETH-Emission darstellt, und den Rest zu vereinfachen zu:
- `Y = (X(10^3)/(7200 * 15)) = X/108`
-Wir können dies vereinfachen als eine Funktion von `X`:
+Wir können dies vereinfachen und als eine Funktion von `X` schreiben:
-- `f(X) = X/108` wobei `X` ist die tägliche ETH-Ausgabe, und `f(X)` stellt die Menge an gwei/Gaspreis dar, die erforderlich ist, um alle neu ausgegebenen ETH auszugleichen.
+- `f(X) = X/108`, wobei `X` die tägliche ETH-Emission ist und `f(X)` den Gwei/Gas-Preis darstellt, der erforderlich ist, um alle neu emittierten ETH auszugleichen.
-Wenn also zum Beispiel `X` (tägliche ETH-Ausgabe) auf 1800 basierend auf der Summe der eingesetzten ETH ansteigt, `f(X)` (gwei, die erforderlich sind, um die gesamte Emission auszugleichen) wäre dann `17 gwei` (mit 2 signifikanten Ziffern)
+Wenn also zum Beispiel `X` (tägliche ETH-Emission) basierend auf der Gesamtzahl der gestaketen ETH auf 1800 ansteigt, wäre `f(X)` (Gwei, die erforderlich sind, um die gesamte Emission auszugleichen) dann `17 Gwei` (bei Verwendung von 2 signifikanten Ziffern).
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
-- [Der Zusammenschluss](/roadmap/merge/)
-- [Ultrasound.money](https://ultrasound.money/) - _Dashboards zur Visualisierung von ETH-Ausgabe und -Verbrauch in Echtzeit verfügbar_
-- [Kartierung der Ethereum-Ausgabe](https://www.attestant.io/posts/charting-ethereum-issuance/) - _Jim McDonald 2020_
+- [Die Zusammenführung](/roadmap/merge/)
+- [Ultrasound.money](https://ultrasound.money/) – _Verfügbare Dashboards zur Visualisierung der ETH-Emission und -Verbrennung in Echtzeit_
+- [Charting Ethereum Issuance](https://www.attestant.io/posts/charting-ethereum-issuance/) – _Jim McDonald 2020_
diff --git a/public/content/translations/de/roadmap/pbs/index.md b/public/content/translations/de/roadmap/pbs/index.md
index d62b51fa43e..ab96a995f90 100644
--- a/public/content/translations/de/roadmap/pbs/index.md
+++ b/public/content/translations/de/roadmap/pbs/index.md
@@ -6,19 +6,19 @@ lang: de
# Proposer-Builder-Trennung {#proposer-builder-separation}
-Gegenwärtig werden Blöcke von Ethereum Validatoren gleichzeitig produziert _ und _ übertragen. Sie bündeln die Transaktionen, die sie über das Gossip-Netzwerk erhalten haben und fassen diese in einem Block zusammen, welcher sodann an die Peers des Ethereumnetzwerks versendet wird. **Vorschlags-Produzent Separation(PBS)** verteilt diese Aufgaben an mehrere Validatoren. Blockproduzenten werden dafür verantwortlich sein, Blöcke zu erstellen und diese den Blocküberträgern in jedem Slot zur Verfügung zu stellen. Der Block-Vorschlagende kann den Inhalt der Blöcke nicht sehen, sie entscheiden sich lediglich für den profitabelsten und zahlen dem Blockproduzenten eine Gebühr bevor sie den Block an die Peers versendet.
+Heutige Ethereum-Validatoren erstellen _und_ verbreiten Blöcke. Sie bündeln die Transaktionen, die sie über das Gossip-Netzwerk erhalten haben und fassen diese in einem Block zusammen, welcher sodann an die Peers des Ethereumnetzwerks versendet wird. **Proposer-Builder-Trennung (PBS)** teilt diese Aufgaben auf mehrere Validatoren auf. Blockproduzenten werden dafür verantwortlich sein, Blöcke zu erstellen und diese den Blocküberträgern in jedem Slot zur Verfügung zu stellen. Der Block-Vorschlagende kann den Inhalt der Blöcke nicht sehen, sie entscheiden sich lediglich für den profitabelsten und zahlen dem Blockproduzenten eine Gebühr bevor sie den Block an die Peers versendet.
Das ist aus mehreren Gründen ein wichtiges Update. Erstens, schafft es Möglichkeiten die Zensur von Transaktionen auf der Protokollebene zu verhindern. Zweitens, schützt es Hobby-Validatoren davor, von institutionellen Mitspielern, die auf eine bessere Rentabilität optimieren können, verdrängt zu werden. Und drittens, hilft es dabei Ethereum zu skalieren, weil es Upgrades für Danksharding ermöglicht.
-## PPT und Zensurresistenz {#pbs-and-censorship-resistance}
+## PBS und Zensurresistenz {#pbs-and-censorship-resistance}
Die Trennung von Block-Erstellern und Block-Antragstellern macht es schwieriger für Block-Antragsteller, Transaktionen zu zensieren. Das liegt daran, dass vergleichsweise komplexe Einschlusskriterien hinzugefügt werden können, die sicherstellen, dass keine Zensur stattgefunden hat, bevor der Block vorgeschlagen wird. Da der Blockvorschlagende eine eigenständige Einheit vom Blockersteller ist, kann er die Rolle eines Beschützers gegen die Zensur der Blockersteller übernehmen.
Ein Beispiel hierfür sind Einschlusslisten, die verwendet werden können, damit Validatoren über Transaktionen informiert sind, aber wenn sie sehen, dass diese nicht in Blöcken enthalten sind, können sie verlangen, dass sie im nächsten Block unbedingt enthalten sein müssen. Die Einschlussliste wird aus dem lokalen Mempool des Block-Vorschlagstellers generiert (der Liste der ihm bekannten Transaktionen) und kurz vor dem Vorschlagen eines Blocks an seine Peers gesendet. Falls Transaktionen aus der Einschlussliste fehlen, könnte der Vorschlagende entweder den Block ablehnen, die fehlenden Transaktionen hinzufügen, bevor er ihn vorschlägt, oder ihn vorschlagen und es anderen Validatoren überlassen, ihn abzulehnen, wenn sie ihn empfangen. Es gibt auch eine möglicherweise effizientere Version dieser Idee, die besagt, dass die Block-Ersteller den verfügbaren Blockplatz vollständig nutzen müssen. Falls sie das nicht tun, werden Transaktionen aus der Einschlussliste des Vorschlagenden hinzugefügt. Diese Idee ist nach wie vor Gegenstand aktiver Forschung, und die optimale Konfiguration für die Einschlusslisten ist noch nicht endgültig festgelegt.
-[Verschlüsselte Mempools](https://www.youtube.com/watch?v=fHDjgFcha0M&list=PLpktWkixc1gUqkyc1-iE6TT0RWQTBJELe&index=3) könnten auch dazu führen, dass Ersteller und Vorschlagende von Blöcken erst nach der Übertragung des Blocks wissen, welche Transaktionen darin enthalten sind.
+[Verschlüsselte Mempools](https://www.youtube.com/watch?v=fHDjgFcha0M&list=PLpktWkixc1gUqkyc1-iE6TT0RWQTBJELe&index=3) könnten es für Builder und Proposer auch unmöglich machen zu wissen, welche Transaktionen sie in einen Block aufnehmen, bis der Block bereits verbreitet wurde.
-
+
Einflussreiche Organisationen können Validatoren dazu drängen, Transaktionen zu zensieren, die von oder zu bestimmten Adressen erfolgen. Die Validatoren geben diesem Druck nach, indem sie Adressen auf der schwarzen Liste in ihrem Transaktionspool erkennen und sie auf den von ihnen vorgeschlagenen Blöcken auslassen. Nach der Einführung von PBS wird dies nicht mehr möglich sein, da Block-Vorschlagende nicht mehr wissen werden, welche Transaktionen sie in ihren Blöcken übertragen. Für bestimmte Personen oder Anwendungen könnte es wichtig sein, die Zensurvorschriften einzuhalten, z. B. wenn sie in ihrer Region gesetzlich vorgeschrieben sind. In solchen Fällen erfolgt die Einhaltung auf Anwendungsebene, während das Protokoll weiterhin erlaubnis- und zensurfrei bleibt.
@@ -26,26 +26,25 @@ Einflussreiche Organisationen können Validatoren dazu drängen, Transaktionen z
## PBS und MEV {#pbs-and-mev}
-**Maximal extrahierbarer Wert (MEV)** bezieht sich darauf, dass Validatoren ihre Rentabilität maximieren, indem sie Transaktionen in vorteilhafter Weise anordnen. Zu den gängigen Beispielen gehören das Arbitrieren von Trades an dezentralen Börsen (z. B. das Vorauslaufen eines großen Verkaufs oder Kaufs) oder die Identifizierung von Möglichkeiten zur Liquidierung von DeFi-Positionen. Die Maximierung von MEV erfordert hoch entwickeltes technisches Wissen und kundenspezifische Software, die normalen Validatoren hinzugefügt wird. Dadurch wird es deutlich wahrscheinlicher, dass institutionelle Betreiber bei der MEV-Extraktion Einzelpersonen und Hobby-Validatoren übertreffen. Das hat zur Folge, dass die Einkommen aus dem Staking (Einsetzen) mit zentralisierten Betreibern voraussichtlich höher ausfallen, was einen zentralisierenden Effekt erzeugt, der das Staking von Privatpersonen weniger attraktiv macht.
+**Maximal extrahierbarer Wert (MEV)** bezieht sich darauf, dass Validatoren ihre Rentabilität maximieren, indem sie Transaktionen in vorteilhafter Weise anordnen. Gängige Beispiele sind Arbitragegeschäfte mit Swaps an dezentralen Börsen (z. B. Frontrunning eines großen Verkaufs oder Kaufs) oder das Erkennen von Möglichkeiten zur Liquidierung von DeFi-Positionen. Die Maximierung von MEV erfordert hoch entwickeltes technisches Wissen und kundenspezifische Software, die normalen Validatoren hinzugefügt wird. Dadurch wird es deutlich wahrscheinlicher, dass institutionelle Betreiber bei der MEV-Extraktion Einzelpersonen und Hobby-Validatoren übertreffen. Das hat zur Folge, dass die Einkommen aus dem Staking (Einsetzen) mit zentralisierten Betreibern voraussichtlich höher ausfallen, was einen zentralisierenden Effekt erzeugt, der das Staking von Privatpersonen weniger attraktiv macht.
Das PBS löst dieses Problem, indem es die Wirtschaftlichkeit von MEV neu konfiguriert. Anstatt dass der Blockvorschlager selbst nach MEV-Möglichkeiten sucht, wählt er einfach einen Block aus vielen Blöcken aus, die ihm von Block-Erstellern angeboten werden. Die Block-Ersteller könnten eine ausgeklügelte MEV-Extraktion durchgeführt haben, aber die Belohnung dafür erhält der Blockvorschlager. Das bedeutet, dass selbst, wenn ein kleiner Pool spezialisierter Block-Ersteller die MEV-Extraktion dominiert, die Belohnung dafür an jeden Validator im Netzwerk gehen könnte, einschließlich einzelner Heim-Staker (Privat-Einsetzer/Staker).
-
+
-Aufgrund der verbesserten Belohnungen durch ausgeklügelte MEV-Strategien könnten Einzelpersonen dazu angeregt werden, sich Pools anzuschließen, anstatt alleine zu staken. Die Trennung der Block-Erstellung vom Block-Vorschlagsverfahren führt dazu, dass die extrahierte MEV auf eine größere Anzahl von Validatoren verteilt wird, anstatt sich bei dem effektivsten MEV-Sucher zu zentralisieren. Gleichzeitig nimmt das Erlauben von spezialisierten Blockproduzenten die Last der Blockerstellung weg vom Einzelnen und verhindert das Stehlen von MEV einzelner für sich selber, während die Anzahl individueller, unabhängiger Validatoren, die Blöcke auf ehrliche weise überprüfen, maximiert wird. Das wichtige Konzept ist die "Beweiser-Verifizierer Asymetrie", welche die Idee beschreibt, dass zentralisierte Blockproduktion okay ist, solange es ein robustes und maximal dezentralisiertes Netzwerk von ehrlichen Validatoren gibt, die die Blöcke überprüfen. Dezentralisierung ist ein Mittel, kein Endziel - worauf es uns ankommt, sind ehrliche Blöcke.
-
+Aufgrund der verbesserten Belohnungen durch ausgeklügelte MEV-Strategien könnten Einzelpersonen dazu angeregt werden, sich Pools anzuschließen, anstatt alleine zu staken. Die Trennung der Block-Erstellung vom Block-Vorschlagsverfahren führt dazu, dass die extrahierte MEV auf eine größere Anzahl von Validatoren verteilt wird, anstatt sich bei dem effektivsten MEV-Sucher zu zentralisieren. Gleichzeitig nimmt das Erlauben von spezialisierten Blockproduzenten die Last der Blockerstellung weg vom Einzelnen und verhindert das Stehlen von MEV einzelner für sich selber, während die Anzahl individueller, unabhängiger Validatoren, die Blöcke auf ehrliche weise überprüfen, maximiert wird. Das wichtige Konzept ist die "Beweiser-Verifizierer Asymetrie", welche die Idee beschreibt, dass zentralisierte Blockproduktion okay ist, solange es ein robustes und maximal dezentralisiertes Netzwerk von ehrlichen Validatoren gibt, die die Blöcke überprüfen. Dezentralisierung ist ein Mittel, kein Endziel - worauf es uns ankommt, sind ehrliche Blöcke.
## PBS und Danksharding {#pbs-and-danksharding}
-Danksharding ist der Weg, auf dem Ethereum zu >100000 Transaktionen pro Sekunde skalieren wird, während Gebühren für Rollup-Benutzer minimiert werden. Es baut auf PBS auf, weil es Arbeitslast für die Blockproduzenten hinzufügt, welche Beweise für bis zu 64 MB an Rollup-Daten in weniger als 1 Sekunde berechnen müssen. Dies wird wahrscheinlich spezialisierte Produzenten benötigen, die dieser Aufgabe einiges an Hardware-Power zur Verfügung stellen. Nichtsdestotrotz, in der derzeitigen Situation könnte die Blockproduktion mehr und mehr auf fortschrittlichere, stärkere Hardwareoperator wegen der MEV-Extraktion zentralisiert werden. Vorschlager-Produzenten-Trennung ist ein Weg, dieser Realität zu begegnen und zentralisierende Kräfte auf die Blockprüfung (der wichtige Teil) oder die Verteilung der Staking-Auszahlungen zu verhindern. Ein großer weiterer Vorteil ist zudem, dass die spezialisierten Blockproduzenten bereit und in der Lage sind, die nötigen Datenbeweise für Danksharding zu berechnen.
+Danksharding ist der Weg, wie Ethereum auf >100.000 Transaktionen pro Sekunde skalieren und die Gebühren für Rollup-Benutzer minimieren wird. Es baut auf PBS auf, weil es Arbeitslast für die Blockproduzenten hinzufügt, welche Beweise für bis zu 64 MB an Rollup-Daten in weniger als 1 Sekunde berechnen müssen. Dies wird wahrscheinlich spezialisierte Produzenten benötigen, die dieser Aufgabe einiges an Hardware-Power zur Verfügung stellen. Nichtsdestotrotz, in der derzeitigen Situation könnte die Blockproduktion mehr und mehr auf fortschrittlichere, stärkere Hardwareoperator wegen der MEV-Extraktion zentralisiert werden. Vorschlager-Produzenten-Trennung ist ein Weg, dieser Realität zu begegnen und zentralisierende Kräfte auf die Blockprüfung (der wichtige Teil) oder die Verteilung der Staking-Auszahlungen zu verhindern. Ein großer weiterer Vorteil ist zudem, dass die spezialisierten Blockproduzenten bereit und in der Lage sind, die nötigen Datenbeweise für Danksharding zu berechnen.
## Aktueller Fortschritt {#current-progress}
-PBS ist in einer fortgeschrittenen Phase der Forschung, aber es gibt immer noch ein paar wichtige Designfragen, die gelöst werden müssen, bevor es in Ethereum Clients implementiert werden kann. Es gibt noch keine endgültige Spezifikation. Das heißt, dass PBS wahrscheinlich noch mindestens ein Jahr oder länger entfernt ist. Informieren Sie sich über den neuesten [Forschungsstand](https://notes.ethereum.org/@vbuterin/pbs_censorship_resistance).
+PBS ist in einer fortgeschrittenen Phase der Forschung, aber es gibt immer noch ein paar wichtige Designfragen, die gelöst werden müssen, bevor es in Ethereum Clients implementiert werden kann. Es gibt noch keine endgültige Spezifikation. Das heißt, dass PBS wahrscheinlich noch mindestens ein Jahr oder länger entfernt ist. Sehen Sie sich den neuesten [Stand der Forschung](https://notes.ethereum.org/@vbuterin/pbs_censorship_resistance) an.
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
-- [Forschungsstand: Zensurwiderstand unter PBS](https://notes.ethereum.org/@vbuterin/pbs_censorship_resistance)
-- [PBS-freundliche Gebührenmarktkonzepte](https://ethresear.ch/t/proposer-block-builder-separation-friendly-fee-market-designs/9725)
-- [PPT und Zensurresistenz](https://notes.ethereum.org/@fradamt/H1TsYRfJc#Secondary-auctions)
-- [Einschlusslisten](https://notes.ethereum.org/@fradamt/H1ZqdtrBF)
+- [Forschungsstand: Zensurresistenz unter PBS](https://notes.ethereum.org/@vbuterin/pbs_censorship_resistance)
+- [PBS-freundliche Gebührenmarktdesigns](https://ethresear.ch/t/proposer-block-builder-separation-friendly-fee-market-designs/9725)
+- [PBS und Zensurresistenz](https://notes.ethereum.org/@fradamt/H1TsYRfJc#Secondary-auctions)
+- [Inklusionslisten](https://notes.ethereum.org/@fradamt/H1ZqdtrBF)
diff --git a/public/content/translations/de/roadmap/pectra/7702/index.md b/public/content/translations/de/roadmap/pectra/7702/index.md
new file mode 100644
index 00000000000..d673a6204f1
--- /dev/null
+++ b/public/content/translations/de/roadmap/pectra/7702/index.md
@@ -0,0 +1,149 @@
+---
+title: Pectra 7702-Richtlinien
+description: Erfahren Sie mehr über 7702 in der Pectra-Version
+lang: de
+---
+
+# Pectra 7702
+
+## Zusammenfassung {#abstract}
+
+EIP 7702 definiert einen Mechanismus, um einem EOA Code hinzuzufügen. Dieser Vorschlag ermöglicht es EOAs, den alten Ethereum-Konten, kurzfristige Funktionsverbesserungen zu erhalten, was die Benutzerfreundlichkeit von Anwendungen erhöht. Dies geschieht durch das Setzen eines Zeigers auf bereits bereitgestellten Code mithilfe eines neuen Transaktionstyps: 4.
+
+Dieser neue Transaktionstyp führt eine Autorisierungsliste ein. Jedes Autorisierungstupel in der Liste ist definiert als
+
+```
+[ chain_id, address, nonce, y_parity, r, s ]
+```
+
+**address** ist die Delegation (bereits bereitgestellter Bytecode, der vom EOA verwendet wird)
+**chain_id** sperrt die Autorisierung auf eine bestimmte Kette (oder 0 für alle Ketten)
+**nonce** sperrt die Autorisierung auf eine bestimmte Konto-Nonce
+(**y_parity, r, s**) ist die Signatur des Autorisierungstupels, die durch den privaten Schlüssel des EOA, auf den sich die Autorisierung bezieht (auch als Autorität bezeichnet), als keccak(0x05 || rlp ([chain_id ,address, nonce])) definiert wird
+
+Eine Delegation kann zurückgesetzt werden, indem an die Null-Adresse delegiert wird.
+
+Der private Schlüssel des EOA behält nach der Delegation die volle Kontrolle über das Konto. Wenn Sie zum Beispiel an ein Safe delegieren, wird das Konto nicht zu einem Multisig, da es immer noch einen einzigen Schlüssel gibt, der jede Signierrichtlinie umgehen kann. In Zukunft sollten Entwickler davon ausgehen, dass jeder Teilnehmer im System ein Smart Contract sein könnte. Für Smart-Contract-Entwickler ist es nicht mehr sicher anzunehmen, dass sich `tx.origin` auf einen EOA bezieht.
+
+## Bewährte Praktiken {#best-practices}
+
+**Kontoabstraktion**: Ein Delegationsvertrag sollte mit den breiteren Kontoabstraktionsstandards (AA) von Ethereum übereinstimmen, um die Kompatibilität zu maximieren. Insbesondere sollte er idealerweise ERC-4337-konform oder kompatibel sein.
+
+**Erlaubnisfreies und zensurresistentes Design**: Ethereum schätzt die erlaubnisfreie Teilnahme. Ein Delegationsvertrag DARF KEINEN einzelnen „vertrauenswürdigen“ Relayer oder Dienst fest programmieren oder sich darauf verlassen. Dies würde das Konto lahmlegen, wenn der Relayer offline geht. Funktionen wie Batching (z. B. approve+transferFrom) können vom EOA selbst ohne einen Relayer verwendet werden. Für Anwendungsentwickler, die erweiterte Funktionen nutzen möchten, die durch 7702 (Gasabstraktion, datenschutzwahrende Abhebungen) ermöglicht werden, benötigen Sie einen Relayer. Obwohl es verschiedene Relayer-Architekturen gibt, empfehlen wir die Verwendung von [4337 Bundlern](https://www.erc4337.io/bundlers), die mindestens auf den [Einstiegspunkt 0.8](https://github.com/eth-infinitism/account-abstraction/releases/tag/v0.8.0) verweisen, denn:
+
+- Sie bieten standardisierte Schnittstellen für das Relaying
+- Sie enthalten eingebaute Paymaster-Systeme
+- Sie gewährleisten die Vorwärtskompatibilität
+- Sie können Zensurresistenz durch einen [öffentlichen Mempool](https://notes.ethereum.org/@yoav/unified-erc-4337-mempool) unterstützen
+- Sie können erfordern, dass die init-Funktion nur vom [EntryPoint](https://github.com/eth-infinitism/account-abstraction/releases/tag/v0.8.0) aufgerufen wird
+
+Mit anderen Worten, jeder sollte als Transaktionssponsor/Relayer agieren können, solange er die erforderliche gültige Signatur oder UserOperation vom Konto bereitstellt. Dies gewährleistet Zensurresistenz: Wenn keine benutzerdefinierte Infrastruktur erforderlich ist, können die Transaktionen eines Benutzers nicht willkürlich durch ein kontrollierendes Relais blockiert werden. Zum Beispiel arbeitet [MetaMasks Delegation Toolkit](https://github.com/MetaMask/delegation-framework/releases/tag/v1.3.0) explizit mit jedem ERC-4337-Bundler oder Paymaster auf jeder Kette zusammen, anstatt einen MetaMask-spezifischen Server zu erfordern.
+
+**Dapps-Integration über Wallet-Schnittstellen**:
+
+Da Wallets spezifische Delegationsverträge für EIP-7702 auf die Whitelist setzen werden, sollten Dapps nicht erwarten, 7702-Autorisierungen direkt anzufordern. Stattdessen sollte die Integration über standardisierte Wallet-Schnittstellen erfolgen:
+
+- **ERC-5792 (`wallet_sendCalls`)**: Ermöglicht Dapps, Wallets aufzufordern, gebündelte Aufrufe auszuführen, was Funktionalitäten wie Transaktionsbündelung und Gas-Abstraktion erleichtert.
+
+- **ERC-6900**: Ermöglicht Dapps, modulare Smart-Account-Funktionen wie Sitzungsschlüssel und Kontowiederherstellung über von Wallets verwaltete Module zu nutzen.
+
+Durch die Nutzung dieser Schnittstellen können Dapps auf Smart-Account-Funktionalitäten zugreifen, die von EIP-7702 bereitgestellt werden, ohne Delegationen direkt zu verwalten, was Kompatibilität und Sicherheit über verschiedene Wallet-Implementierungen hinweg gewährleistet.
+
+> Hinweis: Es gibt keine standardisierte Methode für Dapps, 7702-Autorisierungssignaturen direkt anzufordern. Dapps müssen sich auf spezifische Wallet-Schnittstellen wie ERC-6900 verlassen, um die Funktionen von EIP-7702 zu nutzen.
+
+Weitere Informationen:
+
+- [ERC-5792-Spezifikation](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-5792.md)
+- [ERC-6900-Spezifikation](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-6900.md)
+
+**Vermeidung von Herstellerbindung**: Im Einklang mit dem oben Genannten ist eine gute Implementierung herstellerneutral und interoperabel. Dies bedeutet oft, sich an aufkommende Standards für Smart Accounts zu halten. Zum Beispiel verwendet [Alchemys modulares Konto](https://github.com/alchemyplatform/modular-account) den ERC-6900-Standard für modulare Smart Accounts und wurde mit Blick auf eine „erlaubnisfreie interoperable Nutzung“ konzipiert.
+
+**Datenschutz**: Obwohl der Datenschutz on-chain begrenzt ist, sollte ein Delegationsvertrag bestrebt sein, die Datenexposition und Verknüpfbarkeit zu minimieren. Dies kann durch die Unterstützung von Funktionen wie Gas-Zahlungen in ERC-20-Tokens (sodass Benutzer kein öffentliches ETH-Guthaben halten müssen, was den Datenschutz und die UX verbessert) und einmaligen Sitzungsschlüsseln (die die Abhängigkeit von einem einzigen Langzeitschlüssel verringern) erreicht werden. Zum Beispiel ermöglicht EIP-7702 das Bezahlen von Gas in Tokens über gesponserte Transaktionen, und eine gute Implementierung wird es einfach machen, solche Paymaster zu integrieren, ohne mehr Informationen als nötig preiszugeben. Darüber hinaus bedeutet die Off-Chain-Delegation bestimmter Genehmigungen (unter Verwendung von Signaturen, die on-chain verifiziert werden), dass weniger On-Chain-Transaktionen mit dem Primärschlüssel des Benutzers stattfinden, was dem Datenschutz dient. Konten, die die Verwendung eines Relayers erfordern, zwingen Benutzer, ihre IP-Adressen preiszugeben. Öffentliche Mempools verbessern dies. Wenn eine Transaktion/UserOp sich durch den Mempool ausbreitet, können Sie nicht feststellen, ob sie von der IP stammt, die sie gesendet hat, oder ob sie nur über das p2p-Protokoll weitergeleitet wurde.
+
+**Erweiterbarkeit und modulare Sicherheit**: Kontenimplementierungen sollten erweiterbar sein, damit sie sich mit neuen Funktionen und Sicherheitsverbesserungen weiterentwickeln können. Upgrade-Fähigkeit ist mit EIP-7702 von Natur aus möglich (da ein EOA in Zukunft immer an einen neuen Vertrag delegieren kann, um seine Logik zu aktualisieren). Über die Upgrade-Fähigkeit hinaus ermöglicht ein gutes Design Modularität – z. B. Plug-in-Module für verschiedene Signaturschemata oder Ausgabenrichtlinien –, ohne dass eine vollständige Neuausbringung erforderlich ist. Das Account Kit von Alchemy ist ein Paradebeispiel, das Entwicklern die Installation von Validierungsmodulen (für verschiedene Signaturtypen wie ECDSA, BLS usw.) ermöglicht. und Ausführungsmodule für benutzerdefinierte Logik. Um eine größere Flexibilität und Sicherheit in EIP-7702-fähigen Konten zu erreichen, werden Entwickler ermutigt, an einen Proxy-Vertrag zu delegieren, anstatt direkt an eine spezifische Implementierung. Dieser Ansatz ermöglicht nahtlose Upgrades und Modularität, ohne dass für jede Änderung zusätzliche EIP-7702-Autorisierungen erforderlich sind.
+
+Vorteile des Proxy-Musters:
+
+- **Upgrade-Fähigkeit**: Aktualisieren Sie die Vertragslogik, indem Sie den Proxy auf einen neuen Implementierungsvertrag verweisen.
+
+- **Benutzerdefinierte Initialisierungslogik**: Integrieren Sie Initialisierungsfunktionen in den Proxy, um die notwendigen Zustandsvariablen sicher einzurichten.
+
+Zum Beispiel zeigt der [SafeEIP7702Proxy](https://docs.safe.global/advanced/eip-7702/7702-safe), wie ein Proxy genutzt werden kann, um Delegationen in EIP-7702-kompatiblen Konten sicher zu initialisieren und zu verwalten.
+
+Nachteile des Proxy-Musters:
+
+- **Abhängigkeit von externen Akteuren**: Sie müssen sich darauf verlassen, dass ein externes Team kein Upgrade auf einen unsicheren Vertrag durchführt.
+
+## Sicherheitsüberlegungen {#security-considerations}
+
+**Re-Entrancy-Schutz**: Mit der Einführung der EIP-7702-Delegation kann das Konto eines Benutzers dynamisch zwischen einem extern verwalteten Konto (EOA) und einem Smart Contract (SC) wechseln. Diese Flexibilität ermöglicht es dem Konto, sowohl Transaktionen zu initiieren als auch Ziel von Aufrufen zu sein. Infolgedessen werden Szenarien, in denen ein Konto sich selbst aufruft und externe Aufrufe tätigt, dazu führen, dass `msg.sender` gleich `tx.origin` ist, was bestimmte Sicherheitsannahmen untergräbt, die zuvor darauf beruhten, dass `tx.origin` immer ein EOA ist.
+
+Für Smart-Contract-Entwickler ist es nicht mehr sicher anzunehmen, dass sich `tx.origin` auf einen EOA bezieht. Ebenso ist die Verwendung von `msg.sender == tx.origin` als Schutzmaßnahme gegen Re-Entrancy-Angriffe keine zuverlässige Strategie mehr.
+
+In Zukunft sollten Entwickler davon ausgehen, dass jeder Teilnehmer im System ein Smart Contract sein könnte. Alternativ könnten sie einen expliziten Re-Entrancy-Schutz unter Verwendung von Re-Entrancy-Guards mit `nonReentrant`-Modifikator-Mustern implementieren. Wir empfehlen, einen auditierten Modifikator zu verwenden, z. B. [OpenZeppelins Reentrancy Guard](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/ReentrancyGuard.sol). Sie könnten auch eine [transiente Speichervariable](https://docs.soliditylang.org/en/latest/internals/layout_in_storage.html) verwenden.
+
+**Sicherheitsüberlegungen zur Initialisierung**
+
+Die Implementierung von EIP-7702-Delegationsverträgen bringt spezifische Sicherheitsherausforderungen mit sich, insbesondere im Hinblick auf den Initialisierungsprozess. Eine kritische Schwachstelle entsteht, wenn die Initialisierungsfunktion (`init`) atomar mit dem Delegationsprozess gekoppelt ist. In solchen Fällen könnte ein Frontrunner die Delegationssignatur abfangen und die `init`-Funktion mit geänderten Parametern ausführen, wodurch er möglicherweise die Kontrolle über das Konto übernimmt.
+
+Dieses Risiko ist besonders relevant, wenn versucht wird, bestehende Smart-Contract-Konto-Implementierungen (SCA) mit EIP-7702 zu verwenden, ohne deren Initialisierungsmechanismen zu ändern.
+
+**Lösungen zur Minderung von Initialisierungsschwachstellen**
+
+- Implement `initWithSig`
+ Ersetzen Sie die Standard-`init`-Funktion durch eine `initWithSig`-Funktion, bei der der Benutzer die Initialisierungsparameter signieren muss. Dieser Ansatz stellt sicher, dass die Initialisierung nur mit ausdrücklicher Zustimmung des Benutzers erfolgen kann, wodurch das Risiko einer unbefugten Initialisierung gemindert wird.
+
+- Nutzen Sie den EntryPoint von ERC-4337
+ Verlangen Sie, dass die Initialisierungsfunktion ausschließlich vom ERC-4337 EntryPoint-Vertrag aufgerufen wird. Diese Methode nutzt das standardisierte Validierungs- und Ausführungsframework von ERC-4337 und fügt dem Initialisierungsprozess eine zusätzliche Sicherheitsebene hinzu.
+ _(Siehe: [Safe Docs](https://docs.safe.global/advanced/eip-7702/7702-safe))_
+
+Durch die Anwendung dieser Lösungen können Entwickler die Sicherheit von EIP-7702-Delegationsverträgen verbessern und sich vor potenziellen Frontrunning-Angriffen während der Initialisierungsphase schützen.
+
+**Speicherkollisionen** Das Delegieren von Code löscht nicht den vorhandenen Speicher. Bei der Migration von einem Delegationsvertrag zu einem anderen bleiben die Restdaten des vorherigen Vertrags erhalten. Wenn der neue Vertrag dieselben Speicher-Slots verwendet, diese aber unterschiedlich interpretiert, kann dies zu unbeabsichtigtem Verhalten führen. Wenn beispielsweise die ursprüngliche Delegation an einen Vertrag erfolgte, bei dem ein Speicher-Slot einen `bool`-Wert darstellt, und die nachfolgende Delegation an einen Vertrag, bei dem derselbe Slot einen `uint`-Wert darstellt, kann die Nichtübereinstimmung zu unvorhersehbaren Ergebnissen führen.
+
+**Phishing-Risiken** Mit der Implementierung der EIP-7702-Delegation können die Vermögenswerte auf dem Konto eines Benutzers vollständig von Smart Contracts kontrolliert werden. Wenn ein Benutzer sein Konto unwissentlich an einen bösartigen Vertrag delegiert, könnte ein Angreifer leicht die Kontrolle erlangen und Gelder stehlen. Bei Verwendung von `chain_id=0` wird die Delegation auf alle Chain-IDs angewendet. Delegieren Sie nur an einen unveränderlichen Vertrag (niemals an einen Proxy) und nur an Verträge, die mit CREATE2 bereitgestellt wurden (mit Standard-Initcode – keine metamorphen Verträge), damit der Bereitsteller nicht etwas anderes an dieselbe Adresse an anderer Stelle bereitstellen kann. Andernfalls gefährdet Ihre Delegation Ihr Konto auf allen anderen EVM-Ketten.
+
+Wenn Benutzer delegierte Signaturen durchführen, sollte der Zielvertrag, der die Delegation erhält, klar und deutlich angezeigt werden, um Phishing-Risiken zu mindern.
+
+**Minimale vertrauenswürdige Oberfläche & Sicherheit**: Obwohl ein Delegationsvertrag Flexibilität bietet, sollte seine Kernlogik minimal und auditierbar gehalten werden. Der Vertrag ist praktisch eine Erweiterung des EOA des Benutzers, sodass jeder Fehler katastrophale Folgen haben kann. Implementierungen sollten den besten Praktiken der Smart-Contract-Sicherheits-Community folgen. Zum Beispiel müssen Konstruktor- oder Initialisierungsfunktionen sorgfältig gesichert werden – wie von Alchemy hervorgehoben, könnte bei Verwendung eines Proxy-Musters unter 7702 ein ungeschützter Initialisierer einem Angreifer ermöglichen, das Konto zu übernehmen. Teams sollten darauf abzielen, den On-Chain-Code einfach zu halten: Der 7702-Vertrag von Ambire umfasst nur ~200 Zeilen Solidity, um die Komplexität bewusst zu minimieren und Fehler zu reduzieren. Es muss ein Gleichgewicht zwischen funktionsreicher Logik und der Einfachheit, die die Auditierung erleichtert, gefunden werden.
+
+### Bekannte Implementierungen {#known-implementations}
+
+Aufgrund der Natur von EIP 7702 wird empfohlen, dass Wallets Vorsicht walten lassen, wenn sie Benutzern helfen, an einen Drittanbietervertrag zu delegieren. Nachfolgend finden Sie eine Sammlung bekannter Implementierungen, die auditiert wurden:
+
+| Vertragsadresse | Quelle | Audits (Prüfungen) |
+| ------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 0x000000009B1D0aF20D8C6d0A44e162d11F9b8f00 | [Uniswap/calibur](https://github.com/Uniswap/calibur) | [Audits](https://github.com/Uniswap/calibur/tree/main/audits) |
+| 0x69007702764179f14F51cdce752f4f775d74E139 | [alchemyplatform/modular-account](https://github.com/alchemyplatform/modular-account) | [Audits](https://github.com/alchemyplatform/modular-account/tree/develop/audits) |
+| 0x5A7FC11397E9a8AD41BF10bf13F22B0a63f96f6d | [AmbireTech/ambire-common](https://github.com/AmbireTech/ambire-common/blob/feature/eip-7702/contracts/AmbireAccount7702.sol) | [Audits](https://github.com/AmbireTech/ambire-common/tree/feature/eip-7702/audits) |
+| 0x63c0c19a282a1b52b07dd5a65b58948a07dae32b | [MetaMask/delegation-framework](https://github.com/MetaMask/delegation-framework) | [Audits](https://github.com/MetaMask/delegation-framework/tree/main/audits) |
+| 0x4Cd241E8d1510e30b2076397afc7508Ae59C66c9 | [AA-Team der Ethereum Foundation](https://github.com/eth-infinitism/account-abstraction/blob/develop/contracts/accounts/Simple7702Account.sol) | [Audits](https://github.com/eth-infinitism/account-abstraction/blob/develop/audits/SpearBit%20Account%20Abstraction%20Security%20Review%20-%20Mar%202025.pdf) |
+| 0x17c11FDdADac2b341F2455aFe988fec4c3ba26e3 | [Luganodes/Pectra-Batch-Contract](https://github.com/Luganodes/Pectra-Batch-Contract) | [Audits](https://certificate.quantstamp.com/full/luganodes-pectra-batch-contract/23f0765f-969a-4798-9edd-188d276c4a2b/index.html) |
+
+## Hardware-Wallet-Richtlinien {#hardware-wallet-guidelines}
+
+Hardware-Wallets sollten keine beliebige Delegation ermöglichen. Der Konsens im Bereich der Hardware-Wallets ist die Verwendung einer Liste vertrauenswürdiger Delegator-Verträge. Wir schlagen vor, die oben aufgeführten bekannten Implementierungen zuzulassen und andere von Fall zu Fall zu prüfen. Da die Delegation Ihres EOA an einen Vertrag die Kontrolle über alle Vermögenswerte gibt, sollten Hardware-Wallets bei der Implementierung von 7702 vorsichtig sein.
+
+### Integrationsszenarien für Begleit-Apps {#integration-scenarios-for-companion-apps}
+
+#### Lazy {#lazy}
+
+Da der EOA weiterhin wie gewohnt funktioniert, gibt es nichts zu tun.
+
+Hinweis: Einige Vermögenswerte könnten vom Delegationscode automatisch abgelehnt werden, wie z. B. ERC-1155-NFTs, und der Support sollte sich dessen bewusst sein.
+
+#### Bewusst {#aware}
+
+Benachrichtigen Sie den Benutzer, dass für den EOA eine Delegation vorhanden ist, indem Sie dessen Code überprüfen, und bieten Sie optional an, die Delegation zu entfernen.
+
+#### Gängige Delegation {#common-delegation}
+
+Der Hardware-Anbieter setzt bekannte Delegationsverträge auf die Whitelist und implementiert deren Unterstützung in der Software-Begleit-App. Es wird empfohlen, einen Vertrag mit voller ERC-4337-Unterstützung zu wählen.
+
+EOAs, die an einen anderen delegiert wurden, werden als Standard-EOAs behandelt.
+
+#### Benutzerdefinierte Delegation {#custom-delegation}
+
+Der Hardware-Anbieter implementiert seinen eigenen Delegationsvertrag, fügt ihn den Listen hinzu und implementiert seine Unterstützung in der Software-Begleit-App. Es wird empfohlen, einen Vertrag mit voller ERC-4337-Unterstützung zu erstellen.
+
+EOAs, die an einen anderen delegiert wurden, werden als Standard-EOAs behandelt.
diff --git a/public/content/translations/de/roadmap/pectra/index.md b/public/content/translations/de/roadmap/pectra/index.md
new file mode 100644
index 00000000000..f0484d5ff48
--- /dev/null
+++ b/public/content/translations/de/roadmap/pectra/index.md
@@ -0,0 +1,127 @@
+---
+title: Prag-Electra (Pectra)
+description: Erfahre mehr über das Pectra-Protokoll-Upgrade
+lang: de
+---
+
+# Pectra {#pectra}
+
+Das Pectra-Netzwerk-Upgrade folgte auf [Dencun](/roadmap/dencun/) und brachte Änderungen sowohl an der Ausführungsebene als auch an der Konsens-Ebene von Ethereum. Der verkürzte Name Pectra ist eine Kombination aus Prag und Electra, den jeweiligen Namen für die Spezifikationsänderungen der Ausführungs- und der Konsens-Ebene. Zusammen bringen diese Änderungen eine Reihe von Verbesserungen für Ethereum-Nutzer, Entwickler und Validatoren.
+
+Dieses Upgrade wurde erfolgreich im Ethereum-Mainnet bei Epoche `364032` am **7. Mai 2025 um 10:05 (UTC)** aktiviert.
+
+
+
+
+Das Pectra-Upgrade ist nur ein einziger Schritt in den langfristigen Entwicklungszielen von Ethereum. Erfahre mehr über die [Protokoll-Roadmap](/roadmap/) und [frühere Upgrades](/ethereum-forks/).
+
+
+
+
+## Verbesserungen in Pectra {#new-improvements}
+
+Pectra bringt die größte Anzahl an [EIPs](https://eips.ethereum.org/) aller bisherigen Upgrades mit sich! Es gibt viele kleinere Änderungen, aber auch einige wichtige neue Funktionen. Die vollständige Liste der Änderungen und technischen Details findet sich in den einzelnen enthaltenen EIPs.
+
+### EOA-Konto-Code {#7702}
+
+[EIP-7702](https://eips.ethereum.org/EIPS/eip-7702) stellt einen wichtigen Schritt in Richtung einer weitreichenden [Kontoabstraktion](/roadmap/account-abstraction/) dar. Mit dieser Funktion können Nutzer ihre Adresse ([EOA](/glossary/#eoa)) so einstellen, dass sie um einen Smart Contract erweitert wird. Der EIP führt einen neuen Transaktionstyp mit einer spezifischen Funktion ein: Adressinhabern wird es ermöglicht, eine Autorisierung zu unterzeichnen, die ihre Adresse so einstellt, dass sie einen ausgewählten Smart Contract nachahmt.
+
+Mit diesem EIP können sich Nutzer für programmierbare Wallets entscheiden, die neue Funktionen wie Transaktionsbündelung, gaslose Transaktionen und benutzerdefinierten Asset-Zugriff für alternative Wiederherstellungsschemata ermöglichen. Dieser hybride Ansatz kombiniert die Einfachheit von EOAs mit der Programmierbarkeit von vertragsbasierten Konten.
+
+Eine ausführlichere Beschreibung von 7702 findest du [hier](/roadmap/pectra/7702/)
+
+### Erhöhung des maximalen effektiven Guthabens {#7251}
+
+Das aktuelle effektive Guthaben des Validators beträgt genau 32 ETH. Das ist der minimal notwendige Betrag, um am Konsens teilzunehmen, aber gleichzeitig das Maximum, das ein einzelner Validator staken kann.
+
+[EIP-7251](https://eips.ethereum.org/EIPS/eip-7251) erhöht das maximal mögliche effektive Guthaben auf 2048 ETH, was bedeutet, dass ein einzelner Validator nun zwischen 32 und 2048 ETH staken kann. Anstatt Vielfache von 32 zu staken, können Staker nun einen beliebigen ETH-Betrag zum Staken wählen und erhalten Belohnungen für jeden ETH über dem Minimum. Wenn zum Beispiel das Guthaben eines Validators mit seinen Belohnungen auf 33 ETH anwächst, wird der zusätzliche 1 ETH ebenfalls als Teil des effektiven Guthabens betrachtet und erhält Belohnungen.
+
+Aber der Vorteil eines besseren Belohnungssystems für Validatoren ist nur ein Teil dieser Verbesserung. [Staker](/staking/), die mehrere Validatoren betreiben, können diese nun zu einem einzigen zusammenfassen, was den Betrieb erleichtert und den Netzwerk-Overhead reduziert. Da jeder Validator in der Beacon Chain in jeder Epoche eine Signatur einreicht, wachsen die Bandbreitenanforderungen mit mehr Validatoren und einer großen Anzahl zu verbreitender Signaturen. Die Zusammenfassung von Validatoren wird das Netzwerk entlasten und neue Skalierungsoptionen eröffnen, während die gleiche wirtschaftliche Sicherheit erhalten bleibt.
+
+Eine ausführlichere Beschreibung von maxEB findest du [hier](/roadmap/pectra/maxeb/)
+
+### Erhöhung des Blob-Durchsatzes {#7691}
+
+Blobs bieten [Datenverfügbarkeit](/developers/docs/data-availability/#data-availability-and-layer-2-rollups) für L2s. Sie wurden im [vorherigen Netzwerk-Upgrade](/roadmap/dencun/) eingeführt.
+
+Derzeit zielt das Netzwerk auf durchschnittlich 3 Blobs pro Block mit einem Maximum von 6 Blobs ab. Mit [EIP-7691](https://eips.ethereum.org/EIPS/eip-7691) wird die durchschnittliche Blob-Anzahl auf 6 erhöht, mit einem Maximum von 9 pro Block, was zu einer erhöhten Kapazität für Ethereum-Rollups führt. Dieses EIP hilft, die Lücke zu überbrücken, bis [PeerDAS](https://eips.ethereum.org/EIPS/eip-7594) noch höhere Blob-Anzahlen ermöglicht.
+
+### Erhöhung der Calldata-Kosten {#7623}
+
+Vor der Einführung von [Blobs im Dencun-Upgrade](/roadmap/danksharding) verwendeten L2s [Calldata](/developers/docs/data-availability/blockchain-data-storage-strategies/#calldata), um ihre Daten in Ethereum zu speichern. Sowohl Blobs als auch Calldata beeinflussen die Bandbreitennutzung von Ethereum. Während die meisten Blöcke nur eine minimale Menge an Calldata verwenden, können datenintensive Blöcke, die auch viele Blobs enthalten, schädlich für das P2P-Netzwerk von Ethereum sein.
+
+Um dieses Problem zu beheben, erhöht [EIP-7623](https://eips.ethereum.org/EIPS/eip-7623) die Preise für Calldata, aber nur für datenintensive Transaktionen. Dies begrenzt die Blockgröße im schlimmsten Fall, bietet einen Anreiz für L2s, nur Blobs zu verwenden, und lässt über 99 % der Transaktionen unberührt.
+
+### Auslösbare Exits der Ausführungsebene {#7002}
+
+Derzeit ist das Verlassen eines Validators und das [Abheben von gestakten ETH](/staking/withdrawals/) ein Vorgang der Konsens-Ebene, der einen aktiven Validator-Schlüssel erfordert, denselben BLS-Schlüssel, den der Validator zur Erfüllung aktiver Aufgaben wie Attestierungen verwendet. Die „Withdrawal Credentials“ sind ein separater Cold Key, der den ausgetretenen Stake empfängt, aber den Austritt nicht auslösen kann. Die einzige Möglichkeit für Staker, auszusteigen, besteht darin, eine spezielle Nachricht an das Beacon-Chain-Netzwerk zu senden, die mit dem aktiven Validator-Schlüssel signiert ist. Dies ist in Szenarien einschränkend, in denen die „Withdrawal Credentials“ und der Validator-Schlüssel von verschiedenen Entitäten gehalten werden oder wenn der Validator-Schlüssel verloren geht.
+
+[EIP-7002](https://eips.ethereum.org/EIPS/eip-7002) führt einen neuen Vertrag ein, der verwendet werden kann, um den Austritt unter Verwendung der „Withdrawal Credentials“ der Ausführungsebene auszulösen. Staker können ihren Validator verlassen, indem sie eine Funktion in diesem speziellen Vertrag aufrufen, ohne dass sie ihren Validator-Signierschlüssel benötigen oder überhaupt auf die Beacon Chain zugreifen müssen. Wichtig ist, dass die Aktivierung von Validator-Abhebungen on-chain Staking-Protokolle mit reduzierten Vertrauensannahmen gegenüber Node-Betreibern ermöglicht.
+
+### Validator-Einzahlungen on-chain {#6110}
+
+Validator-Einzahlungen werden derzeit durch das [eth1data-Polling](https://eth2book.info/capella/part2/deposits-withdrawals/deposit-processing/) verarbeitet, einer Funktion auf der Beacon Chain, die Daten von der Ausführungsebene abruft. Es handelt sich um eine Art technische Schuld aus der Zeit vor The Merge, als die Beacon Chain ein separates Netzwerk war und sich mit Proof-of-Work-Re-Orgs befassen musste.
+
+[EIP-6110](https://eips.ethereum.org/EIPS/eip-6110) ist eine neue Methode zur Übermittlung von Einzahlungen von der Ausführungs- an die Konsens-Ebene, die eine sofortige Verarbeitung mit geringerer Implementierungskomplexität ermöglicht. Es ist eine sicherere Art, Einzahlungen zu handhaben, die für das vereinte Ethereum nativ ist. Es hilft auch, das Protokoll zukunftssicher zu machen, da es keine historischen Einzahlungen zum Bootstrapping der Node benötigt, was für den Ablauf der Historie notwendig ist.
+
+### Precompile für BLS12-381 {#2537}
+
+Precompiles sind ein spezieller Satz von Smart Contracts, die direkt in die Ethereum Virtual Machine ([EVM](/developers/docs/evm/)) integriert sind. Im Gegensatz zu regulären Verträgen werden Precompiles nicht von Nutzern bereitgestellt, sondern sind Teil der Client-Implementierung selbst und in deren nativer Sprache geschrieben (z. B. Go, Java, etc., nicht Solidity). Precompiles dienen für weit verbreitete und standardisierte Funktionen wie kryptografische Operationen. Smart-Contract-Entwickler können Precompiles wie einen regulären Vertrag aufrufen, aber mit mehr Sicherheit und Effizienz.
+
+[EIP-2537](https://eips.ethereum.org/EIPS/eip-2537) fügt neue Precompiles für Kurvenoperationen über [BLS12-381](https://hackmd.io/@benjaminion/bls12-381) hinzu. Diese elliptische Kurve ist dank ihrer praktischen Eigenschaften in Kryptowährungs-Ökosystemen weit verbreitet. Genauer gesagt wurde sie von der Konsens-Ebene von Ethereum übernommen, wo sie von Validatoren verwendet wird.
+
+Der neue Precompile gibt jedem Entwickler die Möglichkeit, kryptografische Operationen mit dieser Kurve einfach, effizient und sicher durchzuführen, zum Beispiel die Überprüfung von Signaturen. On-Chain-Anwendungen, die von dieser Kurve abhängen, können gas-effizienter und sicherer werden, indem sie sich auf einen Precompile anstatt auf einen benutzerdefinierten Vertrag verlassen. Dies gilt hauptsächlich für Anwendungen, die über Validatoren innerhalb der EVM nachdenken möchten, z. B. Staking-Pools, [Restaking](/restaking/), Light Clients, kettenübergreifende Brücken, aber auch Zero-Knowledge.
+
+### Bereitstellung historischer Block-Hashes aus dem State {#2935}
+
+Die EVM stellt derzeit den `BLOCKHASH`-Opcode zur Verfügung, der es Vertragsentwicklern ermöglicht, den Hash eines Blocks direkt in der Ausführungsebene abzurufen. Dies ist jedoch nur auf die letzten 256 Blöcke beschränkt und könnte in Zukunft für zustandslose Clients problematisch werden.
+
+[EIP-2935](https://eips.ethereum.org/EIPS/eip-2935) erstellt einen neuen Systemvertrag, der die letzten 8192 Block-Hashes als Storage-Slots bereitstellen kann. Dies trägt dazu bei, das Protokoll für eine zustandslose Ausführung zukunftssicher zu machen, und wird effizienter, wenn Verkle-Tries übernommen werden. Abgesehen davon können Rollups jedoch sofort davon profitieren, da sie den Vertrag direkt mit einem längeren historischen Fenster abfragen können.
+
+### Verschieben des Komitee-Index außerhalb der Attestierung {#7549}
+
+Der Konsens der Beacon Chain basiert darauf, dass Validatoren ihre Stimmen für den neuesten Block und die finalisierte Epoche abgeben. Die Attestierung enthält 3 Elemente, von denen 2 Stimmen und das dritte der Wert des Komitee-Index ist.
+
+[EIP-7549](https://eips.ethereum.org/EIPS/eip-7549) verschiebt diesen Index aus der signierten Attestierungsnachricht heraus, was die Überprüfung und Aggregation von Konsens-Stimmen erleichtert. Dies ermöglicht mehr Effizienz in jedem Konsens-Client und kann erhebliche Leistungsverbesserungen für Zero-Knowledge-Schaltungen zum Beweis des Ethereum-Konsens bringen.
+
+### Blob-Zeitplan zu EL-Konfigurationsdateien hinzufügen {#7840}
+
+[EIP-7840](https://eips.ethereum.org/EIPS/eip-7840) ist eine einfache Änderung, die ein neues Feld zur Client-Konfiguration der Ausführungsebene hinzufügt. Es konfiguriert die Anzahl der Blöcke und ermöglicht die dynamische Einstellung der Ziel- und Maximalanzahl von Blobs pro Block sowie die Anpassung der Blob-Gebühr. Mit einer direkt definierten Konfiguration können Clients die Komplexität des Austauschs dieser Informationen über die Engine-API vermeiden.
+
+
+
+
+Um mehr darüber zu erfahren, wie Pectra dich speziell als Ethereum-Nutzer, Entwickler oder Validator betrifft, schau in die Pectra-FAQ.
+
+
+
+
+## Betrifft dieses Upgrade alle Ethereum-Nodes und -Validatoren? {#client-impact}
+
+Ja, das Pectra-Upgrade erfordert Updates sowohl für [Ausführungs-Clients als auch für Konsens-Clients](/developers/docs/nodes-and-clients/). Alle wichtigen Ethereum-Clients werden Versionen veröffentlichen, die den als hochprioritär eingestuften Hard Fork unterstützen. Um nach dem Upgrade die Synchronisation mit dem Ethereum-Netzwerk aufrechtzuerhalten, müssen die Knotenbetreiber sicherstellen, dass die von ihnen eingesetzte Client-Version unterstützt wird. Beachten Sie, dass die Informationen zu Client-Versionen zeitkritisch sind, und Benutzer sollten die neuesten Updates konsultieren, um die die aktuellsten Details zu erfahren.
+
+## Wie können ETH nach der harten Abspaltung umgewandelt werden? {#scam-alert}
+
+- **Keine Aktion für deine ETH erforderlich**: Nach dem Ethereum-Pectra-Upgrade ist es nicht notwendig, deine ETH umzuwandeln oder zu aktualisieren. Ihre Kontoguthaben bleiben unverändert und die ETH, die Sie derzeit besitzen, bleiben auch nach der harten Abspaltung in der bestehenden Form zugänglich.
+- **Vorsicht vor Betrug!**
@@ -31,26 +31,28 @@ Rollups sammeln eine große Anzahl von Transaktionen, führen sie aus und überm
Rollup-Daten wurden in der Vergangenheit dauerhaft auf Ethereum gespeichert, was teuer ist. Über 90 % der Transaktionskosten, die die Nutzer für Rollups zahlen, sind auf diese Datenspeicherung zurückzuführen. Um die Transaktionskosten zu senken, können wir die Daten in einen neuen temporären "Blob"-Speicher verschieben. Blobs sind billiger, weil sie nicht dauerhaft sind; sie werden aus Ethereum gelöscht, sobald sie nicht mehr benötigt werden. Die langfristige Speicherung von Rollup-Daten liegt in der Veranwortung derjenigen, die sie benötigen, wie z. B. Rollup-Betreibern, Börsen, Indexierungsdiensten usw. Das Hinzufügen von Blob-Transaktionen zu Ethereum ist Teil eines Upgrades, das als "Proto-Danksharding" bekannt ist.
-Mit Proto-Danksharding lassen sich viele Blobs zu Ethereum-Blöcken hinzufügen. Dadurch wird eine weitere signifikante (>100x) Erhöhung des Ethereum-Durchsatzes und eine deutliche Reduzierung der Transaktionskosten möglich.
+Mit Proto-Danksharding lassen sich viele Blobs zu Ethereum-Blöcken hinzufügen. Dies ermöglicht eine weitere erhebliche (>100x) Steigerung des Ethereum-Durchsatzes und Senkung der Transaktionskosten.
### Danksharding {#danksharding}
-Die zweite Stufe der Erweiterung von Blob-Daten ist kompliziert, weil dafür neue Methoden zur Überprüfung der Verfügbarkeit von Rollup-Daten im Netz erforderlich sind. Außerdem wird dafür vorausgesetzt, dass [Validatoren](/glossary/#validator) ihre Verantwortung für [Block](/glossary/#block)-Bau und Blockvorschläge auseinanderhalten. Außerdem muss kryptografisch nachgewiesen werden, dass die Validatoren kleine Teilmengen der Blobdaten überprüft haben.
+Die zweite Stufe der Erweiterung von Blob-Daten ist kompliziert, weil sie neue Methoden zur Überprüfung der Verfügbarkeit von Rollup-Daten im Netzwerk erfordert und davon abhängt, dass [Validatoren](/glossary/#validator) ihre Zuständigkeiten für die [Block](/glossary/#block)bildung und den Blockvorschlag voneinander trennen. Außerdem muss kryptografisch nachgewiesen werden, dass die Validatoren kleine Teilmengen der Blobdaten überprüft haben.
-Dieser zweite Schritt ist bekannt unter dem Namen [“Danksharding”](/roadmap/danksharding/). **Es wird wahrscheinlich noch einige Jahre dauern, bis es zu einer vollständigen Umsetzung kommt**. Danksharding stützt sich auf andere Entwicklungen wie die [Trennung von Blockbildung und Blockvorschlag](/roadmap/pbs) und neue Netzwerkdesigns, die es dem Netzwerk ermöglichen, die Verfügbarkeit von Daten effizient zu bestätigen, indem jeweils einige Kilobyte zufällig abgetastet werden, was als [data availability sampling (DAS)](/developers/docs/data-availability) bekannt ist.
+Dieser zweite Schritt ist als ["Danksharding"](/roadmap/danksharding/) bekannt. Die Implementierungsarbeiten werden fortgesetzt, wobei Fortschritte bei Voraussetzungen wie der [Trennung von Blockerstellung und Blockvorschlag](/roadmap/pbs) und bei neuen Netzwerkdesigns gemacht werden, die es dem Netzwerk ermöglichen, die Datenverfügbarkeit durch zufälliges Abtasten einiger Kilobytes auf einmal effizient zu bestätigen, bekannt als [Data Availability Sampling (DAS)](/developers/docs/data-availability).
Mehr zu Danksharding
-## Rollups dezentralisieren {#decentralizing-rollups}
+## Dezentralisierung von Rollups {#decentralizing-rollups}
-[Rollups](/layer-2) sind bereits dabei, Ethereum zu skalieren. Ein [reichhaltiges Ökosystem von Rollup-Projekten](https://l2beat.com/scaling/tvl) ermöglicht es den Nutzern, schnell und kostengünstig Transaktionen durchzuführen und dabei eine Reihe von Sicherheitsgarantien zu bieten. Rollups wurden jedoch mit zentralisierten Sequenzern (Computer, die die gesamte Transaktionsverarbeitung und -aggregation durchführen, bevor sie an Ethereum übermittelt werden) gebootet. Dies ist anfällig für Zensur, da die Betreiber der Sequenzer sanktioniert, bestochen oder anderweitig kompromittiert werden können. Gleichzeitig unterscheiden sich [Rollups](https://l2beat.com) in der Art und Weise, wie sie die eingehenden Daten validieren. Am besten ist es, wenn die „Prüfer“ [Betrugsnachweise](/glossary/#fraud-proof) oder Gültigkeitsnachweise einreichen, aber noch sind nicht alle Rollups so weit. Selbst die Rollups, die Gültigkeits-/Betrugsnachweise verwenden, nutzen einen kleinen Pool von bekannten Prüfern. Daher besteht der nächste kritische Schritt bei der Skalierung von Ethereum darin, die Verantwortung für den Betrieb von Sequenzern und Prüfern auf mehr Personen zu verteilen.
+[Rollups](/layer-2) skalieren bereits Ethereum. Ein [reichhaltiges Ökosystem von Rollup-Projekten](https://l2beat.com/scaling/tvs) ermöglicht es Nutzern, mit einer Reihe von Sicherheitsgarantien schnell und kostengünstig Transaktionen durchzuführen. Rollups wurden jedoch mit zentralisierten Sequenzern (Computer, die die gesamte Transaktionsverarbeitung und -aggregation durchführen, bevor sie an Ethereum übermittelt werden) gebootet. Dies ist anfällig für Zensur, da die Betreiber der Sequenzer sanktioniert, bestochen oder anderweitig kompromittiert werden können. Gleichzeitig [variieren Rollups](https://l2beat.com/scaling/summary) in der Art und Weise, wie sie eingehende Daten validieren. Am besten ist es, wenn "Prover" [Betrugsbeweise](/glossary/#fraud-proof) oder Gültigkeitsnachweise einreichen, aber noch sind nicht alle Rollups so weit. Selbst die Rollups, die Gültigkeits-/Betrugsnachweise verwenden, nutzen einen kleinen Pool von bekannten Prüfern. Daher besteht der nächste kritische Schritt bei der Skalierung von Ethereum darin, die Verantwortung für den Betrieb von Sequenzern und Prüfern auf mehr Personen zu verteilen.
-Mehr zu Rollups
+Mehr über Rollups
## Aktueller Fortschritt {#current-progress}
-Proto-Danksharding ist das erste dieser Roadmap-Elemente, das im Rahmen des Netzwerk-Upgrades Cancun-Deneb („Dencun“) im März 2024 implementiert wird. **Zur vollständigen Umsetzung von Danksharding kommt es wahrscheinlich erst in einigen Jahren**, da hierfür zunächst mehrere andere Roadmap-Elemente abgeschlossen werden müssen. Die Dezentralisierung der Rollup-Infrastruktur wird wahrscheinlich ein schrittweiser Prozess sein - es gibt viele verschiedene Rollups, die leicht unterschiedliche Systeme aufbauen und in unterschiedlichem Tempo vollständig dezentralisieren werden.
+Mit dem Netzwerk-Upgrade Cancun-Deneb („Dencun“) im März 2024 erfolgte die erfolgreiche Einführung von Proto-Danksharding. Seit seiner Implementierung haben Rollups begonnen, Blob-Speicher zu nutzen, was zu geringeren Transaktionskosten für Nutzer und Millionen von in Blobs verarbeiteten Transaktionen geführt hat.
-[Weitere Informationen zum Dencun-Netzwerk-Upgrade](/roadmap/dencun/)
+Die Arbeiten an Full Danksharding werden fortgesetzt, und es werden Fortschritte bei dessen Voraussetzungen wie PBS (Proposer-Builder Separation) und DAS (Data Availability Sampling) erzielt. Die Dezentralisierung der Rollup-Infrastruktur ist ein schrittweiser Prozess – es gibt viele verschiedene Rollups, die geringfügig unterschiedliche Systeme aufbauen und sich in unterschiedlichem Tempo vollständig dezentralisieren werden.
+
+[Mehr über das Dencun-Netzwerk-Upgrade und seine Auswirkungen](/roadmap/dencun/)
Lesen Sie mehr über Auszahlungen
+Informationen zu Auszahlungen
-## Angriff abwehren {#defending-against-attacks}
+## Schutz vor Angriffen {#defending-against-attacks}
-Es gibt Verbesserungen, die am Proof-of-Stake-Protokoll von Ethereum vorgenommen werden können. Eine davon ist als [View-Merge](https://ethresear.ch/t/view-merge-as-a-replacement-for-proposer-boost/13739) bekannt – ein sicherer [Abspaltungs](/glossary/#fork)-Wahlalgorithmus, der bestimmte ausgefeilte Angriffsarten erschwert.
+Es gibt Verbesserungen, die am Proof-of-Stake-Protokoll von Ethereum vorgenommen werden können. Einer davon ist als [View-Merge](https://ethresear.ch/t/view-merge-as-a-replacement-for-proposer-boost/13739) bekannt – ein sichererer [Fork](/glossary/#fork)-Auswahlalgorithmus, der bestimmte komplexe Angriffsarten erschwert.
-Eine Verkürzung der Zeit, die Ethereum für die [Finalisierung](/glossary/#finality) von Blöcken benötigt, würde für eine bessere Benutzererfahrung sorgen. Außerdem würde sie ausgefeilte „Reorg“-Angriffe verhindern, bei denen Angreifer versuchen, kürzlich erstellte Blöcke umzuorganisieren, um Profit zu machen oder bestimmte Transaktionen zu zensieren. [**Einzelplatzendgültigkeit („Single Slot Finality“, SSF)**](/roadmap/single-slot-finality/) ist eine **Möglichkeit zur Minimierung der Finalisierungsverzögerung**. Zurzeit besteht die Möglichkeit, dass ein Angreifer andere Validierer dazu bewegt, Blöcke in einem Zeitraum von 15 Minuten neu zu konfigurieren. Mit SSF ist dieser Zeitrahmen gleich 0. Nutzer, von Einzelpersonen bis hin zu Anwendungen und Börsen, profitieren von der schnellen Gewissheit, dass ihre Transaktionen nicht rückgängig gemacht werden, und das Netzwerk profitiert davon, dass eine ganze Klasse von Angriffen unterbunden wird.
+Die Verkürzung der Zeit, die Ethereum benötigt, um Blöcke zu [finalisieren](/glossary/#finality), würde eine bessere Benutzererfahrung bieten und komplexe „Reorg“-Angriffe verhindern, bei denen Angreifer versuchen, die neuesten Blöcke neu zu ordnen, um Profit zu erzielen oder bestimmte Transaktionen zu zensieren. [**Single-Slot Finality (SSF)**](/roadmap/single-slot-finality/) ist eine **Möglichkeit, die Finalisierungsverzögerung zu minimieren**. Zurzeit besteht die Möglichkeit, dass ein Angreifer andere Validierer dazu bewegt, Blöcke in einem Zeitraum von 15 Minuten neu zu konfigurieren. Mit SSF ist dieser Zeitrahmen gleich 0. Nutzer, von Einzelpersonen bis hin zu Anwendungen und Börsen, profitieren von der schnellen Gewissheit, dass ihre Transaktionen nicht rückgängig gemacht werden, und das Netzwerk profitiert davon, dass eine ganze Klasse von Angriffen unterbunden wird.
-Lesen Sie mehr über die Endgültigkeit voneinzelnen Slots
+Informationen zu Single-Slot Finality
-## Verteidigung gegen Zensur {#defending-against-censorship}
+## Schutz vor Zensur {#defending-against-censorship}
-Durch die Dezentralisierung wird verhindert, dass Einzelpersonen oder kleine Gruppen von [Validatoren](/glossary/#validator) zu einflussreich werden. Neue Staking-Technologien können dazu beitragen, dass die Ethereum-Validatoren so dezentralisiert wie möglich bleiben und gleichzeitig vor Hardware-, Software- und Netzwerkausfällen geschützt sind. Hierzu gehört Software, die die Verantwortlichkeiten von Validatoren auf mehrere [Knoten](/glossary/#node) verteilt. Dies wird als **verteilte Validierungstechnologie (distributed validator technology / DVT)** bezeichnet. [Staking-Pools](/glossary/#staking-pool) werden zur Verwendung von DVT angeregt, da dadurch mehrere Computer gemeinsam an der Validierung teilnehmen können, was zu mehr Redundanz und Fehlertoleranz führt. Außerdem werden die Validierungsschlüssel auf mehrere Systeme aufgeteilt, anstatt dass ein einzelner Operator mehrere Validatoren betreibt. Dies erschwert es unredlichen Betreibern, Angriffe auf Ethereum zu koordinieren. Insgesamt besteht die Idee darin, Sicherheitsvorteile zu erzielen, indem die Validatoren als _Gemeinschaften_ und nicht als Einzelpersonen betrieben werden.
+Dezentralisierung verhindert, dass Einzelpersonen oder kleine Gruppen von [Validatoren](/glossary/#validator) zu einflussreich werden. Neue Staking-Technologien können dazu beitragen, dass die Ethereum-Validatoren so dezentralisiert wie möglich bleiben und gleichzeitig vor Hardware-, Software- und Netzwerkausfällen geschützt sind. Dazu gehört Software, die die Zuständigkeiten von Validatoren auf mehrere [Nodes](/glossary/#node) verteilt. Dies ist als **verteilte Validatortechnologie (DVT)** bekannt. Für [Staking-Pools](/glossary/#staking-pool) besteht ein Anreiz, DVT zu verwenden, da es mehreren Computern ermöglicht, gemeinsam an der Validierung teilzunehmen, was zu zusätzlicher Redundanz und Fehlertoleranz führt. Außerdem werden die Validierungsschlüssel auf mehrere Systeme aufgeteilt, anstatt dass ein einzelner Operator mehrere Validatoren betreibt. Dies erschwert es unredlichen Betreibern, Angriffe auf Ethereum zu koordinieren. Insgesamt besteht die Idee darin, Sicherheitsvorteile zu erzielen, indem Validatoren als _Gemeinschaften_ und nicht als Einzelpersonen betrieben werden.
-Lesen Sie mehr über verteilte Validierungstechnologie
+Informationen zur verteilten Validatortechnologie
-Die Implementierung der **Proposer-Builder-Separation (PBS)** wird die in Ethereum eingebauten Schutzmechanismen gegen Zensur drastisch verbessern. PBS ermöglicht es einem Validator, einen Block zu erstellen, und einem anderen, ihn über das Ethereum-Netzwerk zu veröffentlichen. Dadurch wird sichergestellt, dass die Gewinne aus professionellen, gewinnmaximierenden Blockbildungsalgorithmen gerechter über das Netzwerk verteilt werden und **verhindern, dass sich der Gewinn im Laufe der Zeit bei den leistungsstärksten institutionellen Stakern konzentriert**. Der Blockanbieter kann den profitabelsten Block auswählen, der ihm von einem Markt von Blockbauern angeboten wird. Um zu zensieren, müsste ein Blockvorschläger oft einen weniger profitablen Block wählen, was **wirtschaftlich betrachtet unlogisch und auch für den Rest der Validierer** im Netz offensichtlich wäre.
+Die Implementierung der **Proposer-Builder Separation (PBS)** wird die in Ethereum integrierten Schutzmechanismen gegen Zensur drastisch verbessern. PBS ermöglicht es einem Validator, einen Block zu erstellen, und einem anderen, ihn über das Ethereum-Netzwerk zu veröffentlichen. Dies stellt sicher, dass die Gewinne aus professionellen, gewinnmaximierenden Algorithmen zur Blockerstellung gerechter im Netzwerk verteilt werden, **was die Konzentration von Stakes** bei den leistungsstärksten institutionellen Stakern im Laufe der Zeit **verhindert**. Der Blockanbieter kann den profitabelsten Block auswählen, der ihm von einem Markt von Blockbauern angeboten wird. Um zu zensieren, müsste ein Block-Proposer oft einen weniger profitablen Block wählen, was **wirtschaftlich irrational und für die übrigen Validatoren** im Netzwerk **offensichtlich wäre**.
Es gibt potenzielle Erweiterungen zu PBS, wie verschlüsselte Transaktionen und Inklusionslisten, die die Zensurresistenz von Ethereum weiter verbessern könnten. Diese machen den Blockersteller und den Vorschlagenden blind für die tatsächlichen Transaktionen, die in ihren Blöcken enthalten sind.
-Lesen Sie über die Trennung von Proposer und Builder
+Informationen zur Proposer-Builder Separation
## Schutz für Validatoren {#protecting-validators}
-Es ist möglich, dass ein raffinierter Angreifer bevorstehende Prüfer identifiziert und sie mit Spam attackiert, um sie daran zu hindern, Blöcke vorzuschlagen; dies ist als **Denial of Service (DoS)** Angriff bekannt. Die Implementierung von [**secret-leader-election (SLE)**](/roadmap/secret-leader-election) schützt vor dieser Art von Angriffen, indem verhindert wird, dass die Blockvorschläger im Voraus bekannt gegeben werden. Dabei wird eine Reihe von kryptografischen Zusagen, die Kandidaten für Blockvorschläge darstellen, ständig gemischt und deren Reihenfolge verwendet, um zu bestimmen, welcher Prüfer ausgewählt wird, und zwar so, dass nur die Prüfer selbst ihre Reihenfolge im Voraus erfahren.
+Es ist möglich, dass ein raffinierter Angreifer bevorstehende Validatoren identifiziert und sie mit Spam-Nachrichten angreift, um sie daran zu hindern, Blöcke vorzuschlagen. Dies wird als **Denial-of-Service-Angriff (DoS)** bezeichnet. Die Implementierung von [**Secret Leader Election (SLE)**](/roadmap/secret-leader-election) schützt vor dieser Art von Angriff, indem verhindert wird, dass Block-Proposer im Voraus bekannt sind. Dabei wird eine Reihe von kryptografischen Zusagen, die Kandidaten für Blockvorschläge darstellen, ständig gemischt und deren Reihenfolge verwendet, um zu bestimmen, welcher Prüfer ausgewählt wird, und zwar so, dass nur die Prüfer selbst ihre Reihenfolge im Voraus erfahren.
-Lesen Sie über die geheime Wahl des Leiters
+Informationen zur Secret Leader Election
## Aktueller Fortschritt {#current-progress}
-**Die auf der Roadmap aufgeführten Sicherheitsupgrades befinden sich in fortgeschrittenen Forschungsstadien**, sie werden aber voraussichtlich erst in einiger Zeit implementiert werden. Die nächsten Schritte für view-merge, PBS, SSF und SLE sind die Fertigstellung von Spezifikationen und der Beginn der Entwicklung von Prototypen.
+**Sicherheitsupgrades auf der Roadmap befinden sich in fortgeschrittenen Forschungsphasen**, aber ihre Implementierung wird voraussichtlich erst in einiger Zeit erfolgen. Die nächsten Schritte für View-Merge, PBS, SSF und SLE sind die Finalisierung einer Spezifikation und der Beginn der Entwicklung von Prototypen.
diff --git a/public/content/translations/de/roadmap/single-slot-finality/index.md b/public/content/translations/de/roadmap/single-slot-finality/index.md
index 6770e858d5c..30e0249776e 100644
--- a/public/content/translations/de/roadmap/single-slot-finality/index.md
+++ b/public/content/translations/de/roadmap/single-slot-finality/index.md
@@ -4,9 +4,9 @@ description: Erklärung von Einzelplatzfinalität (single slot finality)
lang: de
---
-# Einzelplatzfinalität (single slot finality) {#single-slot-finality}
+# Single-Slot-Finalität {#single-slot-finality}
-Es braucht ungefähr 15 Minuten einen Ethereum Block zu finalisieren. Jedoch können wir Ethereums Konsensmechanismus Blöcke effizienter validieren lassen und dadurch die Zeit, die für das Finalisieren benötigt wird, dramatisch verringern. Statt für 15 Minuten zu warten, könnten Blöcke im selben Platz (slot) vorgeschlagen und finalisiert werden. Dieses Konzept nennt sich **Einzelplatzfinalität (SSF)**.
+Es braucht ungefähr 15 Minuten einen Ethereum Block zu finalisieren. Jedoch können wir Ethereums Konsensmechanismus Blöcke effizienter validieren lassen und dadurch die Zeit, die für das Finalisieren benötigt wird, dramatisch verringern. Statt für 15 Minuten zu warten, könnten Blöcke im selben Platz (slot) vorgeschlagen und finalisiert werden. Dieses Konzept ist als **Single-Slot-Finalität (SSF)** bekannt.
## Was ist Endgültigkeit? {#what-is-finality}
@@ -16,9 +16,9 @@ In Ethereums auf Proof-of-Stake basierenden Konsensmechanismus bezieht sich die
Die derzeitige Zeit zur Endlichkeit hat sich als zu lang herausgestellt. Die meisten Nutzer wollen nicht 15 Minuten auf Endlichkeit warten, und es ist für Anwendungen und Austausche, welche einen hohen Transaktionsdurchsatz wollen ungünstig so lange zu warten, um sicher zu sein, dass ihre Transaktionen permanent sind. Eine Verzögerung zwischen dem Vorschlagen eines Blocks und dessen Finalisierung zu haben ermöglicht auch kurze Neuorganisationen, welche ein Angreifer nutzen könnte einzelne Blöcke zu zensieren oder MEV zu extrahieren. Der Mechanismus, der das stufenweise Verbessern von Blöcken regelt, ist ebenfalls recht komplex und wurde mehrfach gepatcht, um Sicherheitslücken zu schließen, was ihn zu einem der Teile der Ethereum-Codebasis macht, in dem subtile Fehler wahrscheinlicher sind. Diese Probleme könnten alle eliminiert werden, wäre die Zeit, die für das finalisieren eines einzigen Platzes gebraucht wird, geringer.
-## Der Kompromiss von Dezentralisation / Zeit / Overhead {#the-decentralization-time-overhead-tradeoff}
+## Der Kompromiss zwischen Dezentralisierung / Zeit / Overhead {#the-decentralization-time-overhead-tradeoff}
-Die Endlichkeitsgarantie ist keine direkte Eigenschaft eines neuen Blocks; es braucht Zeit, einen neuen Block zu finalisieren. Der Grund dafür ist, dass Validatoren, die mindestens 2/3 der gesamten staked ETH auf dem Netzwerk für den Block abstimmen müssen ("Bestätigung"), dafür dass er als endlich gesehen werden kann. Jeder validierende Node auf dem Netzwerk muss Attestierungen anderer Nodes verarbeiten, um zu wissen, ob ein Block diese 2/3 Voraussetzung erreicht hat.
+Die Endlichkeitsgarantie ist keine direkte Eigenschaft eines neuen Blocks; es braucht Zeit, einen neuen Block zu finalisieren. Der Grund dafür ist, dass Validatoren, die mindestens 2/3 der gesamten gestaketen ETH im Netzwerk repräsentieren, für den Block stimmen müssen („bestätigen“), damit dieser als finalisiert gilt. Jeder validierende Node auf dem Netzwerk muss Attestierungen anderer Nodes verarbeiten, um zu wissen, ob ein Block diese 2/3 Voraussetzung erreicht hat.
Je kürzer die Zeit zur Endlichkeit ist, desto mehr Rechenleistung wird an jedem einzelnen Node benötigt, da die Attestierung schneller verarbeitet werden muss. Außerdem müssen mit mehr validierenden Nodes auch mehr Attestierungen für jeden Block verarbeitet, was auch die benötigte Gesamtrechenleistung erhöht. Je mehr Rechenleistung benötigt wird, desto weniger Menschen können sich ins Ethereum Netzwerk einbringen, da teurere Hardware benötigt wird, um jeden validierenden Node zu betreiben. Die Zeit zwischen Blöcken zu erhöhen, verringert die an jedem Node benötigte Rechenleistung, erhöht jedoch auch die Zeit zu Endlichkeit, da mehr Attestierungen langsam verarbeitet werden.
@@ -33,34 +33,33 @@ Mit dem derzeitigen Aufbau des Mechanismus müssen, um die Zeit zur Endlichkeit
## Wege zu SSF {#routes-to-ssf}
-
+
Der derzeitige Konsensmechanismus verbindet Attestierungen mehrerer Validatoren, welche Komitees genannt werden, um die Anzahl an Nachrichten, die jeder Validator in einem Block verarbeiten muss, um jenen zu validieren, zu verringern. Jeder Validator hat in jeder Epoche (32 Plätze) die Möglichkeit zur Attestierung. In jedem Platz haben jedoch nur eine Untergruppe von Validatoren, bekannt als Komitee-Attestierung diese Möglichkeit. Das machen sie, indem sie in Unternetzwerke unterteilt werden, in denen wenige Validatoren als "Aggregatoren" ausgewählt werden. Diese Aggregatoren verbinden alle die Unterschriften, welche sie von anderen Validatoren bekommen in, in ihrem Netzwerk zu einer einzelnen aggregierten Unterschrift. Der Aggregator, welcher die größte Anzahl an einzelnen Teilnahmen beinhaltet, gibt dann die aggregierte Unterschrift an den Blockantragsteller (Block Proposer) weiter, welcher sie dann in seinem Block mit den aggregierten Unterschriften anderer Komitees einschließt.
-Dieser Prozess gibt für jeden Validatoren ausreichende Kapazität, in jeder Epoche abzustimmen, da 32 Plätze * 64 Komitees * 256 Validator pro Komitee 524 288 Validatoren pro Epoche ergeben. Zum Zeitpunkt der Erstellung dieses Artikels (Februar 2023) gibt es ~513 000 aktive Validatoren.
+Dieser Prozess gibt für jeden Validatoren ausreichende Kapazität, in jeder Epoche abzustimmen, da 32 Plätze \* 64 Komitees \* 256 Validator pro Komitee 524 288 Validatoren pro Epoche ergeben. Zum Zeitpunkt der Erstellung dieses Artikels (Februar 2023) gibt es ~513 000 aktive Validatoren.
-In diesem Schema ist es für jeden Validatoren möglich für einen Block abzustimmen, indem er seine Attestierungen über die gesamte Epoche verteilen. Jedoch gibt es potentielle Wege diesen Mechanismus zu verbessern, sodass _jeder Validator die Chance hat in jedem Platz zu attestieren_.
-
+In diesem Schema ist es für jeden Validatoren möglich für einen Block abzustimmen, indem er seine Attestierungen über die gesamte Epoche verteilen. Jedoch gibt es potentielle Wege diesen Mechanismus zu verbessern, sodass _jeder Validator die Chance hat in jedem Platz zu attestieren_.
Seit der Ethereum Konsensmechanismus entwickelt wurde, hat sich das Unterschriften-Aggregationsschema (BLS) als deutlich skalierbarer als erwartet erwiesen, dabei wurde auch die Fähigkeit von Clients, die Unterschriften zu verarbeiten und unterschreiben, verbessert. Es stellt sich heraus, dass das Verarbeiten von Attestierungen in großer Anzahl von Validatoren in einem einzelnen Platz möglich ist. Zum Beispiel müssten Nodes, bei einer Million Validatoren, die zweimal pro Platz wählen und dem Verändern von der Zeit pro Slot (Platz) auf 16 Sekunden, Unterschriften mit mindestens 125 000 Aggregationen pro Sekunde funktionieren, um alle Attestierungen innerhalb des Platzes zu verarbeiten. In Wirklichkeit benötigt ein gewöhnlicher Computer ungefähr 500 Nanosekunden um eine Unterschrift zu verifizieren, das heißt, dass 125 000 Verifikationen in ~62,5 ms durchgeführt werden könnten. Das wäre weit unter der Ein-Sekunden-Grenze.
-Weitere Effizienzgewinne könnten durch die Erstellung von Superkomitees von beispielsweise 125 000 zufällig gewählten Validatoren pro Platz erreicht werden. Nur diese Validatoren könnten für einen Block abstimmen und dadurch könnte nur eine Untermenge an Validatoren entscheiden, ob ein Block endlich ist. Ob das eine gute Idee ist, kommt darauf an, wie teuer ein Angriff auf Ethereum nach der Community sein sollte. Das liegt daran, dass Angreifer einen unehrlichen Block statt mit 2/3 der gesamten staked Ether mit 2/3 der staked Ether _in diesem Superkomitee_ finalisieren könnten. Dies ist immer noch ein aktives Forschungsgebiet, jedoch scheint es plausibel, dass für eine Validatorenmenge, die groß genug wäre um Superkomitees zu brauchen, würden die Kosten für das Angreifen eines dieser Superkomitees extrem hoch sein (Zum Beispiel beträgen die ETH genannten Kosten eines Angriffs `2/3 * 125 000 * 32 = ~2,6 Millionen ETH`). Die Kosten eines Angriffs können angepasst werden, indem die Größe einer einzelnen Validatorenmenge (z.B. das Anpassen der Validatorengröße, sodass der Angriff 1 Million Ether, 4 Millionen Ether, 10 Millionen Ether, etc. kosten würde). [Vorläufige Abstimmungen](https://youtu.be/ojBgyFl6-v4?t=755) der Community legen nahe, dass 1-2 Millionen Ether akzeptable Angriffskosten darstellen würden, das bedeutet, man bräuchte ~65 636 - ~97 152 Validatoren pro Superkomitee.
+Weitere Effizienzgewinne könnten durch die Einrichtung von Supercommittees aus z. B. 125.000 zufällig ausgewählten Validatoren pro Slot erzielt werden. Nur diese Validatoren könnten für einen Block abstimmen und dadurch könnte nur eine Untermenge an Validatoren entscheiden, ob ein Block endlich ist. Ob das eine gute Idee ist, kommt darauf an, wie teuer ein Angriff auf Ethereum nach der Community sein sollte. Das liegt daran, dass ein Angreifer anstelle von 2/3 des gesamten gestaketen Ethers einen unehrlichen Block mit 2/3 des gestaketen Ethers _in diesem Supercommittee_ finalisieren könnte. Dies ist nach wie vor ein aktives Forschungsgebiet, aber es scheint plausibel, dass bei einem Validator-Set, das groß genug ist, um überhaupt Supercommittees zu benötigen, die Kosten für einen Angriff auf eines dieser Subcommittees extrem hoch sein werden (z. B. würden die auf ETH lautenden Angriffskosten `2/3 * 125.000 * 32 = ~2,6 Millionen ETH` betragen). Die Angriffskosten können durch eine Erhöhung der Größe des Validator-Sets angepasst werden (z. B. durch Anpassen der Validator-Größe, sodass die Angriffskosten 1 Million Ether, 4 Millionen Ether, 10 Millionen Ether usw. betragen). [Vorläufige Umfragen](https://youtu.be/ojBgyFl6-v4?t=755) in der Community deuten darauf hin, dass 1–2 Millionen Ether akzeptable Angriffskosten sind, was ~65.536–97.152 Validatoren pro Supercommittee impliziert.
-Jedoch ist die Verifikation noch nicht das wahre Problem, die Aggregation von Unterschriften ist was Validatoren Nodes wirklich herausfordert. Um die Aggregation der Unterschriften zu skalieren, muss man wahrscheinlich die Validatorenmenge jedes Unternetzwerks oder die Anzahl an Unternetzwerke erhöhen oder zusätzliche Ebenen der Aggregation hinzufügen (d.h. Komitees von Komitees zu implementieren). Ein Teil der Lösung könnte das Erlauben von spezialisierten Aggregatoren sein - ähnlich dazu wie das Blockerzeugen und das Generieren von Verpflichtungen für Rollup Daten zu spezialisierten Blockerzeugern unter Proposer-Builder Separation (PBS) und Danksharding ausgelagert wird.
+Jedoch ist die Verifikation noch nicht das wahre Problem, die Aggregation von Unterschriften ist was Validatoren Nodes wirklich herausfordert. Um die Signaturaggregation zu skalieren, muss wahrscheinlich die Anzahl der Validatoren in jedem Subnetz erhöht, die Anzahl der Subnetze erhöht oder zusätzliche Aggregationsebenen hinzugefügt werden (d. h. es werden Komitees von Komitees implementiert). Ein Teil der Lösung könnte das Erlauben von spezialisierten Aggregatoren sein - ähnlich dazu wie das Blockerzeugen und das Generieren von Verpflichtungen für Rollup Daten zu spezialisierten Blockerzeugern unter Proposer-Builder Separation (PBS) und Danksharding ausgelagert wird.
-## Was ist die Rolle der Abspaltungsregel (fork-choice rule) innerhalb SSF? {#role-of-the-fork-choice-rule}
+## Was ist die Rolle der Abspaltungsregel (fork-choice rule) innerhalb SSF? Rolle der Fork-Choice-Regel {#role-of-the-fork-choice-rule}
-Der heutige Konsensmechanismus beruht auf engen Verbindungen zwischen dem Finality Gadget (Algorithmus, welcher bestimmt ob 2/3 der Validatoren eine bestimmte Kette attestiert haben) und der Abspaltungsregel (Algorithmus, der bestimmt welche Kette die richtige ist, sollte es mehrere geben). Der Abspaltungsalgorithmus (fork choice algorithm) betrachtet nur Blöcke _seit_ dem letzten finalisierten Block. Unter SSF gäbe es keine Blöcke, welche die Abspaltungsregel erwähnen müsste, da die Endgültigkeit im selben Slot, in der der Block vorgeschlagen wurde, aufkommt. Das bedeutet, dass unter SSF _entweder_ der Abspaltungsalgorithmus _oder_ das Finality Gadget zu jeder Zeit aktiv sein müssten. Das Finality Gadget würde Blöcke, bei denen 2/3 der Validatoren online sind und ehrlich attestieren finalisieren. Wenn ein Block die 2/3 Grenze nicht überschreiten könnte, würde die Abspaltungsregel bestimmen welcher Kette zu folgen ist. Das erzeugt auch eine Möglichkeit den Inaktivität-Leck-Mechanismus, welcher eine Kette wiederherstellt, bei der >1/3 der Validatoren offline gegangen sind, wenn auch mit einigen zusätzlichen Nuancen.
+Der heutige Konsensmechanismus beruht auf engen Verbindungen zwischen dem Finality Gadget (Algorithmus, welcher bestimmt ob 2/3 der Validatoren eine bestimmte Kette attestiert haben) und der Abspaltungsregel (Algorithmus, der bestimmt welche Kette die richtige ist, sollte es mehrere geben). Der Fork-Choice-Algorithmus berücksichtigt nur Blöcke _seit_ dem letzten finalisierten Block. Unter SSF gäbe es keine Blöcke, welche die Abspaltungsregel erwähnen müsste, da die Endgültigkeit im selben Slot, in der der Block vorgeschlagen wurde, aufkommt. Das bedeutet, dass unter SSF _entweder_ der Fork-Choice-Algorithmus _oder_ das Finality-Gadget jederzeit aktiv wäre. Das Finality Gadget würde Blöcke, bei denen 2/3 der Validatoren online sind und ehrlich attestieren finalisieren. Wenn ein Block die 2/3 Grenze nicht überschreiten könnte, würde die Abspaltungsregel bestimmen welcher Kette zu folgen ist. Dies schafft auch die Möglichkeit, den Mechanismus des Inaktivitäts-Lecks beizubehalten, der eine Kette wiederherstellt, bei der >1/3 der Validatoren offline gehen, wenn auch mit einigen zusätzlichen Nuancen.
-## Offenstehende Probleme {#outstanding-issues}
+## Offene Fragen {#outstanding-issues}
-Das Problem mit dem Skalieren von Aggregationen mit einer Erhöhung der Validatorenmenge pro Unternetz ist, dass es zu einer größeren Last auf dem Peer-to-Peer Netzwerk führt. Das Problem damit, Ebenen der Aggregation hinzuzufügen, ist, dass es sehr komplex aufzubauen ist und Verzögerungen mit sich bringt (d.h. es könnte für einen Block Proposer länger dauern von allen Unternetz-Aggregatoren zu hören). Es ist auch nicht klar, wie man mit dem Szenario umgeht, dass mehr aktive Validatoren auf dem Netzwerk sind, als in jedem Platz verarbeitbar sind, sogar mit der BLS Unterschriftenaggregation. Eine mögliche Lösung ist das, da alle Validatoren in jedem Platz attestieren müssen und es keine Komitees unter SSF gibt. Das 32 ETH Limit zum effektiven Guthaben könnte komplett entfernt werden, was bedeutet, dass Operatoren, welche mehrere Validatoren verwalten ihren Staking Einsatz konsolidieren und weniger laufen könnten. Das würde die Anzahl der Nachrichten, welche validierende Nodes verarbeiten müssen, um alle Validatoren zu berücksichtigen reduzieren. Das beruht auf große Staker, welche zustimmen ihre Validatoren zu konsolidieren. Es ist auch möglich eine Obergrenze für die Anzahl an Validatoren oder der Anzahl von staked ETH zu jeder Zeit festzulegen. Jedoch erfordert dies irgendeinen Mechanismus, um zu entscheiden, welche Validatoren erlaubt sind teilzunehmen und welche nicht, was verantwortlich für das Erzeugen ungewollter Nebeneffekte ist.
+Das Problem mit dem Skalieren von Aggregationen mit einer Erhöhung der Validatorenmenge pro Unternetz ist, dass es zu einer größeren Last auf dem Peer-to-Peer Netzwerk führt. Das Problem beim Hinzufügen von Aggregationsebenen ist, dass die Entwicklung sehr komplex ist und Latenz hinzufügt (d. h., es könnte länger dauern, bis der Block-Vorschlagende von allen Subnetz-Aggregatoren eine Rückmeldung erhält). Es ist auch nicht klar, wie man mit dem Szenario umgeht, dass mehr aktive Validatoren auf dem Netzwerk sind, als in jedem Platz verarbeitbar sind, sogar mit der BLS Unterschriftenaggregation. Eine mögliche Lösung ist das, da alle Validatoren in jedem Platz attestieren müssen und es keine Komitees unter SSF gibt. Das 32 ETH Limit zum effektiven Guthaben könnte komplett entfernt werden, was bedeutet, dass Operatoren, welche mehrere Validatoren verwalten ihren Staking Einsatz konsolidieren und weniger laufen könnten. Das würde die Anzahl der Nachrichten, welche validierende Nodes verarbeiten müssen, um alle Validatoren zu berücksichtigen reduzieren. Das beruht auf große Staker, welche zustimmen ihre Validatoren zu konsolidieren. Es ist auch möglich eine Obergrenze für die Anzahl an Validatoren oder der Anzahl von staked ETH zu jeder Zeit festzulegen. Jedoch erfordert dies irgendeinen Mechanismus, um zu entscheiden, welche Validatoren erlaubt sind teilzunehmen und welche nicht, was verantwortlich für das Erzeugen ungewollter Nebeneffekte ist.
## Aktueller Fortschritt {#current-progress}
-SSF ist in der Forschungsphase. Es ist davon auszugehen, dass ihre Veröffentlichung noch einige Jahre auf sich warten lässt. Wahrscheinlich wird es erst nach anderen wesentlichen Upgrades wie [Verkle Trees](/roadmap/verkle-trees/) und [Danksharding](/roadmap/danksharding/) dazu kommen.
+SSF ist in der Forschungsphase. Es wird nicht erwartet, dass es vor einigen Jahren ausgeliefert wird, wahrscheinlich nach anderen wesentlichen Upgrades wie [Verkle-Trees](/roadmap/verkle-trees/) und [Danksharding](/roadmap/danksharding/).
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
-- [Vitalik zu SSF auf der EDCON 2022](https://www.youtube.com/watch?v=nPgUKNPWXNI)
-- [Vitaliks Notizen: Wege zur Einzelplatzfinalität (SSF)](https://notes.ethereum.org/@vbuterin/single_slot_finality)
+- [Vitalik über SSF bei der EDCON 2022](https://www.youtube.com/watch?v=nPgUKNPWXNI)
+- [Vitaliks Notizen: Wege zur Single-Slot-Finalität](https://notes.ethereum.org/@vbuterin/single_slot_finality)
diff --git a/public/content/translations/de/roadmap/statelessness/index.md b/public/content/translations/de/roadmap/statelessness/index.md
index f6b7e6711a2..a05c63395b4 100644
--- a/public/content/translations/de/roadmap/statelessness/index.md
+++ b/public/content/translations/de/roadmap/statelessness/index.md
@@ -4,7 +4,7 @@ description: Erklärung vom Verfall des Vergangenen (history expiry) und der Zus
lang: de
---
-# Zustandslosigkeit, Zustandsverfall und Verfall des Vergangenen (history expiry) {#statelessness}
+# Zustandslosigkeit, Zustandsablauf und Historienablauf {#statelessness}
Die Möglichkeit Ethereum Nodes auf einfacher Hardware betreiben zu können ist für wahre Dezentralisation entscheidend. Das liegt daran, dass das Betreiben eines Nodes Nutzern die Möglichkeit gibt Informationen verifizieren zu können, indem sie kryptografische Überprüfungen unabhängig ausführen können, statt von den Daten eines Dritten abhängig zu sein. Einen Node zu betreiben erlaubt Nutzern Transaktionen direkt zum Ethereum Peer-to-Peer Netzwerk einzuschicken, statt einem Vermittler vertrauen zu müssen. Dezentralisation ist nicht möglich, wenn diese Vorteile nur Nutzern mit teurer Hardware zur Verfügung stehen. Stattdessen sollten Nodes in der Lage sein, mit extrem einfachen Rechen- und Speichervoraussetzungen betrieben zu werden. Dadurch könnten sie auf Handys, Mikrocomputern oder unbemerkt auf einem Standrechner laufen.
@@ -12,18 +12,18 @@ Heute ist der hohe Speicherplatzbedarf das, was den Zugriff auf Nodes für alle
Günstigere Festplatten können für das Speichern alter Daten verwendet werden, sie sind jedoch zu langsam, um mit eingehenden Blöcken mithalten zu können. Die Beibehaltung der aktuellen Speichermodelle für Clients, bei gleichzeitiger Verbilligung und Vereinfachung der Datenspeicherung ist nur eine vorübergehende und partielle Lösung des Problems, da das Zustandswachstum von Ethereum "unbegrenzt" ist, was bedeutet, dass die Speicheranforderungen immer weiter steigen werden und die technologischen Verbesserungen immer mit dem kontinuierlichen Zustandswachstum Schritt halten müssen. Stattdessen müssen Klienten einen neuen Weg finden, Blöcke und Transaktionen zu verifizieren, während keine Daten von lokalen Datenbanken gespeichert werden müssen.
-## Speicherreduzierung für Nodes {#reducing-storage-for-nodes}
+## Reduzierung des Speichers für Nodes {#reducing-storage-for-nodes}
Es gibt verschiedene Wege, um die Datenmengen, die jeder Knoten speichern muss, zu reduzieren. Für jede dieser Möglichkeiten muss Ethereums Kernprotokoll in unterschiedlichem Umfang aktualisiert werden:
-- **Verfall des Vergangenen (history expiry)**: Dies ermöglicht Nodes Zustandsdaten, welche älter als X Blöcke sind, wegzuschmeißen, jedoch verändert es nicht, wie Ethereums Client mit Zustandsdaten umgeht
-- **Zustandsverfall** Dies erlaubt Daten, welche selten verwendet werden, inaktiv zu werden. Inaktive Daten können von Clients ignoriert werden, bis sie wiederbelebt werden.
-- **Schwache Zustandslosigkeit**: Hier müssen nur Blockproduzenten Zugriff auf die vollständigen Zustandsdaten haben, andere Nodes können Blöcke ohne eine lokale Zustandsdatenbank verifizieren.
-- **Starke Zustandslosigkeit**: Hier können keine Nodes auf die vollständigen Zustandsdaten zugreifen.
+- **Historienablauf**: Ermöglicht Nodes, Zustandsdaten zu verwerfen, die älter als X Blöcke sind, ändert aber nichts daran, wie Ethereum-Clients mit Zustandsdaten umgehen.
+- **Zustandsablauf**: Ermöglicht, dass Zustandsdaten, die nicht häufig verwendet werden, inaktiv werden. Inaktive Daten können von Clients ignoriert werden, bis sie wiederbelebt werden.
+- **Schwache Zustandslosigkeit**: Nur Block-Produzenten benötigen Zugriff auf die vollständigen Zustandsdaten, andere Nodes können Blöcke ohne eine lokale Zustandsdatenbank verifizieren.
+- **Starke Zustandslosigkeit**: Keine Nodes benötigen Zugriff auf die vollständigen Zustandsdaten.
-## Datenverfall {#data-expiry}
+## Datenablauf {#data-expiry}
-### Verfall des Vergangenen (history expiry) {#history-expiry}
+### Historienablauf {#history-expiry}
Dass das Vergangene verfällt, bedeutet im Einfachen, dass Clients ältere Daten, die sie unwahrscheinlich brauchen werden, abschneiden. Dadurch müssen sie nur noch kleine Mengen der vergangenen Daten behalten und können alte Daten wegschmeißen, sobald neue hinzugefügt werden. Es gibt zwei Gründe dafür, dass Clients veraltete Daten brauchen könnten: dem Synchronisieren und Bedienen von Datenanfragen. Früher mussten Clients vom jeden Block Genesis bis zum Kopf der Kette synchronisieren und dabei alle nach Richtigkeit überprüfen. Heute nutzen Clients "schwache subjektive Kontrollpunkte" um ihren Weg an die Spitze der Blockchain zu bootstrappen. Diese Kontrollpunkte sind vertraute Startpunkte, als würde man den Genesis Block näher die Gegenwart statt dem Startpunkt von Ethereum legen. Das bedeutet, dass Clients alle Informationen vor ihrem letzten schwachen subjektiven Kontrollpunkt löschen können, ohne dabei die Fähigkeit zu verlieren, den Kopf der Kette zu synchronisieren. Clients liefern zurzeit Anfragen (die über JSON-RPC ankommen) für vergangene Daten, indem sie sie von ihren lokalen Datenbanken nehmen. Jedoch wird das mit dem Verfall des Vergangenen nicht möglich sein, wenn die angefragten Daten abgeschnitten wurden. Um diese vergangenen Daten zu liefern, bedarf es innovativer Lösungen.
@@ -35,16 +35,16 @@ EIP-4444 ist bis jetzt nicht bereit, aber unter aktiver Diskussion. Interessante
Dieses Upgrade ändert nicht die fundamentale Art der Ethereum Nodes, Zustandsdaten zu speichern, sondern nur die Art auf vergangene Daten zuzugreifen.
-### Zustandsverfall {#state-expiry}
+### Zustandsablauf {#state-expiry}
Zustandsverfall bezieht sich auf das Entfernen der Zustände von individuellen Nodes, wenn sie nicht vor kurzer Zeit aufgerufen wurden. Es gibt mehrere Wege, wie das implementiert werden könnte, dazu gehören:
-- **Verfall nach Leihe**: Das bedeutet, dass von Accounts "Leihgebühren" verlangt und sie verfallen lässt sollten sie Null erreichen
-- **Verfall nach Zeit**: Account inaktiv machen, wenn auf ihnen seit einer bestimmten Zeit kein Lesen/Schreiben mehr stattfindet
+- **Ablauf durch Miete**: Erhebung einer "Miete" von Konten und deren Ablauf, wenn die Miete Null erreicht
+- **Ablauf nach Zeit**: Konten werden inaktiv, wenn für einen bestimmten Zeitraum keine Lese- oder Schreibvorgänge auf dieses Konto stattfinden.
-Der Verfall nach Leihe könnte eine direkt eingezogene Leihgebühr sein, welche die Accounts in der Datenbank der aktiven Zustände behält. Der Verfall nach Zeit könnte ein Countdown seit der letzten Account-Interaktion, oder ein periodischer Verfall aller Accounts sein. Es könnte auch Mechanismen geben, welche beide Elemente der Zeit- und Leihbasierenden Modelle miteinander verbindet. Zum Beispiel könnten individuelle Accounts im aktiven Zustand verbleiben, wenn sie einen kleinen Betrag vor dem Datum ihres Verfalls zahlen. Mit dem Zustandsverfall ist es wichtig zu beachten, dass inaktive Zustände **nicht gelöscht**, sondern einfach separat vom aktiven Zustand gespeichert werden. Der inaktive Zustand kann einfach wieder in den aktiven Zustand gebracht werden.
+Der Verfall nach Leihe könnte eine direkt eingezogene Leihgebühr sein, welche die Accounts in der Datenbank der aktiven Zustände behält. Der Verfall nach Zeit könnte ein Countdown seit der letzten Account-Interaktion, oder ein periodischer Verfall aller Accounts sein. Es könnte auch Mechanismen geben, welche beide Elemente der Zeit- und Leihbasierenden Modelle miteinander verbindet. Zum Beispiel könnten individuelle Accounts im aktiven Zustand verbleiben, wenn sie einen kleinen Betrag vor dem Datum ihres Verfalls zahlen. Beim Zustandsablauf ist es wichtig zu beachten, dass der inaktive Zustand **nicht gelöscht** wird, sondern nur getrennt vom aktiven Zustand gespeichert wird. Der inaktive Zustand kann einfach wieder in den aktiven Zustand gebracht werden.
-Das würde wahrscheinlich durch Zustandsbäume für verschiedene Zeiträume (vielleicht ~1 Jahr) funktionieren. Wenn ein neuer Zeitraum beginnt, beginnt auch ein neuer Zustandsbaum. Nur der derzeitige Zustandsbaum kann modifiziert werden, alle anderen sind unveränderlich. Von Ethereum Nodes wird erwartet, den derzeitigen und letzten Zustandsbaum zu halten. Die erfordert eine Möglichkeit einer Adresse einen Zeitstempel mit der zugehörigen Periode zu geben. Es gibt [mehrere Möglichkeiten](https://ethereum-magicians.org/t/types-of-resurrection-metadata-in-state-expiry/6607) dies zu machen, die führende Option erfordert jedoch [das Verlängern von Adressen](https://ethereum-magicians.org/t/increasing-address-size-from-20-to-32-bytes/5485), um die zusätzlichen Informationen unterzubringen. Das hätte den zusätzlichen Vorteil, dass längere Adressen sicherer wären. Das Roadmap-Eintrag, welcher dies macht, nennt sich [Ethereum Raumerweiterung](https://ethereum-magicians.org/t/increasing-address-size-from-20-to-32-bytes/5485).
+Das würde wahrscheinlich durch Zustandsbäume für verschiedene Zeiträume (vielleicht ~1 Jahr) funktionieren. Wenn ein neuer Zeitraum beginnt, beginnt auch ein neuer Zustandsbaum. Nur der derzeitige Zustandsbaum kann modifiziert werden, alle anderen sind unveränderlich. Von Ethereum Nodes wird erwartet, den derzeitigen und letzten Zustandsbaum zu halten. Die erfordert eine Möglichkeit einer Adresse einen Zeitstempel mit der zugehörigen Periode zu geben. Es gibt [mehrere mögliche Wege](https://ethereum-magicians.org/t/types-of-resurrection-metadata-in-state-expiry/6607), dies zu tun, aber die führende Option erfordert eine [Verlängerung der Adressen](https://ethereum-magicians.org/t/increasing-address-size-from-20-to-32-bytes/5485), um die zusätzlichen Informationen unterzubringen, mit dem zusätzlichen Vorteil, dass längere Adressen viel sicherer sind. Der Fahrplanpunkt, der dies umsetzt, wird als [Erweiterung des Adressraums](https://ethereum-magicians.org/t/increasing-address-size-from-20-to-32-bytes/5485) bezeichnet.
Ähnlich zum Verfallen des Vergangenen würde die Verantwortung für das Speichern alter Daten für individuelle Nutzer wegfallen und auf andere Entitäten wie zentralisierten Anbieter, selbstlosen Mitgliedern der Community oder futuristischeren dezentralen Lösungsansätzen wie dem Portal Netzwerk verteilt.
@@ -56,7 +56,7 @@ Zustandslosigkeit ist fast eine falsche Bezeichnung, da nicht das Konzept des Zu
- Beinahe direkte Synchronisation
- Die Fähigkeit Blöcke ohne Reihenfolge zu validieren
-- Das Betreiben von Nodes mit sehr geringen Hardware Voraussetzung (z.B. Handys)
+- Nodes, die mit sehr geringen Hardwareanforderungen (z. B. auf Handys) laufen können
- Das Betreiben von Nodes auf günstigen Festplatten, da kein schreiben/lesen auf dem Speicher nötig ist
- Kompatibilität mit zukünftigen Verbesserungen der Kryptographie Ethereums
@@ -66,14 +66,13 @@ Schwache Zustandslosigkeit beinhaltet Änderungen dazu, wie Ethereum Nodes Zusta
**Bei der schwachen Zustandslosigkeit brauchen Blöcke Zugriff auf die vollen Zustandsdaten, jedoch benötigt das Verifizieren von Blöcken keine Zustandsdaten**
-Damit dies passieren kann, müssen [Verkle Trees](/roadmap/verkle-trees/) bereits in Ethereum Clients implementiert sein. Verkle-Bäume sind eine Datenersetzungsstruktur um Ethereums Zustandsdaten zu speichern. Sie erlauben kleine "Zeugen" fester Größe, die dazu da sind Daten zwischen Peers zu vermitteln und Blöcke direkt, anstatt gegen lokale Datenbanken zu verifizieren. [Proposer-Builder Separation](/roadmap/pbs/) wird zudem benötigt, da es Blockerzeugern erlaubt spezialisierte Nodes mit leistungsfähigerer Hardware zu sein und da sie es sind, die Zugriff auf die vollen Zustandsdaten brauchen.
+Damit dies geschehen kann, müssen [Verkle-Trees](/roadmap/verkle-trees/) bereits in Ethereum-Clients implementiert worden sein. Verkle-Bäume sind eine Datenersetzungsstruktur um Ethereums Zustandsdaten zu speichern. Sie erlauben kleine "Zeugen" fester Größe, die dazu da sind Daten zwischen Peers zu vermitteln und Blöcke direkt, anstatt gegen lokale Datenbanken zu verifizieren. [Proposer-Builder Separation](/roadmap/pbs/) ist ebenfalls erforderlich, da dies Block-Buildern ermöglicht, spezialisierte Nodes mit leistungsstärkerer Hardware zu sein, und genau diese benötigen Zugriff auf die vollständigen Zustandsdaten.
-
+
Zustandslosigkeit stützt sich auf Blockerzeuger, welche eine Kopie der vollen Zustandsdaten pflegen, sodass sie Zeugen generieren können, welche genutzt werden um Blöcke zu verifizieren. Andere Nodes müssen die Zustandsdaten nicht abrufen, da alle benötigten Informationen für das Verifizieren eines Blocks im Zeugen vorhanden sind. Das erzeugt eine Situation, in der das Vorschlagen eines Blocks teuer, das Verifizieren jedoch günstig ist, was bedeutet, das weniger Operatoren einen blockvorschlagenden Node betreiben werden. Jedoch ist die Dezentralisation von Block Proposern nicht kritisch, solange möglichst viele Teilnehmende unabhängig voneinander verifizieren können, dass der vorgeschlagene Block valide ist.
-Lesen Sie mehr in Dankrads Notizen
-
+Lesen Sie mehr in Dankrads Notizen
Block Proposer nutzen die Zustandsdaten, um "Zeugen" zu erzeugen - die minimale Menge an Daten, die die Werte des Zustands beweisen, welche während einer Transaktion in einem Block geändert werden. Andere Validatoren halten nicht den Zustand, sie speichern nur die Wurzel des Zustands (state root) (einen Hash des gesamten Zustands). Sie erhalten einen Block und einen Zeugen und nutzen diese, um ihre Wurzel des Zustands zu aktualisieren. Das macht einen validierenden Node extrem leichtgewichtig.
@@ -87,17 +86,19 @@ Starke Zustandslosigkeit wurde von Forschern untersucht, wird aber wahrscheinlic
## Aktueller Fortschritt {#current-progress}
-Schwache Zustandslosigkeit, Verfall des Vergangenen und Zustandsverfall sind alle in der Forschungsphase und können voraussichtlich in einigen Jahren ausgesendet werden. Es gibt keine Garantie dafür, dass all diese Vorschläge implementiert werden, zum Beispiel wird es eventuell nicht nötig sein den Verfall des Vergangenen nach dem Zustandsverfall zu implementieren. Es gibt auch andere Punkte der Roadmap, so wie [Verkle Bäume](/roadmap/verkle-trees) und [Proposer-Builder Separation](/roadmap/pbs), welche zuerst fertiggestellt werden müssen.
+Schwache Zustandslosigkeit, Verfall des Vergangenen und Zustandsverfall sind alle in der Forschungsphase und können voraussichtlich in einigen Jahren ausgesendet werden. Es gibt keine Garantie dafür, dass all diese Vorschläge implementiert werden, zum Beispiel wird es eventuell nicht nötig sein den Verfall des Vergangenen nach dem Zustandsverfall zu implementieren. Es gibt auch andere Fahrplanpunkte, wie [Verkle-Trees](/roadmap/verkle-trees) und die [Proposer-Builder Separation](/roadmap/pbs), die zuerst abgeschlossen werden müssen.
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
-- [Vitalik Zustandslosigkeit AMA](https://www.reddit.com/r/ethereum/comments/o9s15i/impromptu_technical_ama_on_statelessness_and/)
-- [Eine Theorie der Zustandsgrößenverwaltung](https://hackmd.io/@vbuterin/state_size_management)
-- [Die Konflikt-minimierte Zustandsbünde wiederherstellen](https://ethresear.ch/t/resurrection-conflict-minimized-state-bounding-take-2/8739)
-- [Wege zur Zustandslosigkeit und zum Zustandsverfall](https://hackmd.io/@vbuterin/state_expiry_paths)
+- [Was ist zustandsloses Ethereum?](https://stateless.fyi/)
+- [Vitaliks AMA zur Zustandslosigkeit](https://www.reddit.com/r/ethereum/comments/o9s15i/impromptu_technical_ama_on_statelessness_and/)
+- [Eine Theorie zur Verwaltung der Zustandsgröße](https://hackmd.io/@vbuterin/state_size_management)
+- [Resurrection-conflict-minimized state bounding](https://ethresear.ch/t/resurrection-conflict-minimized-state-bounding-take-2/8739)
+- [Wege zur Zustandslosigkeit und zum Zustandsablauf](https://hackmd.io/@vbuterin/state_expiry_paths)
- [EIP-4444 Spezifikation](https://eips.ethereum.org/EIPS/eip-4444)
-- [Alex Stokes zu EIP-4444](https://youtu.be/SfDC_qUZaos)
-- [Warum es so wichtig ist zustandslos zu werden](https://dankradfeist.de/ethereum/2021/02/14/why-stateless.html)
-- [Die originalen zustandsloser Client Konzeptnotizen](https://ethresear.ch/t/the-stateless-client-concept/172)
-- [Mehr zum Zustandsverfall](https://hackmd.io/@vbuterin/state_size_management#A-more-moderate-solution-state-expiry)
-- [Noch mehr zum Zustandsverfall](https://hackmd.io/@vbuterin/state_expiry_paths#Option-2-per-epoch-state-expiry)
+- [Alex Stokes über EIP-4444](https://youtu.be/SfDC_qUZaos)
+- [Warum es so wichtig ist, zustandslos zu werden](https://dankradfeist.de/ethereum/2021/02/14/why-stateless.html)
+- [Die ursprünglichen Konzeptnotizen zum zustandslosen Client](https://ethresear.ch/t/the-stateless-client-concept/172)
+- [Mehr zum Zustandsablauf](https://hackmd.io/@vbuterin/state_size_management#A-more-moderate-solution-state-expiry)
+- [Noch mehr zum Zustandsablauf](https://hackmd.io/@vbuterin/state_expiry_paths#Option-2-per-epoch-state-expiry)
+- [Informationsseite zu zustandslosem Ethereum](https://stateless.fyi)
diff --git a/public/content/translations/de/roadmap/user-experience/index.md b/public/content/translations/de/roadmap/user-experience/index.md
index 760342bd6cb..84901f49964 100644
--- a/public/content/translations/de/roadmap/user-experience/index.md
+++ b/public/content/translations/de/roadmap/user-experience/index.md
@@ -7,30 +7,30 @@ alt: "Ethereum-Roadmap"
template: roadmap
---
-**Die Nutzung von Ethereum muss vereinfacht werden**; von der Verwaltung von [Schlüsseln](/glossary/#key) und [Wallets](/glossary/#wallet) bis zur Initiierung von Transaktionen. Um die Massenakzeptanz zu erleichtern, muss sich die Benutzerfreundlichkeit für Ethereum drastisch erhöhen. Benutzer müssen ohne Berechtigungen und zensurresistent auf Ethereum zugreifen können und dabei von derselben reibungslosen Erfahrung profitieren, die sie von der Nutzung von [Web2](/glossary/#web2)-Anwendungen kennen.
+**Die Nutzung von Ethereum muss vereinfacht werden**; von der Verwaltung von [Schlüsseln](/glossary/#key) und [Wallets](/glossary/#wallet) bis zur Initiierung von Transaktionen. Um die Massenakzeptanz zu erleichtern, muss Ethereum die Benutzerfreundlichkeit drastisch erhöhen, sodass die Nutzer einen erlaubnisfreien und zensurresistenten Zugang zu Ethereum mit der reibungslosen Erfahrung wie bei der Nutzung von [Web2](/glossary/#web2)-Apps erleben können.
-## Jenseits von Seed-Phrasen {#no-more-seed-phrases}
+## Über Seed-Phrases hinaus {#no-more-seed-phrases}
Ethereum-Konten sind durch ein Schlüsselpaar geschützt, das zur Identifizierung von Konten (öffentlicher Schlüssel) und zum Signieren von Nachrichten (privater Schlüssel) verwendet wird. Ein privater Schlüssel ist wie ein Master-Passwort; er ermöglicht den vollständigen Zugang zu einem Ethereum-Konto. Für Menschen, die eher mit Banken und Web2-Apps vertraut sind, welche die Konten im Namen des Nutzers verwalten, ist dies eine andere Art der Bedienung. Damit Ethereum die Massenakzeptanz erreicht, ohne sich auf zentralisierte Dritte zu verlassen, muss es einen unkomplizierten, reibungslosen Weg geben, wie ein Nutzer sein Vermögen in Verwahrung nehmen und die Kontrolle über seine Daten behalten kann, ohne sich mit Public-Private-Key-Kryptografie und Schlüsselverwaltung auskennen zu müssen.
-Die Lösung hierfür ist die Verwendung von [Smart-Contract](/glossary/#smart-contract)-Wallets für die Interaktion mit Ethereum. Smart Contract Wallets bieten die Möglichkeit, Konten bei Verlust oder dem Diebstahl der Schlüssel zu schützen, Betrug besser aufzudecken und abzuwehren und ermöglichen neue Funktionen für Wallets. Obwohl es heute bereits Smart Contract Wallets gibt, ist es schwierig, diese zu erstellen, da das Ethereum-Protokoll sie besser unterstützen muss. Diese zusätzliche Unterstützung wird als Kontoabstraktion bezeichnet.
+Die Lösung für dieses Problem ist die Verwendung von [Smart Contract](/glossary/#smart-contract)-Wallets zur Interaktion mit Ethereum. Smart Contract Wallets bieten die Möglichkeit, Konten bei Verlust oder dem Diebstahl der Schlüssel zu schützen, Betrug besser aufzudecken und abzuwehren und ermöglichen neue Funktionen für Wallets. Obwohl es heute bereits Smart Contract Wallets gibt, ist es schwierig, diese zu erstellen, da das Ethereum-Protokoll sie besser unterstützen muss. Diese zusätzliche Unterstützung wird als Kontoabstraktion bezeichnet.
Mehr zum Thema Kontenabstraktion
## Nodes für jedermann
-Benutzer, die [Knoten](/glossary/#node) betreiben, müssen sich nicht darauf verlassen, dass Dritte ihnen Daten bereitstellen, und können schnell, privat und ohne Berechtigungen mit der Ethereum-[Blockchain](/glossary/#blockchain) interagieren. Allerdings erfordert der Betrieb einer Node derzeit technische Kenntnisse und viel Speicherplatz, so dass viele Menschen stattdessen auf Intermediäre vertrauen müssen.
+Benutzer, die [Nodes](/glossary/#node) betreiben, müssen sich nicht darauf verlassen, dass Dritte ihnen Daten bereitstellen, und können schnell, privat und erlaubnisfrei mit der Ethereum-[Blockchain](/glossary/#blockchain) interagieren. Allerdings erfordert der Betrieb einer Node derzeit technische Kenntnisse und viel Speicherplatz, so dass viele Menschen stattdessen auf Intermediäre vertrauen müssen.
-Es gibt mehrere Upgrades, die den Betrieb von Nodes wesentlich einfacher und weniger ressourcenintensiv machen werden. Die Art und Weise, wie Daten gespeichert werden, wird geändert, um eine platzsparendere Struktur zu verwenden, die als **Verkle Tree** bekannt ist. Außerdem werden mit [ statelessness](/roadmap/statelessness) oder [data expiry](/roadmap/statelessness/#data-expiry), Ethereum-Nodes nicht mehr Kopie der gesamten Ethereum-Statusdaten speichern müssen, was den Speicherplatzbedarf auf der Festplatte drastisch reduziert. [Light nodes](/developers/docs/nodes-and-clients/light-clients/) bietet viele Vorteile eine Full Node, kann aber problemlos auf Mobiltelefonen oder in einfachen Browseranwendungen ausgeführt werden.
+Es gibt mehrere Upgrades, die den Betrieb von Nodes wesentlich einfacher und weniger ressourcenintensiv machen werden. Die Art und Weise, wie Daten gespeichert werden, wird geändert, um eine platzsparendere Struktur zu verwenden, die als **Verkle Tree** bekannt ist. Mit [Zustandslosigkeit](/roadmap/statelessness) oder [Datenablauf](/roadmap/statelessness/#data-expiry) müssen Ethereum-Nodes zudem keine Kopie der gesamten Ethereum-Zustandsdaten mehr speichern, was den Speicherplatzbedarf auf der Festplatte drastisch reduziert. [Light Nodes](/developers/docs/nodes-and-clients/light-clients/) bieten viele der Vorteile des Betriebs eines Full Nodes, können aber problemlos auf Mobiltelefonen oder in einfachen Browser-Apps ausgeführt werden.
-Lesen Sie über Verkle-Trees
+Mehr über Verkle-Trees
Mit diesen Upgrades werden die Hürden für den Betrieb einer Node praktisch auf Null reduziert. Die Nutzer werden von einem sicheren, erlaubnisfreien Zugang zu Ethereum profitieren, ohne dass sie nennenswerten Speicherplatz oder CPU auf ihrem Computer oder Mobiltelefon opfern müssen, und sie werden nicht auf Dritte angewiesen sein, wenn es um den Daten- oder Netzwerkzugang geht, wenn sie Apps verwenden.
## Aktueller Fortschritt {#current-progress}
-Smart-Contract-Wallets sind bereits verfügbar, aber es sind noch weitere Verbesserungen erforderlich, um sie so dezentralisiert und erlaubnislos wie möglich zu gestalten. EIP-4337 ist ein ausgereifter Vorschlag, der keine Änderungen am Ethereum-Protokoll erfordert. Der wichtigste für EIP-4337 erforderliche Smart Contract wurde **im März 2023 bereitgestellt**.
+Smart-Contract-Wallets sind bereits verfügbar, aber es sind noch weitere Verbesserungen erforderlich, um sie so dezentralisiert und erlaubnislos wie möglich zu gestalten. EIP-4337 ist ein ausgereifter Vorschlag, der keine Änderungen am Ethereum-Protokoll erfordert. Der wichtigste Smart Contract, der für EIP-4337 benötigt wird, wurde **im März 2023 bereitgestellt**.
-**Die vollständige Zustandslosigkeit ist noch in der Forschungsphase** und es wird wahrscheinlich noch einige Jahre dauern, bis sie implementiert wird. Es gibt mehrere Meilensteine auf dem Weg zur vollständigen Statelessness, einschließlich data expiry, welche früher umgesetzt werden können. Andere Punkte der Roadmap wie zum Beispiel [ Verkle Trees](/roadmap/verkle-trees/) und [Proposer-builder separation](/roadmap/pbs/) müssen zuerst abgeschlossen werden.
+**Die vollständige Zustandslosigkeit ist noch in der Forschungsphase** und es wird wahrscheinlich noch einige Jahre dauern, bis sie implementiert wird. Es gibt mehrere Meilensteine auf dem Weg zur vollständigen Statelessness, einschließlich data expiry, welche früher umgesetzt werden können. Andere Roadmap-Punkte, wie [Verkle-Trees](/roadmap/verkle-trees/) und die [Trennung von Proposer und Builder](/roadmap/pbs/), müssen zuerst abgeschlossen werden.
Verkle Tree Testnets sind bereits in Betrieb, und die nächste Phase besteht darin, Verkle Tree fähige Clients in privaten und dann in öffentlichen Testnets einzusetzen. Sie können dazu beitragen, den Fortschritt zu beschleunigen, indem Sie Kontrakte in die Testnets einbringen oder Testnet-Clients betreiben.
diff --git a/public/content/translations/de/roadmap/verkle-trees/index.md b/public/content/translations/de/roadmap/verkle-trees/index.md
index 20abb653934..69a78b97c0e 100644
--- a/public/content/translations/de/roadmap/verkle-trees/index.md
+++ b/public/content/translations/de/roadmap/verkle-trees/index.md
@@ -7,7 +7,7 @@ summaryPoints:
- Lesen Sie, warum Verkle Trees eine Bereicherung für Ethereum sind.
---
-# Verkle Trees {#verkle-trees}
+# Verkle-Trees {#verkle-trees}
Verkle Trees (ein Schachtelwort aus "Vektor-Verpflichtung" und "Merkle Bäumen") sind eine Datenstruktur, die zum Upgrade von Ethereum Nodes genutzt werden kann, so dass keine großen Mengen an Zustandsdaten mehr gespeichert werden müssen, ohne dass die Fähigkeit der Blockvalidierung verloren geht.
@@ -15,7 +15,7 @@ Verkle Trees (ein Schachtelwort aus "Vektor-Verpflichtung" und "Merkle Bäumen")
Verkle Bäume sind ein kritischer Schritt hin zu Zustandsfreien Ethereum Clients. Zustandsfreie Clients müssen nicht den ganzen Zustand der Datenbank speichern, um hereinkommende Blöcke prüfen zu können. Anstatt ihre eigene Lokale Kopie von Ethereums' Zustand zur Verifizierung zu verwenden, nutzen zustandsfreie Clients einen "Zeugen" der Zustandsdaten, die mit dem Block ankommen. Ein Zeuge ist eine Ansammlung von Einzelteilen an Zustandsdaten, die benötigt werden, um bestimmte Transaktionen auszuführen und gleichzeitig ein kryptographischer Beweis das der Zeuge wirklich Teil der ganzen Daten ist. Der Zeuge wird _anstatt_ der Zustandsdatenbank verwendet. Damit dies funktioniert, müssen Zeugen sehr klein sein, so dass sie sicher und rechtzeitig über das Netzwerk verteilt werden können, damit Validatoren sie innerhalb des 12 Sekunden Zeitfensters bearbeiten können. Die momentane Zustandsdatenstruktur ist dafür nicht geeignet, weil Zeugen zu groß sind. Verkle Trees lösen dieses Problem, indem sie kleine Zeugen ermöglichen und damit eines der Hauptprobleme der zustandsfreien Clienten entfernen.
-
+
Ethereum Clients nutzen momentan eine Datenstruktur, die als Patricia Merkle Trie bekannt ist, um ihre Zustandsdaten zu speichern. Informationen über einzelne Accounts sind als Blätter auf der Baumstruktur gespeichert und Paare von Blättern werden wiederholt gehashed, bis nur ein einzelner Hash bleibt. Der endgültige Hash ist bekannt als die "Wurzel". Um Blöcke zu überprüfen, führen Ethereum Clients alle Transaktionen in einem Block aus und aktualisieren ihren lokalen Zustandsbaum. Der Block wird als gültig angesehen, wenn die Wurzel des lokalen Baumes identisch zu der vom Block-Vorschlagenden ist, weil jeder Unterschied in der Berechnung des Block-Vorschlagenden und der überprüfenden Node einen komplett anderen Wurzelhash ergeben würde. Das Problem hierbei ist, dass die Überprüfung der Blockchain erfordert, dass jeder Client den gesamten Zustandsbaum des Kopf-Blocks und mehrere historische Blöcke (der Standard in Geth ist, die Zustandsdaten für 128 Blöcke hinter dem Kopf zu behalten) erfordert. Dies setzt voraus, dass Clients über große Mengen an Speicherplatz verfügen, was wiederum eine Barriere für günstige ressourcenschonende Hardware ist. Eine Lösung hierfür ist ein Update des Zutandsbaumes auf eine effizientere Struktur (Verkle Tree), die Daten effizient über kleine "Zeugen" teilen kann, anstatt den vollständigen Zustand von Ethereum zu übertragen. Den Datenzustand in Verkle Trees umzuschreiben, ist ein großer Schritt hin zu Zustandsfreien Clients.
@@ -23,7 +23,7 @@ Ethereum Clients nutzen momentan eine Datenstruktur, die als Patricia Merkle Tri
## Was ist ein Zeuge und warum brauchen wir sie? {#what-is-a-witness}
-Einen Block zu verifizieren bedeutet, die Transaktionen des blockes auszuführen, die Änderungen vollständig in Ethereum's Zustandsbaum zu übertragen und den neuen Wurzelhash zu berechnen. Der berechnete Wurzelhash eines verifizierten Blockes ist identisch zu dem, der mit dem Block geliefert wurde (weil dies bedeutet, dass der Block-Vorschlagende die Berechnung exakt wie der Verifizierende ausgeführt hat). In heutigen Ethereum Clients wird Zugang zum gesamten Zustandsbaum benötigt, der eine große lokal gespeicherte Datenstruktur ist. Ein Zeuge enthält nur Fragmente der Zustandsdaten, die benötigt werden, um die Transaktionen im aktuellen Block auszuführen. Ein Validator kann nur mit diesen Datenfragmenten verifizieren, dass der Block-Vorschlagende die Block-Transaktionen korrekt ausgeführt und den Zustand aktualisiert hat. Dies bedeutet jedoch, dass der Zeuge zwischen Netzwerkteilnehmern des Ethereumnetzwerks schnell genug übertragen werden muss, um innerhalb eines 12 Sekunden Zeitrahmens empfangen und von jeder Node sicher verarbeitet werden zu können. Wenn der Zeuge zu groß ist, könnte das Herunterladen auf manchen Nodes zu lange dauern, so dass diese den Anschluss verlieren könnten. Dies würde Zentralisierung forcieren, da nur Nodes mit sehr schneller Internetverbindung in der Lage wären, erfolgreich bei der Blockvalidierung zu partizipieren. Mit Verkle Trees muss der Zustand nicht mehr auf einem lokalen Speichermedium gespeichert werden; _Alles_ was gebraucht wird, befindet sich im Block selber. Unglücklicherweise sind die Zeugen, die aus Merkle-Bäumen erstellt werden können, viel zu groß, um zustandsfreie Clients zu ermöglichen.
+Einen Block zu verifizieren bedeutet, die Transaktionen des blockes auszuführen, die Änderungen vollständig in Ethereum's Zustandsbaum zu übertragen und den neuen Wurzelhash zu berechnen. Der berechnete Wurzelhash eines verifizierten Blockes ist identisch zu dem, der mit dem Block geliefert wurde (weil dies bedeutet, dass der Block-Vorschlagende die Berechnung exakt wie der Verifizierende ausgeführt hat). In heutigen Ethereum Clients wird Zugang zum gesamten Zustandsbaum benötigt, der eine große lokal gespeicherte Datenstruktur ist. Ein Zeuge enthält nur Fragmente der Zustandsdaten, die benötigt werden, um die Transaktionen im aktuellen Block auszuführen. Ein Validator kann nur mit diesen Datenfragmenten verifizieren, dass der Block-Vorschlagende die Block-Transaktionen korrekt ausgeführt und den Zustand aktualisiert hat. Dies bedeutet jedoch, dass der Zeuge zwischen Netzwerkteilnehmern des Ethereumnetzwerks schnell genug übertragen werden muss, um innerhalb eines 12 Sekunden Zeitrahmens empfangen und von jeder Node sicher verarbeitet werden zu können. Wenn der Zeuge zu groß ist, könnte das Herunterladen auf manchen Nodes zu lange dauern, so dass diese den Anschluss verlieren könnten. Dies würde Zentralisierung forcieren, da nur Nodes mit sehr schneller Internetverbindung in der Lage wären, erfolgreich bei der Blockvalidierung zu partizipieren. Mit Verkle-Trees muss der Zustand nicht auf Ihrer Festplatte gespeichert werden; _alles_, was Sie zur Verifizierung eines Blocks benötigen, ist im Block selbst enthalten. Unglücklicherweise sind die Zeugen, die aus Merkle-Bäumen erstellt werden können, viel zu groß, um zustandsfreie Clients zu ermöglichen.
## Warum erlauben Verkle Bäume kleinere Zeugen? {#why-do-verkle-trees-enable-smaller-witnesses}
@@ -31,36 +31,36 @@ Die Struktur eines Merkle Trie erzeugt sehr große Zeugen - zu groß, um sicher
In einem Polynombindungs-Schema haben die Zeugen überschaubare Größen, die leicht unter Netzwerkteilnehmern versendet werden können. Dies erlaubt Clients, Zustandsveränderungen in jedem Block mit minimaler Menge an Daten zu verifizieren.
-
+
Die Größe des Zeugen variiert abhängig von der Anzahl der Blätter, die er enthält. Davon ausgehend, dass ein Zeuge 1000 Blätter abdeckt, wäre ein Zeuge für einen Merkle Baum ungefähr 3,5 MB (von 7 Ebenen im Trie ausgehend). Ein Zeuge für die selben Daten in einem Verkle Baum (von 4 Ebenen zum Baum ausgehend) würde ungefähr 150 kB an Daten ergeben -**etwa 23x kleiner**. Diese Reduktion der Zeugengröße wird Zeugen in zustandsfreien Clients ermöglichen, akzeptabel klein zu sein. Polynomzeugen sind 0,128–1 kB groß; abhängig davon, welches spezifische Polynom-Commitment verwendet wird.
-## Wie sieht die Struktur von Verkle Bäumen aus? {#what-is-the-structure-of-a-verkle-tree}
+## Wie sieht die Struktur von Verkle Bäumen aus? Was ist die Struktur eines Verkle-Trees? {#what-is-the-structure-of-a-verkle-tree}
-Verkle Bäume sind `(key,value)` Paare, in denen die keys 32-byte Elemente zusammengestellt aus einem 31-byte _stem_ und einem einzelnen byte _suffix_ sind. Diese Schlüssel sind in _extension_ Knoten und _inner_ Knoten organisiert. Erweiterungsknoten repräsentieren einen einzelnen Stamm für 256 Kinder mit verschiedenen Suffixes. Innere-Knoten haben auch 256 Kinder, aber sie können andere Erweiterungsknoten sein. Der Hauptunterschied zwischen Verklebaum- und Merklebaum-Struktur ist, dass der Verkle Baum viel flacher mit weniger Zwischenknoten ist, die das Blatt zur Wurzel verbinden und so insgesamt weniger Daten benötigen, um einen Beweis zu generieren.
+Verkle-Trees sind `(key,value)`-Paare, bei denen die Schlüssel 32-Byte-Elemente sind, die sich aus einem 31-Byte-_Stamm_ und einem einzelnen Byte-_Suffix_ zusammensetzen. Diese Schlüssel sind in _Extension-Nodes_ und _Inner-Nodes_ organisiert. Erweiterungsknoten repräsentieren einen einzelnen Stamm für 256 Kinder mit verschiedenen Suffixes. Innere-Knoten haben auch 256 Kinder, aber sie können andere Erweiterungsknoten sein. Der Hauptunterschied zwischen Verklebaum- und Merklebaum-Struktur ist, dass der Verkle Baum viel flacher mit weniger Zwischenknoten ist, die das Blatt zur Wurzel verbinden und so insgesamt weniger Daten benötigen, um einen Beweis zu generieren.
-[Lesen Sie mehr üner die Struktur von Verkle Bäumen](https://blog.ethereum.org/2021/12/02/verkle-tree-structure)
+[Lesen Sie mehr über die Struktur von Verkle-Trees](https://blog.ethereum.org/2021/12/02/verkle-tree-structure)
## Aktueller Fortschritt {#current-progress}
Verkle Tree Testnetzwerke laufen bereits, aber es sind noch substantielle Updates der Clients vonnöten, um Verkle Bäume zu unterstützen. Sie können dazu beitragen, den Fortschritt zu beschleunigen, indem Sie Kontrakte in die Testnets einbringen oder Testnet-Clients betreiben.
-[Entdecken Sie das Verkle Gen Devnet 2-Testnetz](https://verkle-gen-devnet-2.ethpandaops.io/)
-
-[Sehen Sie sich an, wie Guillaume Ballet das Condrieu Verkle-Testnetz erklärt](https://www.youtube.com/watch?v=cPLHFBeC0Vg) (beachten Sie, dass das Condrieu-Testnetz Proof-of-Work war und durch das Verkle Gen Devnet 2-Testnetz ersetzt wurde).
-
-## Weiterführende Informationen {#further-reading}
-
-- [Verkle Trees für Zustandslosigkeit](https://verkle.info/)
-- [Dankrad Feist erklärt Verkle Trees bei PEEPanEIP](https://www.youtube.com/watch?v=RGJOQHzg3UQ)
-- [Guillaume Ballet erklärt Verkle Trees bei ETHGlobal](https://www.youtube.com/watch?v=f7bEtX3Z57o)
-- ["Wie Verkle Trees Ethereum schlank und super machen" von Guillaume Ballet bei Devcon 6](https://www.youtube.com/watch?v=Q7rStTKwuYs)
-- [Piper Merriam über zustandsfreie Clients bei ETHDenver 2020](https://www.youtube.com/watch?v=0yiZJNciIJ4)
-- [Dankrad Fiest erklärt Verkle Trees und Zustandslosigkeit im Podcast zu Null-Wissen](https://zeroknowledge.fm/podcast/202/)
-- [Vitalik Buterin über Verkle Trees](https://vitalik.eth.limo/general/2021/06/18/verkle.html)
-- [Dankrad Feist über Verkle Trees](https://dankradfeist.de/ethereum/2021/06/18/verkle-trie-for-eth1.html)
-- [Verkle Trees EIP Dokumentation](https://notes.ethereum.org/@vbuterin/verkle_tree_eip#Illustration)
+[Sehen Sie sich an, wie Guillaume Ballet das Condrieu Verkle-Testnet erklärt](https://www.youtube.com/watch?v=cPLHFBeC0Vg) (beachten Sie, dass das Condrieu-Testnet Proof-of-Work war und inzwischen durch das Verkle Gen Devnet 6 Testnet ersetzt wurde).
+
+## Weiterführende Lektüre {#further-reading}
+
+- [Verkle-Trees für Zustandslosigkeit](https://verkle.info/)
+- [Dankrad Feist erklärt Verkle-Trees auf PEEPanEIP](https://www.youtube.com/watch?v=RGJOQHzg3UQ)
+- [Verkle-Trees für alle](https://web.archive.org/web/20250124132255/https://research.2077.xyz/verkle-trees)
+- [Anatomie eines Verkle-Proofs](https://ihagopian.com/posts/anatomy-of-a-verkle-proof)
+- [Guillaume Ballet erklärt Verkle-Trees bei ETHGlobal](https://www.youtube.com/watch?v=f7bEtX3Z57o)
+- ["Wie Verkle-Trees Ethereum schlank und leistungsstark machen" von Guillaume Ballet bei Devcon 6](https://www.youtube.com/watch?v=Q7rStTKwuYs)
+- [Piper Merriam über zustandslose Clients von der ETHDenver 2020](https://www.youtube.com/watch?v=0yiZJNciIJ4)
+- [Dankrad Fiest erklärt Verkle-Trees und Zustandslosigkeit im Zero-Knowledge-Podcast](https://zeroknowledge.fm/podcast/202/)
+- [Vitalik Buterin über Verkle-Trees](https://vitalik.eth.limo/general/2021/06/18/verkle.html)
+- [Dankrad Feist über Verkle-Trees](https://dankradfeist.de/ethereum/2021/06/18/verkle-trie-for-eth1.html)
+- [Verkle-Tree-EIP-Dokumentation](https://notes.ethereum.org/@vbuterin/verkle_tree_eip#Illustration)
diff --git a/public/content/translations/de/security/index.md b/public/content/translations/de/security/index.md
index 5caf5e8a2e0..609c15b8a28 100644
--- a/public/content/translations/de/security/index.md
+++ b/public/content/translations/de/security/index.md
@@ -4,13 +4,15 @@ description: Ethereum sicher nutzen
lang: de
---
-# Ethereum – Sicherheits- und Betrugsvorbeugung {#introduction}
+# Ethereum-Sicherheit und Betrugsprävention {#introduction}
Das zunehmende Interesse an Kryptowährungen bringt ein wachsendes Risiko durch Betrüger und Hacker mit sich. In diesem Artikel geht es um bewährte Praktiken, um diese Risiken einzugrenzen.
+**Denken Sie daran: Niemand von ethereum.org wird Sie jemals kontaktieren. Beantworten Sie keine E-Mails, die angeblich vom offiziellen Ethereum-Support stammen.**
+
- Achtung: Obwohl Unterstützungsbetrug oft auf Discord erfolgt, ist es auch möglich, dass diese und auch andere Arten von Betrug auf anderen Chat-Plattformen, einschließlich per E-Mail, vorkommen können.
+ Achtung: Obwohl Betrugsmaschen im Support-Stil häufig auf Discord vorkommen, können sie auch in jeder Chat-Anwendung, in der über Kryptowährungen diskutiert wird, einschließlich E-Mails, verbreitet sein.
### „Eth2“-Token-Betrug {#eth2-token-scam}
-Im Vorfeld der [Zusammenführung](/roadmap/merge/) haben Betrüger die Chance ergriffen, die Verwirrung um den Begriff „Eth2“ für sich zu nutzen, indem sie Benutzer dazu brachten, ihr ETH gegen „ETH2“-Token einzutauschen. Es gibt kein „ETH2", und es wurde auch kein anderer legitimer Token zusammen mit der Zusammenführung eingeführt. Das ETH, welches Sie vor der Zusammenführung besaßen, ist jetzt weiterhin das gleiche ETH. Es ist in Bezug auf den Wechsel von Proof-of-Work zu Proof-of-Stake **nicht nötig, im Zusammenhang mit Ihren ETH aktiv zu werden**.
+Im Vorfeld von [Die Zusammenführung](/roadmap/merge/) nutzten Betrüger die Verwirrung um den Begriff „Eth2“ aus, um Nutzer dazu zu bringen, ihre ETH gegen einen „ETH2“-Token einzutauschen. Es gibt kein „ETH2", und es wurde auch kein anderer legitimer Token zusammen mit der Zusammenführung eingeführt. Das ETH, welches Sie vor der Zusammenführung besaßen, ist jetzt weiterhin das gleiche ETH. **Es ist nicht notwendig, bezüglich Ihrer ETH irgendwelche Maßnahmen für den Wechsel von Proof-of-Work zu Proof-of-Stake zu ergreifen**.
-Betrüger könnten sich als „Support" ausgeben, und Sie dazu auffordern Ihr ETH einzuzahlen, um im Gegenzug „ETH2" zu erhalten. Es gibt kein [offizielles Ethereum-Support-Team](/community/support/) und auch keinen neuen Token. Teilen Sie niemals Ihre Ethereum-Wallet-Seed-Phrasen.
+Betrüger könnten sich als „Support" ausgeben, und Sie dazu auffordern Ihr ETH einzuzahlen, um im Gegenzug „ETH2" zu erhalten. Es gibt keinen [offiziellen Ethereum-Support](/community/support/) und es gibt keinen neuen Token. Teilen Sie niemals Ihre Ethereum-Wallet-Seed-Phrasen.
-_Hinweis: Es gibt abgeleitete (derivative) Token/Ticker, die staked ETH darstellen können (z. B. rETH von Rocket Pool, stETH von Lido, ETH2 von Coinbase). Doch diese abgeleiteten Token sind nichts, zu dem Sie „migrieren“ müssen._
+_Hinweis: Es gibt derivative Token/Ticker, die gestakte ETH repräsentieren können (d. h. rETH von Rocket Pool, stETH von Lido, ETH2 von Coinbase), aber zu diesen müssen Sie nicht „migrieren“._
-### Phishing-Betrug {#phishing-scams}
+### Phishing-Betrugsmaschen {#phishing-scams}
Phishing ist eine Betrugsmasche, die sich immer stärker ausbreitet. Betrüger setzen darauf, um das Geld aus Ihrer Wallet zu stehlen.
@@ -151,9 +154,9 @@ Wenn Sie eine E-Mail von einem unbekannten Absender erhalten, denken Sie daran:
- Geben Sie niemals Ihre persönlichen Daten oder Kennwörter an Dritte weiter
- Löschen Sie E-Mails von unbekannten Absendern
-[Mehr zur Vermeidung von Phishing-Betrugsversuchen](https://support.mycrypto.com/staying-safe/mycrypto-protips-how-not-to-get-scammed-during-ico)
+[Mehr zur Vermeidung von Phishing-Betrugsmaschen](https://support.mycrypto.com/staying-safe/mycrypto-protips-how-not-to-get-scammed-during-ico)
-### Krypto-Makler-Betrug {#broker-scams}
+### Krypto-Broker-Betrug {#broker-scams}
Betrügerische Krypto-Börsenmakler geben sich als fachmännische Makler für Kryptowährungen aus, die Ihnen anbieten, Ihr Geld zu nehmen und es in Ihrem Namen zu investieren. Nachdem der Betrüger Ihr Geld bekommen hat, könnte er Sie bitten, ihm noch mehr Geld zu senden, damit Sie keine weiteren Anlagegewinne verpassen. Oder der Betrüger verschwindet einfach sofort komplett.
@@ -161,9 +164,9 @@ Diese Betrüger finden ihre Zielpersonen oft, indem sie gefälschte Konten auf Y
**Vertrauen Sie keiner fremden Person im Internet, Investitionen in Ihrem Namen zu tätigen. Sie werden so Ihre Krypto verlieren.**
-
+
-### Krypto-Mining-Pool-Betrug {#mining-pool-scams}
+### Betrugsmaschen mit Krypto-Mining-Pools {#mining-pool-scams}
Seit September 2022 ist Mining auf Ethereum nicht mehr möglich. Jedoch gibt es noch immer Mining-Pool-Betrug. Beim Mining-Pool-Betrug werden Sie unaufgefordert von anderen Personen kontaktiert, die vorgeben, dass Sie große Gewinne erzielen können, wenn Sie einem Ethereum-Mining-Pool beitreten. Die Betrüger tischen Ihnen eine Lüge nach der anderen auf und werden solange mit Ihnen in Kontakt bleiben, wie es erforderlich ist. Im Grunde wird der Betrüger versuchen, Sie davon zu überzeugen, einem Mining-Pool für Ethereum beizutreten. Mit Ihrer Kryptowährung würden dann ETH geschaffen und Ihnen ETH-Dividenden ausgezahlt. Sie werden dann erkennen, dass Ihre Kryptowährung kleine Erträge abwirft. Das ist natürlich so gedacht, um Sie dazu zu bringen, mehr Kryptowährung zu investieren. Am Ende wird Ihre Kryptowährung an eine unbekannte Adresse gesendet und der Betrüger wird entweder verschwinden oder, wie kürzlich zu beobachten war, vielleicht sogar weiter mit Ihnen in Kontakt bleiben.
@@ -175,68 +178,68 @@ Folgendes sollten Sie beachten:
- Recherchieren Sie selbst umfassend zu Themen wie Staking, Liquiditäts-Pools und andere Investitionsmöglichkeiten für Ihre Kryptowährung
- Solche Pläne sind selten, wenn überhaupt, echt. Wären sie es, dann würden viele darüber Bescheid wissen und Sie hätten eventuell schon einmal etwas davon gehört.
-[Mann verliert 200.000 US-Dollar in einem Mining-Pool-Betrug](https://www.reddit.com/r/CoinBase/comments/r0qe0e/scam_or_possible_incredible_payout/)
+[Mann verliert 200.000 $ durch Mining-Pool-Betrug](https://www.reddit.com/r/CoinBase/comments/r0qe0e/scam_or_possible_incredible_payout/)
-### Airdrop-Betrug {#airdrop-scams}
+### Airdrop-Betrugsmaschen {#airdrop-scams}
Beim Airdrop-Betrug wird über ein Betrugsprojekt ein Asset (z. B. ein NFT/Token) per Airdrop an Ihre Wallet gesendet. Sie werden daraufhin zu einer Betrugs-Website weitergeleitet, damit Sie die per Airdrop versendeten Assets beanspruchen können. Sie werden aufgefordert, sich mit Ihrer Ethereum-Wallet anzumelden, um eine Transaktion zu „autorisieren“, wenn Sie versuchen, den Besitz an dem Asset zu beanspruchen. Diese Transaktion ist eine Gefährdung für Ihr Konto, denn dabei werden Ihre öffentlichen und privaten Schlüssel an den Betrüger gesendet. In einer alternativen Form dieses Betrugs werden Sie dazu aufgefordert, eine Transaktion zu genehmigen, über die Geld direkt zu dem Wallet des Betrügers gesendet wird.
-[Mehr zu Airdrop-Betrugsversuchen](https://www.youtube.com/watch?v=LLL_nQp1lGk)
+[Mehr zu Airdrop-Betrugsmaschen](https://www.youtube.com/watch?v=LLL_nQp1lGk)
- Ein Kennwortmanager ist hilfreich bei der Erstellung starker, einzigartiger Kennwörter und dabei sich diese zu merken! Wir empfehlen dringend die Verwendung eines Kennwortmanagers! Es gibt viele gute, kostenlose Angebote.
+ Ein Passwort-Manager erstellt starke, einzigartige Passwörter für Sie und merkt sie sich! Wir empfehlen dringend, einen zu verwenden, und die meisten davon sind kostenlos!
Es ist nicht möglich, sich starke, einzigartige Kennwörter für jedes Konto zu merken, das Sie eingerichtet haben. Ein Kennwortmanager bietet Ihnen einen sicheren, verschlüsselten Speicher für all Ihre Kennwörter, auf den Sie über ein starkes Master-Kennwort zugreifen können. Ein solches Tool schlägt Ihnen auch starke Kennwörter vor, wenn Sie sich für einen neuen Dienst anmelden, sodass Sie keine eigenen erstellen müssen. Viele Kennwortmanager informieren Sie auch, wenn Sie von einem Datenleck betroffen sind, sodass Sie Ihre Kennwörter vor böswilligen Angriffen ändern können.
-
+
-#### Überzeugen Sie sich selbst von einem Kennwortmanager: {#try-password-manager}
+#### Probieren Sie einen Passwort-Manager aus: {#try-password-manager}
- [Bitwarden](https://bitwarden.com/)
- [KeePass](https://keepass.info/)
- [1Password](https://1password.com/)
-- Oder sehen Sie sich andere [empfohlene Passwortmanager](https://www.privacytools.io/secure-password-manager) an
+- Oder sehen Sie sich andere [empfohlene Passwort-Manager](https://www.privacytools.io/secure-password-manager) an
-### Zwei-Faktor-Authentifizierung verwenden {#two-factor-authentication}
+### Verwenden Sie die Zwei-Faktor-Authentifizierung {#two-factor-authentication}
Sie werden möglicherweise gelegentlich aufgefordert, Ihre Identität mit einzigartigen Nachweisen zu authentifizieren. Diese werden als **Faktoren** bezeichnet. Die drei Hauptfaktoren lauten:
@@ -244,26 +247,26 @@ Sie werden möglicherweise gelegentlich aufgefordert, Ihre Identität mit einzig
- Etwas, das nur Sie sind (wie ein Fingerabdruck oder ein Iris-/Gesichts-Scan)
- Etwas, das nur Sie besitzen (wie ein Sicherheitsschlüssel, oder eine Authentifizierungs-App auf Ihrem Smartphone)
-Die Nutzung der **Zwei-Faktor-Authentifizierung (2FA)** bietet einen zusätzlichen *Sicherheitsfaktor* für Ihre Online-Konten. 2FA sorgt dafür, dass Ihr Passwort allein nicht reicht, um auf ein Konto zuzugreifen. Meist ist der zweite Faktor ein zufälliger 6-stelliger Code, bekannt als ein **zeitabhängiges einmaliges Kennwort (Time-based One-time Password, TOTP)**, auf das Sie über eine Authentifizierungs-App wie Google Authenticator oder Authy Zugriff haben. Solche Apps funktionieren als „etwas, das Sie besitzen“-Faktor, da der Seed, der den Zeitcode generiert, auf Ihrem Gerät gespeichert ist.
+Die Nutzung der **Zwei-Faktor-Authentifizierung (2FA)** bietet einen zusätzlichen _Sicherheitsfaktor_ für Ihre Online-Konten. 2FA sorgt dafür, dass Ihr Passwort allein nicht reicht, um auf ein Konto zuzugreifen. Am häufigsten ist der zweite Faktor ein zufälliger 6-stelliger Code, bekannt als **zeitbasiertes Einmalpasswort (TOTP)**, auf den Sie über eine Authenticator-App wie Google Authenticator oder Authy zugreifen können. Solche Apps funktionieren als „etwas, das Sie besitzen“-Faktor, da der Seed, der den Zeitcode generiert, auf Ihrem Gerät gespeichert ist.
- Hinweis: SMS-basierte 2FA ist anfällig für SIM Jacking und daher nicht sicher. Für das höchste Maß an Sicherheit nutzen Sie am besten einen Dienst wie Google Authenticator oder Authy.
+ Hinweis: SMS-basierte 2FA ist anfällig für SIM-Jacking und ist nicht sicher. Für die beste Sicherheit verwenden Sie einen Dienst wie Google Authenticator oder Authy.
#### Sicherheitsschlüssel {#security-keys}
-Ein Sicherheitsschlüssel ist eine fortschrittlichere und sicherere Art der 2FA. Sicherheitsschlüssel sind physische Hardware-Authentifizierungsgeräte, die wie Authentifizierungsapps funktionieren. Einen Sicherheitsschlüssel zu verwenden, ist die sicherste Variante der 2FA. Viele dieser Schlüssel verwenden den Standard „FIDO Universal 2nd Factor (U2F)“. [Mehr erfahren über FIDO U2F](https://www.yubico.com/authentication-standards/fido-u2f/).
+Ein Sicherheitsschlüssel ist eine fortschrittlichere und sicherere Art der 2FA. Sicherheitsschlüssel sind physische Hardware-Authentifizierungsgeräte, die wie Authentifizierungsapps funktionieren. Einen Sicherheitsschlüssel zu verwenden, ist die sicherste Variante der 2FA. Viele dieser Schlüssel verwenden den Standard „FIDO Universal 2nd Factor (U2F)“. [Erfahren Sie mehr über FIDO U2F](https://www.yubico.com/resources/glossary/fido-u2f/).
Mehr zur 2FA ansehen:
-
+
Typischerweise werden ERC-20-Staking-Token an die Staker ausgegeben und repräsentieren den Wert ihres eingesetzten ETH sowie Belohnungen. Denken Sie daran, dass Staking-Belohnungen grundsätzlich etabliert sind, verschiedene Pools Staking-Belohnungen allerdings nach leicht unterschiedlichen Methoden an ihre Benutzer verteilen.
-
+
Sofort! Die Aktualisierung des Netzwerks auf Shanghai/Capella erfolgte im April 2023 und führte das Auszahlen von Staking-Mitteln ein. Validatoren haben nun die Möglichkeit, Staking-Pools, die sie unterstützen, zu verlassen und eine Auszahlung von ETH an ihre angegebene Adresse anzuweisen. Dies macht es möglich, Ihren Anteil am Stake gegen das zugrundeliegende ETH einzulösen. Bitte wenden Sie sich an Ihren Anbieter, um zu erfahren, wie er diese Funktionalität unterstützt.
Alternativ dazu ermöglichen Pools, die einen ERC-20 Staking-Token verwenden, den Handel mit diesem Token auf dem freien Markt, so dass Sie Ihre Staking-Position verkaufen können, ohne tatsächlich ETH aus dem Staking-Vertrag zu entnehmen.
-Mehr zum Abheben von Staking
-
+Mehr zu Staking-Auszahlungen \n
-
-Es gibt viele Ähnlichkeiten zwischen diesen gepoolten Staking-Optionen und zentralisierten Börsen, wie z. B. die Möglichkeit, kleine ETH-Beträge zu staken und sie zu bündeln, um Validatoren zu aktivieren.
+\nEs gibt viele Ähnlichkeiten zwischen diesen gepoolten Staking-Optionen und zentralisierten Börsen, wie z. B. die Möglichkeit, kleine ETH-Beträge zu staken und sie zu bündeln, um Validatoren zu aktivieren.
Im Gegensatz zu zentralisierten Börsen nutzen viele andere gepoolte Staking-Optionen Smart Contracts und/oder Staking-Token, bei denen es sich in der Regel um ERC-20-Token handelt, die Sie in Ihrer eigenen Wallet halten und wie jeden anderen Token kaufen oder verkaufen können. Dies bietet eine gewisse Souveränität und Sicherheit, da Sie die Kontrolle über Ihre Token besitzen. Allerdings haben Sie immer noch keine direkte Kontrolle über den Validator-Client, der in Ihrem Namen im Hintergrund Attestierungen ausgibt.
-Einige Pooling-Optionen sind im Hinblick auf die Nodes, die sie unterstützen, stärker dezentralisiert als andere. Um die Gesundheit und Dezentralisierung des Netzwerks zu fördern, werden Staker immer dazu ermutigt, einen Pooling-Service auszuwählen, der eine genehmigungsfreie, dezentrale Gruppe von Node-Betreibern ermöglicht.
-
+Einige Pooling-Optionen sind im Hinblick auf die Nodes, die sie unterstützen, stärker dezentralisiert als andere. Um die Gesundheit und Dezentralisierung des Netzwerks zu fördern, werden Staker immer dazu ermutigt, einen Pooling-Service auszuwählen, der eine genehmigungsfreie, dezentrale Gruppe von Node-Betreibern ermöglicht.
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
- [Das Ethereum-Staking-Verzeichnis](https://www.staking.directory/) - _Eridian und Spacesider_
-- [Staking mit Rocket Pool – Staking-Übersicht](https://docs.rocketpool.net/guides/staking/overview.html) – _RocketPool-Dokumentation_
-- [Staking von Ethereum mit Lido](https://help.lido.fi/en/collections/2947324-staking-ethereum-with-lido) - _Lido Hilfedokumente_
+- [Staken mit Rocket Pool - Staking-Überblick](https://docs.rocketpool.net/guides/staking/overview.html) - _RocketPool-Dokumentation_
+- [Ethereum staken mit Lido](https://help.lido.fi/en/collections/2947324-staking-ethereum-with-lido) - _Lido-Hilfedokumente_
diff --git a/public/content/translations/de/staking/saas/index.md b/public/content/translations/de/staking/saas/index.md
index 73acdc8cf65..301498a9a53 100644
--- a/public/content/translations/de/staking/saas/index.md
+++ b/public/content/translations/de/staking/saas/index.md
@@ -1,6 +1,6 @@
---
title: Staking als Service
-description: Eine Übersicht darüber, wie man mit gepooltem ETH-Staking beginnen kann
+description: Erfahren Sie mehr über Staking als Service
lang: de
template: staking
emoji: ":money_with_wings:"
@@ -22,14 +22,14 @@ Staking-as-a-Service („SaaS“) stellt eine Kategorie von Staking-Diensten dar
Das Ethereum-Protokoll unterstützt keine Delegation von Staking, daher wurden diese Serviceleistungen aufgebaut, um die entsprechende Nachfrage zu befriedigen. Wenn Sie über 32 ETH zum Staking verfügen, sich aber davor scheuen, mit Hardware umzugehen, bieten SaaS-Dienste Ihnen die Möglichkeit, den schwierigen Teil zu delegieren, während Sie native Blockbelohnungen erhalten.
-
+
Die Vereinbarungen unterscheiden sich von Anbieter zu Anbieter. In der Regel werden Sie durch die Einrichtung aller benötigten Signaturschlüssel (einer pro 32 ETH) und das Hochladen dieser Schlüssel zu Ihrem Anbieter geleitet, damit dieser in Ihrem Namen validieren kann. Die Signaturschlüssel allein bieten nicht die Möglichkeit, Ihr Geld abzuheben, zu überweisen oder auszugeben. Sie bieten jedoch die Möglichkeit, Stimmen für einen Konsens abzugeben, was, wenn es nicht richtig gemacht wird, zu Offline-Strafen oder Slashing führen kann.
-
+
Ja. Jedes Konto besteht aus BLS-Signaturschlüsseln und BLS-Abhebungsschlüsseln. Damit ein Validator den Zustand der Blockchain attestieren, an Synchronisierungsausschüssen teilnehmen und Blöcke vorschlagen kann, müssen die Signaturschlüssel für einen Validator-Kunden leicht zugänglich sein. Diese müssen in irgendeiner Form mit dem Internet verbunden sein und werden daher naturgemäß als "Hot Keys" betrachtet. Dies ist eine Voraussetzung für Ihren Validator, um attestieren zu können. Daher werden die Schlüssel, die zum Überweisen oder Abheben von Geldern verwendet werden, aus Sicherheitsgründen getrennt.
Die BLS-Abhebungsschlüssel werden verwendet, um eine einmalige Nachricht zu signieren, die angibt, an welches Execution-Layer-Konto Staking-Belohnungen und ausgetretene Mittel gehen sollen. Sobald diese Nachricht gesendet wurde, werden die BLS-Abhebungsschlüssel nicht mehr benötigt. Stattdessen wird die Kontrolle über abgehobene Mittel dauerhaft an die von Ihnen angegebene Adresse delegiert. Auf diese Weise können Sie eine Abhebungsadresse festlegen, die durch Ihre eigene Cold Storage gesichert ist, um das Risiko für Ihre Validator-Fonds zu minimieren, selbst wenn jemand anderes die Signaturschlüssel Ihres Validators kontrolliert.
Das Aktualisieren der Auszahlungsberechtigungen ist ein erforderlicher Schritt, um Auszahlungen zu ermöglichen\*. Dieser Prozess beinhaltet das Generieren der Abhebungsschlüssel mit Hilfe Ihrer Mnemonic Seed Phrase.
-Stellen Sie unbedingt sicher, dass Sie diesen Seed-Satz sicher aufbewahren, sonst können Sie Ihre Auszahlungsschlüssel nicht erstellen, wenn es soweit ist.
+Stellen Sie sicher, dass Sie diese Seed-Phrase sicher aufbewahren, sonst können Sie Ihre Auszahlungsschlüssel nicht generieren, wenn es soweit ist.
-\*Staker, die eine Auszahlungsadresse bei der ersten Einzahlung angegeben haben, müssen dies nicht einstellen. Bitte wenden Sie sich an Ihren SaaS-Anbieter, um Unterstützung bei der Vorbereitung Ihres Validators zu erhalten.
-
+\*Staker, die bei der Ersteinzahlung eine Auszahlungsadresse angegeben haben, müssen dies nicht festlegen. Bitte wenden Sie sich an Ihren SaaS-Anbieter, um Unterstützung bei der Vorbereitung Ihres Validators zu erhalten.
-
-Staking Auszahlungen wurden mit der Shanghai/Capella Aktualisierung im April 2023 eingeführt. Staker müssen (sofern nicht bereits bei der Ersteinzahlung geschehen) eine Auszahlungsadresse bereitstellen. Belohnungen werden daraufhin automatisch alle paar Tage in regelmäßigen Abständen ausgezahlt.
+\nStaker müssen (sofern nicht bereits bei der Ersteinzahlung geschehen) eine Auszahlungsadresse bereitstellen. Belohnungen werden daraufhin automatisch alle paar Tage in regelmäßigen Abständen ausgezahlt.
Validatoren haben auch die Möglichkeit, ihre Tätigkeit als Validator zu beenden. Das ermöglicht die Auszahlung ihres restlichen ETH-Guthabens. Konten, die eine Auszahlungsadresse angegeben und den Austrittsprozess abgeschlossen haben, erhalten ihr gesamtes Guthaben bei der nächsten Validatorendurchsicht auf die angegebene Auszahlungsadresse.
-Mehr zu Staking-Abhebungen
-
+Mehr zu Staking-Auszahlungen \n
-
+
Durch die Nutzung eines SaaS-Anbieters vertrauen Sie den Betrieb Ihrer Nodes jemand anderem an. Dies birgt das Risiko einer schlechten Node-Leistung, auf die Sie keinen Einfluss haben. Falls Ihr Validator geslashed wird, wird Ihr Validator-Guthaben bestraft und zwangsweise aus dem Validator-Pool entfernt.
Nach Abschluss des Slashing-/Austrittsprozesses werden diese Mittel an die dem Validator zugewiesene Auszahlungsadresse übertragen. Dies erfordert die Angabe einer Auszahlungsadresse zur Aktivierung. Diese Adresse kann bei der anfänglichen Einzahlung angegeben worden sein. Falls nicht, müssen die Auszahlungsschlüssel des Validators verwendet werden, um eine Nachricht zu unterschreiben, die eine Auszahlungsadresse angibt. Wenn keine Auszahlungsadresse angegeben wurde, bleibt das Guthaben bis zur Angabe gesperrt.
-Für weitere Informationen zu Garantien oder Versicherungsoptionen sowie zur Anleitung zur Bereitstellung einer Abhebungsadresse wenden Sie sich bitte an Ihren individuellen SaaS-Anbieter. Wenn Sie es vorziehen, die volle Kontrolle über Ihre Validator-Konfiguration zu haben, [erfahren Sie mehr darüber, wie Sie Ihre ETH alleine einsetzen können](/staking/solo/).
-
+Für weitere Informationen zu Garantien oder Versicherungsoptionen sowie zur Anleitung zur Bereitstellung einer Abhebungsadresse wenden Sie sich bitte an Ihren individuellen SaaS-Anbieter. Wenn Sie lieber die volle Kontrolle über Ihr Validator Setup haben möchten, [erfahren Sie mehr darüber, wie Sie Ihr ETH alleine einsetzen](/staking/solo/).
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
- [Das Ethereum-Staking-Verzeichnis](https://www.staking.directory/) - _Eridian und Spacesider_
-- [Bewertung von Staking-Diensten](https://www.attestant.io/posts/evaluating-staking-services/) – _Jim McDonald 2020_
+- [Bewertung von Staking-Diensten](https://www.attestant.io/posts/evaluating-staking-services/) - _Jim McDonald 2020_
diff --git a/public/content/translations/de/staking/solo/index.md b/public/content/translations/de/staking/solo/index.md
index 33bc117aabf..ea0c83eec59 100644
--- a/public/content/translations/de/staking/solo/index.md
+++ b/public/content/translations/de/staking/solo/index.md
@@ -1,6 +1,6 @@
---
-title: Solo-Staking Ihres ETH
-description: Ein Überblick darüber, wie Sie mit dem Solo-Staking Ihres ETH beginnen können
+title: Setzen Sie Ihre ETH zu Hause ein
+description: Eine Übersicht über die ersten Schritte beim Home-Staking Ihres ETH
lang: de
template: staking
emoji: ":money_with_wings:"
@@ -13,95 +13,90 @@ summaryPoints:
- Vertrauen Sie niemandem und geben Sie niemals den Zugang zu Ihren Geldern weiter
---
-## Was ist Solo-Staking? {#what-is-solo-staking}
+## Was ist Home-Staking? {#what-is-solo-staking}
-Solo-Staking ist das [Betreiben eines Ethereum-Knotens](/run-a-node/), der mit dem Internet verbunden ist, und das Hinterlegen von 32 ETH, um einen [Validator zu aktivieren](#faq), wodurch Sie direkt am Netzwerkkonsens teilnehmen können.
+Home-Staking ist der Vorgang, einen mit dem Internet verbundenen [Ethereum-Knoten](/run-a-node/) zu betreiben und 32 ETH einzuzahlen, um einen [Validator](#faq) zu aktivieren, wodurch Sie die Möglichkeit erhalten, direkt am Netzwerkkonsens teilzunehmen.
-**Das Solo-Staking erhöht die Dezentralisierung des Ethereum-Netzwerks **, damit Ethereum gegen Zensur resistenter und gegen Angriffe robuster wird. Andere Staking-Methoden können das Netzwerk nicht auf die gleiche Weise unterstützen. Das Solo-Staking ist die beste Staking-Option zur Absicherung von Ethereum.
+**Home-Staking erhöht die Dezentralisierung des Ethereum-Netzwerks**, wodurch Ethereum zensurresistenter und robuster gegen Angriffe wird. Andere Staking-Methoden unterstützen das Netzwerk möglicherweise nicht auf die gleiche Weise. Home-Staking ist die beste Staking-Option zur Sicherung von Ethereum.
-Ein Ethereum-Knoten besteht sowohl aus einem Client der Ausführungsschicht (Execution Layer, EL) als auch aus einem Client der Konsensschicht (Client Layer, CL). Diese Kunden sind Software, die mit einem gültigen Satz von Signaturschlüsseln zusammenarbeiten, um Transaktionen und Blöcke zu verifizieren, den korrekten Kopf der Kette zu bestätigen, Bestätigungen zu attestieren und Blöcke vorzuschlagen.
+Ein Ethereum-Knoten besteht sowohl aus einem Client der Ausführungsebene (EL) als auch aus einem Client der Konsensebene (CL). Diese Clients sind Software, die zusammen mit einem gültigen Satz von Signaturschlüsseln zusammenarbeitet, um Transaktionen und Blöcke zu verifizieren, den korrekten Head der Chain zu bestätigen, Bestätigungen zu aggregieren und Blöcke vorzuschlagen.
-Solo-Staker sind für den Betrieb der Hardware verantwortlich, die zum Ausführen dieser Clients erforderlich ist. Es wird dringend empfohlen, dafür einen fest zugeordneten Computer zu verwenden, den Sie von zu Hause aus betreiben, denn dies ist für die Gesundheit des Netzwerks sehr vorteilhaft.
+Home-Staker sind für den Betrieb der Hardware verantwortlich, die für die Ausführung dieser Clients erforderlich ist. Es wird dringend empfohlen, hierfür einen dedizierten Computer zu verwenden, den Sie von zu Hause aus betreiben – dies ist für die Gesundheit des Netzwerks äußerst vorteilhaft.
-Ein Solo-Staker erhält Belohnungen direkt vom Protokoll dafür, dass sein Validator ordnungsgemäß funktioniert und online bleibt.
+Ein Hausbesitzer erhält Belohnungen direkt vom Protokoll dafür, dass er dafür sorgt, dass sein Validator ordnungsgemäß funktioniert und online ist.
-## Warum Solo-Staken? {#why-stake-solo}
+## Warum von zu Hause aus staken? {#why-stake-solo}
-Das Solo-Staking bringt mehr Verantwortung mit sich, bietet Ihnen aber die maximale Kontrolle über Ihre Mittel und Ihre Staking-Einstellungen.
+Home Staking bringt mehr Verantwortung mit sich, bietet Ihnen jedoch maximale Kontrolle über Ihre Gelder und Ihr Abstecken aufstellen.
-
-## Überlegungen vor dem Solo-Staking {#considerations-before-staking-solo}
+## Überlegungen vor dem Home-Staking {#considerations-before-staking-solo}
-So sehr wir uns wünschen, dass das Solo-Staking für alle zugänglich und risikofrei wäre, spiegelt dies nicht die Realität wider. Es gibt einige praktische und ernsthafte Überlegungen, die Sie beachten sollten, bevor Sie sich entscheiden, Ihre ETH solo zu staken.
+So sehr wir uns auch wünschen, dass Home-Staking für jeden zugänglich und risikofrei wäre, so ist dies nicht die Realität. Es gibt einige praktische und ernsthafte Überlegungen, die Sie berücksichtigen sollten, bevor Sie sich für das Home-Staking Ihrer ETH entscheiden.
-
-Wenn Sie Ihren eigenen Knoten betreiben, sollten Sie einige Zeit damit verbringen, die Verwendung der von Ihnen gewählten Software zu erlernen. Dies umfasst das Lesen der relevanten Dokumentation und das Einstimmen auf die Kommunikationskanäle dieser Entwicklerteams.
+
+Wenn Sie Ihren eigenen Knoten betreiben, sollten Sie sich etwas Zeit nehmen, um zu lernen, wie Sie die von Ihnen gewählte Software verwenden. Dazu gehört das Lesen der relevanten Dokumentation und die Kenntnis der Kommunikationskanäle dieser Entwicklerteams.
-Je mehr Sie über die von Ihnen verwendete Software und die Funktionsweise von Proof-of-Stake (Stake-Nachweis) verstehen, desto weniger riskant ist es als Staker und desto einfacher wird es, alle Probleme zu beheben, die auf dem Weg als Node-Betreiber auftreten können.
-
+Je mehr Sie über die von Ihnen verwendete Software und die Funktionsweise von Proof-of-Stake verstehen, desto weniger riskant ist es als Staker und desto einfacher wird es, als Knotenbetreiber alle auftretenden Probleme zu beheben.
-
-Das Einrichten von Nodes erfordert ein angemessenes Maß an Sicherheit bei der Arbeit mit Computern, obwohl neue Tools dies im Laufe der Zeit einfacher machen. Das Verständnis der Befehlszeilenschnittstelle ist hilfreich, aber nicht mehr unbedingt erforderlich.
+
+Das Einrichten von Knoten erfordert einen gewissen Grad an Vertrautheit im Umgang mit Computern, obwohl neue Tools dies im Laufe der Zeit einfacher machen. Das Verständnis der Kommandozeilenschnittstelle ist hilfreich, aber nicht mehr zwingend erforderlich.
-Es erfordert auch eine sehr einfache Hardware-Konfiguration und ein gewisses Verständnis der empfohlenen Mindestspezifikationen.
-
+Es erfordert auch eine sehr einfache Hardware-Einrichtung und ein gewisses Verständnis der empfohlenen Mindestspezifikationen.
-
-Genauso wie private Schlüssel Ihre Ethereum-Adresse sichern, müssen Sie Schlüssel speziell für Ihren Validator generieren. Sie müssen sich informieren, wie Sie Seed-Phrasen oder private Schlüssel sicher aufbewahren.{' '}
+
+So wie private Schlüssel Ihre Ethereum-Adresse sichern, müssen Sie auch speziell für Ihren Validator Schlüssel generieren. Sie müssen verstehen, wie Sie Seed-Phrases oder private Schlüssel sicher aufbewahren.{' '}
-[Ethereum-Sicherheit und Betrugsprävention](/security/)
-
+[Ethereum-Sicherheit und Betrugsprävention](/security/)
-
-Hardware fällt gelegentlich aus, Netzwerkverbindungen fallen aus und Client-Software muss gelegentlich aktualisiert werden. Die Node-Wartung ist unvermeidlich und erfordert von Zeit zu Zeit Ihre Aufmerksamkeit. Sie sollten sicher sein, dass Sie über alle erwarteten Netzwerk-Upgrades oder andere wichtige Client-Upgrades informiert sind.
+
+Hardware fällt gelegentlich aus, Netzwerkverbindungen schlagen fehl und Client-Software muss gelegentlich aktualisiert werden. Die Wartung von Knoten ist unvermeidlich und erfordert gelegentlich Ihre Aufmerksamkeit. Sie sollten sicherstellen, dass Sie über alle erwarteten Netzwerk-Upgrades oder andere wichtige Client-Upgrades informiert bleiben.
-
-Ihre Belohnungen sind proportional zu der Zeit, in der Ihr Validator online ist und ordnungsgemäß attestiert. Ausfallzeiten führen zu Strafen, die proportional dazu sind, wie viele andere Validatoren gleichzeitig offline sind, aber führen nicht zum Slashing. Auch die Bandbreite spielt eine Rolle, da die Belohnungen für Bescheinigungen, die nicht rechtzeitig eingehen, gekürzt werden. Die Anforderungen sind unterschiedlich, es wird jedoch ein Minimum von 10 Mb/s Upload und Download empfohlen.
+
+Ihre Belohnungen sind proportional zu der Zeit, in der Ihr Validator online ist und ordnungsgemäß Bestätigungen abgibt. Ausfallzeiten führen zu Strafen, die proportional zur Anzahl der gleichzeitig offline geschalteten Validatoren sind, aber führen nicht zu Slashing. Auch die Bandbreite ist wichtig, da die Belohnungen für nicht rechtzeitig erhaltene Bestätigungen verringert werden. Die Anforderungen variieren, aber es wird ein Minimum von 10 Mbit/s für Up- und Download empfohlen.
-
-Im Gegensatz zu Strafen für Inaktivität in Offline-Zeiten ist Slashing eine viel schwerwiegendere Strafe, die auf böswillige Vergehen beschränkt ist. Wenn Sie einen Minderheiten-Client mit Ihren Schlüsseln jeweils auf nur einer Maschine laden, wird das Risiko des Schrumpfens minimiert. Davon abgesehen müssen sich alle Staker der Risiken von Slashing bewusst sein.
+
+Im Gegensatz zu Inaktivitätsstrafen für das Offline-Sein ist Slashing eine wesentlich schwerwiegendere Strafe, die böswilligen Verstößen vorbehalten ist. Indem Sie einen Minderheits-Client betreiben und Ihre Schlüssel nur auf einem einzigen Gerät geladen haben, wird Ihr Risiko eines Slashings minimiert. Dennoch müssen sich alle Staker der Risiken des Slashings bewusst sein.
- Mehr über Slashing und den Lebenszyklus von Validatoren
-
-
+ Mehr über Slashing und den Lebenszyklus von Validatoren
+
-Ein Validator ist eine virtuelle Einheit, die auf Ethereum existiert und am Konsens des Ethereum-Protokolls teilnimmt. Validatoren werden durch ein Guthaben, einen öffentlichen Schlüssel und andere Eigenschaften dargestellt. Ein Validator-Client ist die Software, die im Namen des Validators handelt, indem sie seinen privaten Schlüssel hält und verwendet. Ein einzelner Validator-Client kann viele Schlüsselpaare enthalten und viele Validatoren steuern.
+Ein Validator ist eine virtuelle Entität, die auf Ethereum lebt und am Konsens des Ethereum-Protokolls teilnimmt. Validatoren werden durch ein Guthaben, einen öffentlichen Schlüssel und andere Eigenschaften dargestellt. Ein Validator-Client ist die Software, die im Namen des Validators handelt, indem sie dessen privaten Schlüssel hält und verwendet. Ein einzelner Validator-Client kann viele Schlüsselpaare enthalten und somit viele Validatoren steuern.
-
-Jedes Schlüsselpaar, das einem Validator zugeordnet ist, erfordert genau 32 ETH, um aktiviert zu werden. Mehr ETH, die in einen einzigen Schlüsselsatz eingezahlt werden, erhöhen das Belohnungspotenzial nicht, da jeder Validator auf ein effektives Guthaben von 32 ETH begrenzt ist. Dies bedeutet, dass das Staking in Schritten von 32 ETH erfolgt, von denen jeder seinen eigenen Schlüsselsatz und sein eigenes Guthaben hat.
+
+Ja, moderne Validator-Konten können bis zu 2048 ETH halten. Zusätzliche ETH über 32 werden schrittweise verzinst und erhöhen sich in ganzzahligen Schritten, wenn Ihr tatsächliches Guthaben steigt. Dies wird als Ihr effektives Guthaben bezeichnet.
-Zahlen Sie nicht mehr als 32 ETH für einen einzelnen Validator ein. Sie wird Ihre Belohnungen nicht erhöhen. Wenn eine Auszahlungsadresse für den Validator festgelegt wurde, werden überschüssige Gelder über 32 ETH während des nächsten [Validator-Sweeps](/staking/withdrawals/#validator-sweeping) automatisch an diese Adresse überwiesen.
+Um das effektive Guthaben eines Kontos und damit die Belohnungen zu erhöhen, muss ein Puffer von 0,25 ETH über einer beliebigen Ganzzahl-ETH-Schwelle überschritten werden. Beispielsweise müsste ein Konto mit einem tatsächlichen Guthaben von 32,9 und einem effektiven Guthaben von 32 weitere 0,35 ETH verdienen, um sein tatsächliches Guthaben über 33,25 zu bringen, bevor eine Erhöhung des effektiven Guthabens ausgelöst wird.
-Wenn Ihnen Solo-Staking zu anspruchsvoll erscheint, ziehen Sie die Nutzung eines [Staking-as-a-Service](/staking/saas/)-Anbieters in Betracht, oder wenn Sie mit weniger als 32 ETH arbeiten, schauen Sie sich die [Staking-Pools](/staking/pools/) an.
-
+Dieser Puffer verhindert auch, dass ein effektiver Saldo sinkt, bis er 0,25 ETH unter seinen aktuellen effektiven Saldo gefallen ist.
-
-Wenn man offline geht, während das Netzwerk ordnungsgemäß abgeschlossen wird, führt dies NICHT zu Slashing. Es fallen kleine Strafen für Inaktivität an, wenn Ihr Validator für eine bestimmte Epoche (jeweils 6,4 Minuten lang) nicht verfügbar ist, um dies zu bestätigen, aber dies unterscheidet sich stark von Slashing. Diese Strafen sind etwas geringer als die Belohnung, die Sie verdient hätten, wenn der Validator zur Bestätigung verfügbar gewesen wäre, und Verluste können mit ungefähr der gleichen Zeit zurückerstattet werden, wenn Sie wieder online sind.
+Jedes Schlüsselpaar, das einem Validator zugeordnet ist, benötigt mindestens 32 ETH, um aktiviert zu werden. Jedes darüber hinausgehende Guthaben kann jederzeit durch eine mit dieser Adresse signierte Transaktion an die zugehörige Auszahlungsadresse ausgezahlt werden. Alle Gelder, die das maximale effektive Guthaben übersteigen, werden in regelmäßigen Abständen automatisch ausgezahlt.
-Beachten Sie, dass Strafen für Inaktivität proportional dazu sind, wie viele Validatoren gleichzeitig offline sind. In Fällen, in denen ein großer Teil des Netzwerks auf einmal offline ist, sind die Strafen für jeden dieser Validatoren größer, als wenn ein einzelner Validator nicht verfügbar ist.
+Wenn Ihnen Home-Staking zu anspruchsvoll erscheint, ziehen Sie die Nutzung eines [Staking-as-a-Service](/staking/saas/)-Anbieters in Betracht, oder sehen Sie sich die [Staking-Pools](/staking/pools/) an, wenn Sie mit weniger als 32 ETH arbeiten.
-In extremen Fällen, wenn das Netzwerk nicht mehr fertig gestellt wird, weil mehr als ein Drittel der Validatoren offline sind, werden diese Benutzer unter einem sogenannten quadratischen Inaktivitätsleck leiden, das einen exponentiellen Abfluss von ETH von Offline-Validierungskonten darstellt. Dies ermöglicht es dem Netzwerk, sich schließlich selbst zu heilen, indem es die ETH von inaktiven Validatoren verbrennt, bis deren Kontostand 16 ETH erreicht. An diesem Punkt werden sie automatisch aus dem Validator-Pool herausgeworfen werden. Die verbleibenden Online-Validatoren werden schließlich wieder über 2/3 des Netzwerks verfügen und die qualifizierte Mehrheit haben, die erforderlich ist, um die Kette erneut abzuschließen.
-
+
+Offline zu gehen, während das Netzwerk ordnungsgemäß finalisiert, führt NICHT zu Slashing. Geringe Inaktivitätsstrafen fallen an, wenn Ihr Validator für eine bestimmte Epoche (jeweils 6,4 Minuten lang) nicht für Bestätigungen zur Verfügung steht, was sich jedoch stark von Slashing unterscheidet. Diese Strafen sind etwas geringer als die Belohnung, die Sie erhalten hätten, wenn der Validator für Bestätigungen zur Verfügung gestanden hätte. Die Verluste können durch eine ungefähr gleich lange Zeit, in der Sie wieder online sind, ausgeglichen werden.
-
-Kurz gesagt, dies kann nie vollständig garantiert werden, aber wenn Sie in gutem Glauben handeln, einen Minderheits-Client betreiben und Ihre Signaturschlüssel jeweils nur auf einem Computer aufbewahren, liegt das Slashing-Risiko bei nahezu null.
+Beachten Sie, dass die Strafen für Inaktivität proportional zur Anzahl der gleichzeitig offline geschalteten Validatoren sind. In Fällen, in denen ein großer Teil des Netzwerks gleichzeitig offline ist, sind die Strafen für jeden dieser Validatoren höher als bei der Nichtverfügbarkeit eines einzelnen Validators.
-Es gibt nur wenige spezifische Möglichkeiten, die dazu führen können, dass ein Validator geslashed und aus dem Netzwerk herausgeworfen wird. Zum Zeitpunkt des Verfassens dieses Artikels waren die aufgetretenen Slashings ausschließlich ein Produkt redundanter Hardware-Konfigurationen, bei denen Signaturschlüssel gleichzeitig auf zwei separaten Computern gespeichert werden. Dies kann unbeabsichtigt zu einer doppelten Abstimmung Ihrer Schlüssel führen. Das wiederum stellt ein strafbares Vergehen dar.
+In extremen Fällen, wenn das Netzwerk die Finalisierung einstellt, weil mehr als ein Drittel der Validatoren offline ist, erleiden diese Benutzer einen sogenannten quadratischen Inaktivitätsverlust, der einen exponentiellen Abfluss von ETH von Offline-Validator-Konten darstellt. Dies ermöglicht es dem Netzwerk, sich schließlich selbst zu heilen, indem die ETH inaktiver Validatoren verbrannt werden, bis ihr Guthaben 16 ETH erreicht. An diesem Punkt werden sie automatisch aus dem Validator-Pool entfernt. Die verbleibenden Online-Validatoren werden schließlich wieder mehr als 2/3 des Netzwerks ausmachen und so die erforderliche Supermajorität erreichen, um die Kette erneut zu finalisieren.
-Das Ausführen eines Clients mit qualifizierter Mehrheit (jeder Client, der von mehr als 2/3 des Netzwerks verwendet wird) birgt auch das Risiko eines potenziellen Slashing, falls dieser Client einen Fehler aufweist, der zu einer Chain-Fork führt. Dies kann zu einer fehlerhaften Fork führen, die abgeschlossen wird. Um zur beabsichtigten Kette zurückzukehren, müsste eine Surround-Abstimmung durchgeführt werden, indem man versucht, einen abgeschlossenen Block rückgängig zu machen. Auch dies ist ein strafbares Vergehen und kann einfach dadurch vermieden werden, dass stattdessen ein Minderheits-Client ausgeführt wird.
+
+Kurz gesagt, dies kann nie vollständig garantiert werden, aber wenn Sie in gutem Glauben handeln, einen Minderheits-Client betreiben und Ihre Signaturschlüssel jeweils nur auf einem Computer aufbewahren, ist das Risiko eines Slashings nahezu null.
+
+Es gibt nur wenige spezifische Vorgehensweisen, die dazu führen können, dass ein Validator einem Slashing unterzogen und aus dem Netzwerk entfernt wird. Zum Zeitpunkt der Erstellung dieses Dokuments waren die aufgetretenen Slashings ausschließlich auf redundante Hardware-Setups zurückzuführen, bei denen Signaturschlüssel gleichzeitig auf zwei separaten Maschinen gespeichert wurden. Dies kann unbeabsichtigt zu einer doppelten Abstimmung (Double Vote) durch Ihre Schlüssel führen, was ein durch Slashing strafbares Vergehen ist.
+
+Der Betrieb eines Supermajoritäts-Clients (jeder Client, der von über 2/3 des Netzwerks verwendet wird) birgt auch das Risiko eines potenziellen Slashings, falls dieser Client einen Fehler aufweist, der zu einem Chain-Fork führt. Dies kann zu einem fehlerhaften Fork führen, der finalisiert wird. Um zur beabsichtigten Kette zurückzukehren, müsste eine Surround Vote abgegeben werden, indem versucht wird, einen finalisierten Block rückgängig zu machen. Dies ist ebenfalls ein durch Slashing strafbares Vergehen und kann einfach durch den Betrieb eines Minderheits-Clients vermieden werden.
Äquivalente Fehler in einem Minderheits-Client würden niemals abgeschlossen und würden daher niemals zu einer Surround-Abstimmung, sondern einfach zu Inaktivitätsstrafen, nicht zu Slashing.
-
-Einzelne Clients können in Bezug auf Leistung und Benutzeroberfläche leicht variieren, da jeder von verschiedenen Teams mit einer Vielzahl von Programmiersprachen entwickelt wird. Davon abgesehen ist keiner von ihnen „am besten" Bei allen Produktions-Clients handelt es sich um eine hervorragende Software, die alle die gleichen Kernfunktionen zur Synchronisierung und Interaktion mit der Blockchain ausführen.
+
+Einzelne Clients können sich in Bezug auf Leistung und Benutzeroberfläche geringfügig unterscheiden, da sie von verschiedenen Teams unter Verwendung einer Vielzahl von Programmiersprachen entwickelt werden. Dennoch ist keiner von ihnen der "Beste". Alle Produktions-Clients sind ausgezeichnete Software-Komponenten, die alle die gleichen Kernfunktionen zur Synchronisierung und Interaktion mit der Blockchain ausführen.
-Da alle Produktions-Clients die gleiche Grundfunktionalität bieten, ist es sehr wichtig, dass Sie einen Minderheits-Client wählen, d. h. jeden Client, der derzeit NICHT von einer Mehrheit der Validatoren im Netzwerk verwendet wird. Dies mag kontraintuitiv klingen, aber wenn Sie einen Mehrheits- oder einen Client mit qualifizierter Mehrheit betreiben, besteht für Sie ein erhöhtes Risiko des Slashing im Falle eines Fehlers in diesem Client. Der Betrieb eines Minderheits-Client begrenzt diese Risiken drastisch.
+Da alle Produktions-Clients die gleiche Grundfunktionalität bieten, ist es sehr wichtig, dass Sie einen Minderheits-Client wählen, d. h. einen Client, der derzeit NICHT von einer Mehrheit der Validatoren im Netzwerk verwendet wird. Dies mag kontraintuitiv klingen, aber der Betrieb eines Majoritäts- oder Supermajoritäts-Clients setzt Sie einem erhöhten Slashing-Risiko aus, falls in diesem Client ein Fehler auftritt. Der Betrieb eines Minderheits-Clients begrenzt diese Risiken drastisch.
-Erfahren Sie mehr darüber, warum Client-Diversität entscheidend ist
-
+Erfahren Sie mehr darüber, warum Client-Diversität entscheidend ist
-
-Obwohl ein virtueller privater Server (VPS) als Ersatz für Heim-Hardware verwendet werden kann, spielen der physische Zugang und Standort Ihres Validator-Client eine Rolle. Zentralisierte Cloud-Lösungen wie Amazon Web Services oder Digital Ocean bieten den Vorteil, dass keine Hardware angeschafft und betrieben werden muss, was zur Zentralisierung des Netzwerks beiträgt.
+
+Obwohl ein virtueller privater Server (VPS) als Ersatz für die Hardware zu Hause verwendet werden kann, sind der physische Zugang und der Standort Ihres Validator-Clients sehr wohl von Bedeutung. Zentralisierte Cloud-Lösungen wie Amazon Web Services oder Digital Ocean bieten den Komfort, keine Hardware beschaffen und betreiben zu müssen, gehen aber auf Kosten der Zentralisierung des Netzwerks.
-Je mehr Validator-Clients auf einer einzigen zentralisierten Cloud-Speicherlösung laufen, desto gefährlicher wird es für diese Benutzer. Jedes Ereignis, das diese Anbieter offline schaltet, sei es durch einen Angriff, behördliche Anforderungen oder nur Strom-/Internetausfälle, führt dazu, dass jeder Validator-Client, der sich auf diesen Server verlässt, gleichzeitig offline geht.
+Je mehr Validator-Clients auf einer einzigen zentralisierten Cloud-Speicherlösung laufen, desto gefährlicher wird es für diese Benutzer. Jedes Ereignis, das diese Anbieter offline schaltet, sei es durch einen Angriff, regulatorische Anforderungen oder einfach nur Strom-/Internetausfälle, führt dazu, dass jeder Validator-Client, der auf diesen Server angewiesen ist, gleichzeitig offline geht.
-Offline-Strafen sind proportional dazu, wie viele andere gleichzeitig offline sind. Die Verwendung eines VPS erhöht das Risiko, dass Offline-Strafen schwerwiegender sind, und erhöht Ihr Risiko von quadratischen Lecks oder Slashing, falls der Ausfall groß genug ist. Um Ihr eigenes Risiko und das Risiko für das Netzwerk zu minimieren, wird Benutzern dringend empfohlen, ihre eigene Hardware zu erwerben und zu betreiben.
-
+Offline-Strafen sind proportional zur Anzahl der anderen, die gleichzeitig offline sind. Die Verwendung eines VPS erhöht das Risiko, dass Offline-Strafen schwerwiegender ausfallen, und erhöht Ihr Risiko von quadratischem Verlust oder Slashing, falls der Ausfall groß genug ist. Um Ihr eigenes Risiko und das Risiko für das Netzwerk zu minimieren, wird den Benutzern dringend empfohlen, ihre eigene Hardware zu beschaffen und zu betreiben.
-
+
Abhebungen jeglicher Art aus der Beaconchain erfordern die Angabe von Rücktrittsberechtigungen.
-Neue Staker setzen dies bei der Schlüsselgenerierung und Einzahlung. Bestehende Staker, die dies noch nicht eingestellt haben, können ihre Schlüssel aktualisieren, um diese Funktion zu unterstützen.
+Neue Staker legen dies zum Zeitpunkt der Schlüsselgenerierung und Einzahlung fest. Bestehende Staker, die dies noch nicht festgelegt haben, können ihre Schlüssel upgraden, um diese Funktionalität zu unterstützen.
Sobald die Auszahlungsdaten festgelegt sind, werden Prämienzahlungen (über den ursprünglichen 32) periodisch an die Auszahlungsadresse ausgezahlt.
Um Ihr gesamtes Guthaben zu entsperren und zu erhalten, müssen Sie auch den Prozess des Verlassens Ihres Validators abschließen.
-Mehr zu Staking-Auszahlungen
-
+Mehr zu Staking-Auszahlungen \n
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
- [Das Ethereum-Staking-Verzeichnis](https://www.staking.directory/) - _Eridian und Spacesider_
-- [Ethereums Client-Diversitätsproblem](https://hackernoon.com/Ethereums-Client-Diversitätsproblem) – _@emmanuelawosika 2022_
-- [Client-Diversität fördern](https://www.attestant.io/Posts/Client-Diversität-fördern/) – _Jim McDonald 2022_
-- [Client-Diversität auf der Konsensebene von Ethereum](https://mirror.xyz/jmcook.eth/S7ONEka_0RgtKTZ3-dakPmAHQNPvuj15nh0YGKPFriA) – _jmcook.eth 2022_
-- [Anleitung: Ethereum-Validator-Hardware kaufen](https://www.youtube.com/watch?v=C2wwu1IlhDc) – _EthStaker 2022_
-- [Schritt für Schritt: Wie man dem Ethereum 2.0 Testnetz beitritt](https://kb.beaconcha.in/Guides/Tutorium-eth2-Multi-Client) - _ Butta_
-- [Eth2-Slashing-Präventionstipps](https://medium.com/prysmatic-labs/eth2-Slashing-Präventionstipps-f6faa5025f50) – _Raul Jordan 2020 _
+- [Das Problem der Client-Diversität bei Ethereum](https://hackernoon.com/ethereums-client-diversity-problem) - _@emmanuelawosika 2022_
+- [Hilfe für die Client-Diversität](https://www.attestant.io/posts/helping-client-diversity/) - _Jim McDonald 2022_
+- [Client-Diversität auf der Konsensebene von Ethereum](https://mirror.xyz/jmcook.eth/S7ONEka_0RgtKTZ3-dakPmAHQNPvuj15nh0YGKPFriA) - _jmcook.eth 2022_
+- [Anleitung: Kauf von Ethereum-Validator-Hardware](https://www.youtube.com/watch?v=C2wwu1IlhDc) - _EthStaker 2022_
+- [Eth2-Tipps zur Slashing-Prävention](https://medium.com/prysmatic-labs/eth2-slashing-prevention-tips-f6faa5025f50) - _Raul Jordan 2020_
-Staking-Auszahlungen wurden mit dem Shanghai/Capella-Upgrade aktiviert, welches am 12. April 2023 durchgeführt wurde. Mehr über Shanghai/Capella erfahren
-
+**Staking-Auszahlungen** beziehen sich auf Übertragungen von ETH von einem Validatorkonto auf der Konsensebene von Ethereum (der Beacon Chain) an die Ausführungsebene, auf der damit Transaktionen durchgeführt werden können.
-**Staking-Auszahlungen** beziehen sich auf die Übertragung von ETH von einem Validator-Konto in der Konsensschicht von Ethereum (der Beacon Chain) zur Ausführungsschicht, in der damit Transaktionen durchgeführt werden können.
-
-**Belohnungszahlungen für überschüssige Guthaben** über 32 ETH werden automatisch und regelmäßig an eine mit jedem Validator verknüpfte Auszahlungsadresse gesendet, sobald sie vom Benutzer angegeben wurde. Benutzer können auch das **Staking vollständig beenden** und damit ihr gesamtes Validator-Guthaben freigeben.
+\*\*Belohnungszahlungen für Guthabenüberschüsse über 32 ETH werden automatisch und regelmäßig an eine mit jedem Validator verknüpfte Auszahlungsadresse gesendet, sobald diese vom Benutzer angegeben wurde. Benutzer können das **Staking auch vollständig beenden** und damit ihr gesamtes Validator-Guthaben freigeben.
## Staking-Belohnungen {#staking-rewards}
@@ -46,31 +42,30 @@ Die Angabe einer Auszahlungsadresse ist ein erforderlicher Schritt für jedes Va
-
- Jedem Validatoren-Konto kann nur eine einzige Abhebungsadresse zugewiesen werden, und zwar nur einmal. Sobald eine Adresse ausgewählt und an die Konsensus-Ebene übermittelt wurde, lässt sich dieser Vorgang nicht mehr rückgängig machen. Überprüfen Sie die Besitzverhältnisse und die Richtigkeit der angegebenen Adresse, bevor Sie sie einreichen.
+Jedem Validatorkonto kann nur ein einziges Mal eine Auszahlungsadresse zugewiesen werden. Sobald eine Adresse ausgewählt und an die Konsensebene übermittelt wurde, kann dies nicht mehr rückgängig gemacht oder geändert werden. Überprüfen Sie die Besitzverhältnisse und die Richtigkeit der angegebenen Adresse, bevor Sie sie einreichen.
In der Zwischenzeit besteht keine Bedrohung für Ihre Gelder, wenn Sie dies nicht tun, vorausgesetzt, Ihre Mnemonic-/Seed-Phrase ist offline sicher aufbewahrt und wurde in keiner Weise kompromittiert. Wenn keine Auszahlungsinformationen hinzugefügt werden, bleibt das ETH einfach im Validator-Konto gesperrt, wie es bislang der Fall war, bis eine Auszahlungsadresse angegeben wird.
-## Das vollständige Beenden des Staking {#exiting-staking-entirely}
+## Staking vollständig beenden {#exiting-staking-entirely}
-Die Angabe einer Auszahlungsadresse ist erforderlich, bevor _irgendwelche_ Gelder aus dem Guthaben eines Validator-Kontos übertragen werden können.
+Die Angabe einer Auszahlungsadresse ist erforderlich, bevor _irgendwelche_ Gelder vom Guthaben eines Validatorkontos überwiesen werden können.
Benutzer, die das Staking vollständig beenden und ihr gesamtes Guthaben abheben möchten, müssen auch eine „freiwillige Ausstiegsnachricht" mit Validator-Schlüsseln unterzeichnen und übermitteln, die den Prozess des Ausstiegs aus dem Staking einleitet. Der Vorgang erfolgt mit Ihrem Validator-Client und wird an Ihren Konsens-Node übermittelt. Dafür fallen keine Gas-Kosten an.
Der Prozess, bei dem ein Validator aus dem Staking aussteigt, dauert je nachdem, wie viele andere gleichzeitig aussteigen, unterschiedlich lange. Sobald der Vorgang abgeschlossen ist, ist dieses Konto nicht mehr dafür verantwortlich, Validator-Netzwerkaufgaben auszuführen, ist nicht mehr für Belohnungen berechtigt und hat sein ETH nicht mehr „aufs Spiel gesetzt". Zu diesem Zeitpunkt wird das Konto als vollständig „abhebbar" gekennzeichnet.
-Sobald ein Konto als „abhebbar" markiert wurde und Auszahlungsinformationen bereitgestellt wurden, gibt es nichts mehr, was ein Benutzer tun muss, außer zu warten. Konten werden automatisch und kontinuierlich von Block-Proposern auf berechtigte freigegebene Gelder durchsucht, und Ihr Kontoguthaben wird in voller Höhe (auch als „vollständiger Abzug" bekannt) während des nächsten Sweeps übertragen.
+Sobald ein Konto als „abhebbar" markiert wurde und Auszahlungsinformationen bereitgestellt wurden, gibt es nichts mehr, was ein Benutzer tun muss, außer zu warten. Konten werden automatisch und kontinuierlich von Block-Proposern auf berechtigte, freigegebene Gelder durchsucht, und Ihr Kontoguthaben wird vollständig (auch als „vollständige Auszahlung“ bekannt) während des nächsten Sweeps übertragen.
-## Wann sind Staking-Abhebungen aktiviert? {#when}
+## Wann wurden Auszahlungen beim Staking freigeschaltet? {#when}
-Staking-Abhebungen sind live! Die Funktionalität für das Abheben wurden als Teil des Shanghai/Capella Upgrades vom 12. April 2023 aktiviert.
+Die Auszahlungsfunktionalität wurde als Teil des Shanghai/Capella-Upgrades aktiviert, das am **12. April 2023** stattfand.
Das Shanghai/Capella Upgrade ermöglicht ETH, das gestaked wurde, mit regulären Ethereum-Konten zurückzufordern. Dies schloss den Kreis hinsichtlich der Bereitstellung von Liquidität und brachte Ethereum einen Schritt näher auf seinem Weg, ein nachhaltiges, skalierbares, sicheres dezentralisiertes Ökosystem zu schaffen.
-- [Mehr zur Geschichte von Ethereum](/ethereum-forks/)
+- [Mehr zur Ethereum-Geschichte](/ethereum-forks/)
- [Mehr zur Ethereum-Roadmap](/roadmap/)
## Wie funktionieren Auszahlungen? {#how-do-withdrawals-work}
@@ -83,7 +78,7 @@ Sehen Sie sich diese Erklärung für die Abhebungen von Ethereum von Finematics
-Stellen Sie sich eine analoge Uhr vor. Der Zeiger der Uhr zeigt auf die Stunde, bewegt sich in eine Richtung, lässt keine Stunden aus und kehrt schließlich nach Erreichen der letzten Zahl wieder an den Anfang zurück.
-Stellen Sie sich nun vor, dass die Uhr statt 1 bis 12 die Zahlen 0 bis N hat (die Gesamtzahl der jemals auf der Konsensus-Ebene registrierten Validatoren-Konten, über 500.000 im Januar 2023).
-Der Zeiger auf der Uhr zeigt auf den nächstenValidator, der auf zulässige Abhebungen geprüft werden muss. Es beginnt bei 0 und schreitet rundherum fort, ohne irgendwelche Konten zu überspringen. Wenn der letzte Validator erreicht ist, beginnt der Zyklus von vorne.
+Stellen Sie sich eine analoge Uhr vor. Der Zeiger auf der Uhr zeigt auf die Stunde, bewegt sich in eine Richtung, überspringt keine Stunden und läuft schließlich wieder zum Anfang zurück, nachdem die letzte Zahl erreicht wurde.
+Stellen Sie sich nun statt 1 bis 12 vor, die Uhr hätte die Zahlen von 0 bis N (die Gesamtzahl der Validatorkonten, die jemals auf der Konsensebene registriert wurden; über 500.000 mit Stand Januar 2023).
+Der Zeiger auf der Uhr zeigt auf den nächsten Validator, der auf berechtigte Auszahlungen geprüft werden muss. Er beginnt bei 0 und schreitet rundherum fort, ohne irgendwelche Konten zu überspringen. Wenn der letzte Validator erreicht ist, beginnt der Zyklus von vorne.
-#### Überprüfung eines Kontos auf Auszahlungen {#checking-an-account-for-withdrawals}
+#### Prüfung eines Kontos auf Auszahlungen {#checking-an-account-for-withdrawals}
Bei der Durchsicht der Validatoren auf mögliche Auszahlungen bewertet der Vorschlagende jeden überprüften Validator mit einer kurzen Fragenreihe. Auf diese Weise wird entschieden, ob eine Auszahlung ausgelöst werden sollte und falls ja, wie viel ETH abgehoben werden soll.
1. **Wurde eine Auszahlungsadresse angegeben?** Wenn keine Auszahlungsadresse angegeben wurde, wird das Konto übersprungen und keine Auszahlung eingeleitet.
-2. **Hat der Validator den Prozess verlassen und ist das Guthaben abhebbar?** Sobald der Validator den Prozess komplett verlassen hat und der Zeitpunkt erreicht ist, in dem das Guthaben des Kontos als „abhebbar" gilt, wird eine vollständige Auszahlung veranlasst. Dies wird das gesamte verbleibende Guthaben an die Auszahlungsadresse übertragen.
-3. **Ist der effektive Kontostand auf 32 begrenzt?** Falls das Konto Auszahlungsberechtigungen besitzt, noch nicht vollständig beendet ist und über 32 anstehende Belohnungen hat, wird eine teilweise Auszahlung vorgenommen. Dabei werden lediglich die über 32 hinausgehenden Belohnungen an die Auszahlungsadresse des Benutzers übertragen.
+2. **Ist der Validator ausgestiegen und ist das Guthaben auszahlbar?** Wenn der Validator vollständig ausgestiegen ist und wir die Epoche erreicht haben, in der sein Konto als „auszahlbar“ gilt, wird eine vollständige Auszahlung verarbeitet. Dies wird das gesamte verbleibende Guthaben an die Auszahlungsadresse übertragen.
+3. **Ist das effektive Guthaben auf 32 begrenzt?** Wenn das Konto über Auszahlungsberechtigungen verfügt, nicht vollständig ausgestiegen ist und auf Belohnungen von über 32 ETH wartet, wird eine Teilauszahlung verarbeitet, bei der nur die Belohnungen über 32 ETH an die Auszahlungsadresse des Benutzers überwiesen werden.
Es gibt nur zwei Aktionen, die von Validatoren während des Lebenszyklus eines Validators durchgeführt werden, die diesen Ablauf direkt beeinflussen:
- Bereitstellung von Auszahlungsberechtigungen, um eine Form von Auszahlung zu ermöglichen
- Verlassen des Netzwerks, was eine vollständige Auszahlung anstößt
-### Kostenfreies Gas {#gas-free}
+### Gasfrei {#gas-free}
-Dieser Ansatz für Staking-Auszahlungen vermeidet, dass Staker manuell eine Transaktion einreichen müssen, die eine bestimmte Menge an ETH zur Auszahlung anfordert. Das bedeutet, dass **kein Gas (Transaktionsgebühr) erforderlich** ist und Auszahlungen auch nicht um den bestehenden Blockplatz der Ausführungsschicht konkurrieren.
+Dieser Ansatz für Staking-Auszahlungen vermeidet, dass Staker manuell eine Transaktion einreichen müssen, die eine bestimmte Menge an ETH zur Auszahlung anfordert. Das bedeutet, dass kein Gas (Transaktionsgebühr) erforderlich ist und Auszahlungen auch nicht um den bestehenden Blockplatz der Ausführungsebene konkurrieren.
### Wie oft erhalte ich meine Staking-Belohnungen? {#how-soon}
@@ -123,13 +118,13 @@ Indem wir diese Berechnung erweitern, können wir die Zeit abschätzen, die ben
-| Anzahl der Auszahlungen | Zeit bis zum Abschluss |
-| :-------------------: | :--------------: |
-| 400,000 | 3,5 Tage |
-| 500,000 | 4,3 Tage |
-| 600,000 | 5,2 Tage |
-| 700,000 | 6,1 Tage |
-| 800,000 | 7,0 Tage |
+| Anzahl der Auszahlungen | Dauer bis zum Abschluss |
+| :---------------------: | :---------------------: |
+| 400.000 | 3,5 Tage |
+| 500.000 | 4,3 Tage |
+| 600.000 | 5,2 Tage |
+| 700.000 | 6,1 Tage |
+| 800.000 | 7,0 Tage |
@@ -138,34 +133,32 @@ Wie Sie sehen, verlangsamt sich dieser Prozess, wenn mehr Validatoren im Netzwer
## Häufig gestellte Fragen {#faq}
-Nein, der Prozess zur Bereitstellung von Auszahlungsberechtigungen ist ein einmaliger Prozess und kann nach der Einreichung nicht mehr geändert werden.
-
+Nein, der Prozess zur Bereitstellung von Auszahlungsberechtigungen ist ein einmaliger Prozess und kann nach der Einreichung nicht mehr geändert werden.
-Durch die Einstellung einer Ausführungsebene wurden die Auszahlungsberechtigungen für diesen Validator dauerhaft geändert. Das bedeutet, dass die alten Berechtigungen nicht mehr funktionieren, und die neuen Berechtigungen zu einem Ausführungsschicht-Konto führen.
+Durch das Festlegen einer Auszahlungsadresse auf der Ausführungsebene werden die Auszahlungsberechtigungen für diesen Validator dauerhaft geändert. Das bedeutet, dass die alten Berechtigungen nicht mehr funktionieren, und die neuen Berechtigungen zu einem Ausführungsschicht-Konto führen.
Abhebungsadressen können entweder ein intelligenter Vertrag sein (durch seinen Code kontrolliert), oder ein externes Konto (EOA, kontrolliert durch seinen privaten Schlüssel). Aktuell existiert keine Möglichkeit für diese Konten, eine Nachricht zur Konsensschicht zurückzusenden, die eine Änderung der Validator-Anmeldeinformationen anzeigen würde. Eine solche Funktion einzuführen, würde das Protokoll unnötig komplizieren.
-Als Alternative zur Änderung der Auszahlungsadresse für einen bestimmten Validator können sich Benutzer dafür entscheiden, einen intelligenten Vertrag als ihre Auszahlungsadresse festzulegen, der Schlüsselrotationen handhaben könnte, wie zum Beispiel ein Safe. Benutzer, die ihre Mittel auf ihr eigenes extern kontrolliertes Konto (EOA) setzen, können einen vollständigen Ausstieg durchführen, um all ihre gestakten Mittel abzuheben, und dann mit neuen Anmeldeinformationen erneut staken.
-
+Als Alternative zur Änderung der Auszahlungsadresse für einen bestimmten Validator können sich Benutzer dafür entscheiden, einen intelligenten Vertrag als ihre Auszahlungsadresse festzulegen, der Schlüsselrotationen handhaben könnte, wie zum Beispiel ein Safe. Benutzer, die ihre Mittel auf ihr eigenes extern kontrolliertes Konto (EOA) setzen, können einen vollständigen Ausstieg durchführen, um all ihre gestakten Mittel abzuheben, und dann mit neuen Anmeldeinformationen erneut staken.
-Wenn Sie Teil eines [Staking-Pools](/staking/pools/) sind oder Staking-Token besitzen, sollten Sie sich bei Ihrem Anbieter erkundigen, wie Staking-Auszahlungen gehandhabt werden, da jeder Dienst anders funktioniert.
+Bist du in einem [Staking-Pool](/staking/pools/) oder hältst Staking-Token? Dann frage bei deinem Anbieter nach den Details zur Auszahlung, da die Handhabung je nach Dienst variiert.
-Im Allgemeinen sollten Benutzer in der Lage sein, ihr zugrundeliegendes gestaktes ETH zurückzufordern oder zu ändern, welchen Staking-Anbieter sie nutzen. Wenn ein bestimmter Pool zu groß wird, können Mittel abgezogen, eingelöst und mit einem kleineren Anbieter neu gestaked werden. Oder, wenn Sie genug ETH angesammelt haben, könnten Sie [von zu Hause aus staken](/staking/solo/).
+Im Allgemeinen sollten Benutzer in der Lage sein, ihr zugrundeliegendes gestaktes ETH zurückzufordern oder zu ändern, welchen Staking-Anbieter sie nutzen. Wenn ein bestimmter Pool zu groß wird, können Mittel abgezogen, eingelöst und mit einem kleineren Anbieter neu gestaked werden. Alternativ kannst du, wenn du genügend ETH besitzt, auch [von zu Hause aus staken](/staking/solo/).
@@ -174,11 +167,10 @@ title="Erfolgen Belohnungszahlungen (Teilauszahlungen) automatisch?"
eventCategory="FAQ"
eventAction="Do reward payments (partial withdrawals) happen automatically?"
eventName="read more">
-Ja, solange Ihr Validator eine Auszahlungsadresse bereitgestellt hat. Diese muss einmal bereitgestellt werden, um Auszahlungen zu ermöglichen, danach werden Belohnungszahlungen automatisch alle paar Tage mit jedem Durchlauf des Validators ausgelöst.
-
+Ja, solange Ihr Validator eine Auszahlungsadresse angegeben hat. Diese muss einmal bereitgestellt werden, um Auszahlungen zu ermöglichen, danach werden Belohnungszahlungen automatisch alle paar Tage mit jedem Durchlauf des Validators ausgelöst.
@@ -189,39 +181,37 @@ Sobald ein Validator den Ausstiegsprozess abgeschlossen hat und vorausgesetzt, d
-
-Auszahlungen sind darauf ausgelegt, automatisch durchgeführt zu werden und jegliches ETH zu übertragen, das nicht aktiv zum Staking beiträgt. Dies beinhaltet vollständige Salden für Konten, die den Ausstiegsprozess abgeschlossen haben.
+Auszahlungen sind darauf ausgelegt, automatisch angestoßen zu werden, wobei alle ETH übertragen werden, die nicht aktiv zum Stake beitragen. Dies beinhaltet vollständige Salden für Konten, die den Ausstiegsprozess abgeschlossen haben.
-Es ist nicht möglich, manuell spezifische Mengen an ETH zur Auszahlung anzufordern.
-
+Es ist nicht möglich, manuell spezifische Mengen an ETH zur Auszahlung anzufordern.
Validator-Betreibern wird empfohlen, die Seite Startplattform für Staking-Auszahlungen zu besuchen. Dort können sie mehr Details darüber erfahren, wie Sie Ihren Validator auf Auszahlungen vorbereiten, sowie Informationen zum Zeitpunkt der Ereignisse und zur Funktionsweise von Auszahlungen erhalten.
-Um Ihr Setup zuerst auf einem Testnet auszuprobieren, besuchen Sie das Holesky Testnet Staking Launchpad, um zu beginnen.
+Um Ihr Setup zuerst auf einem Testnet auszuprobieren, besuchen Sie das Hoodi Testnet Staking Launchpad, um zu beginnen.
-Nein. Sobald ein Validator ausgetreten ist und sein gesamtes Guthaben abgehoben wurde, werden alle zusätzlichen Einzahlungen auf diesen Validator automatisch während des nächsten Validator-Durchlaufs an die Auszahlungsadresse übertragen. Um ETH erneut zu staken, muss ein neuer Validator aktiviert werden.
-
+Nein. Sobald ein Validator ausgetreten ist und sein gesamtes Guthaben abgehoben wurde, werden alle zusätzlichen Einzahlungen auf diesen Validator automatisch während des nächsten Validator-Durchlaufs an die Auszahlungsadresse übertragen. Um ETH erneut zu staken, muss ein neuer Validator aktiviert werden.
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
-- [Startplattform für Staking-Auszahlungen](https://launchpad.ethereum.org/withdrawals)
-- [EIP-4895: Beacon-Kette implementiert Abhebungen als Operationen](https://eips.ethereum.org/EIPS/eip-4895)
-- [PEEPanEIP #94: Auszahlung von gestaktem ETH (Testing) mit Potuz & Hsiao-Wei Wang](https://www.youtube.com/watch?v=G8UstwmGtyE)
-- [PEEPanEIP#68: EIP-4895: Auszahlungen per Beacon Chain Push als Operationen mit Alex Stokes](https://www.youtube.com/watch?v=CcL9RJBljUs)
-- [Verständnis der effektiven Bilanz des Validators](https://www.attestant.io/posts/understanding-validator-effective-balance/)
+- [Staking Launchpad-Auszahlungen](https://launchpad.ethereum.org/withdrawals)
+- [EIP-4895: Auszahlungen per Beacon-Chain-Push als Operationen](https://eips.ethereum.org/EIPS/eip-4895)
+- [PEEPanEIP #94: Auszahlung von gestaktem ETH (Test) mit Potuz & Hsiao-Wei Wang](https://www.youtube.com/watch?v=G8UstwmGtyE)
+- [PEEPanEIP#68: EIP-4895: Auszahlungen per Beacon-Chain-Push als Operationen mit Alex Stokes](https://www.youtube.com/watch?v=CcL9RJBljUs)
+- [Das effektive Guthaben eines Validators verstehen](https://www.attestant.io/posts/understanding-validator-effective-balance/)
diff --git a/public/content/translations/de/web3/index.md b/public/content/translations/de/web3/index.md
index 557487446cc..36818219521 100644
--- a/public/content/translations/de/web3/index.md
+++ b/public/content/translations/de/web3/index.md
@@ -6,17 +6,22 @@ lang: de
# Einführung in Web3 {#introduction}
+
+
-#### Resistent gegenüber Zensur {#censorship-resistance}
+#### Zensurresistenz {#censorship-resistance}
Die Machtverteilung zwischen Plattformen und den Urhebern von Inhalten ist äußerst unausgewogen.
@@ -81,11 +86,11 @@ Bei Web3 befinden sich die Daten in der Blockchain. Wenn Sie sich entscheiden, e
Im Web 2.0 müssen die Urheber von Inhalten darauf vertrauen, dass die Plattformen die Regeln nicht ändern. Doch Resistenz gegenüber Zensur ist eine grundlegende Eigenschaft von Web3-Plattformen.
-#### Dezentralisierte Autonome Organisationen (DAO) {#daos}
+#### Dezentrale autonome Organisationen (DAOs) {#daos}
Neben dem Besitz Ihrer Daten in Web3 können Sie die Plattform als Kollektiv besitzen und dabei Token verwenden, die wie Aktien eines Unternehmens wirken. Mit DAOs können Sie dezentrale Eigentumsverhältnisse einer Plattform koordinieren und Entscheidungen über dessen Zukunft treffen.
-DAOs werden technisch definiert als vereinbarte [Smart Contracts](/glossary/#smart-contract), die eine dezentralisierte Entscheidungsfindung über einen Pool von Ressourcen (Tokens) automatisieren. Benutzer mit Token stimmen darüber ab, wie Ressourcen verwendet werden, und der Code führt automatisch das Abstimmungsergebnis aus.
+DAOs sind technisch als vereinbarte [Smart Contracts](/glossary/#smart-contract) definiert, die die dezentralisierte Entscheidungsfindung über einen Pool von Ressourcen (Tokens) automatisieren. Benutzer mit Token stimmen darüber ab, wie Ressourcen verwendet werden, und der Code führt automatisch das Abstimmungsergebnis aus.
Allerdings definieren Menschen viele Web3-Communities als DAOs. Diese Gemeinschaften haben alle unterschiedliche Ebenen der Dezentralisierung und Automatisierung per Code. Derzeit untersuchen wir, was DAOs sind und wie sie sich in Zukunft entwickeln könnten.
@@ -103,33 +108,34 @@ Allerdings definieren Menschen viele Web3-Communities als DAOs. Diese Gemeinscha
Normalerweise würden Sie für jede von Ihnen genutzte Plattform ein Konto anlegen. Vielleicht haben Sie zum Beispiel ein Twitter-Konto, ein YouTube-Konto und ein Reddit-Konto. Möchten Sie Ihren Anzeigenamen oder Ihr Profilbild ändern? Dann müssen Sie das für jedes einzelne Konto tun. In einigen Fällen können Sie sich über soziale Netzwerke anmelden, aber das birgt ein bekanntes Problem: Zensur. Mit einem einzigen Klick können diese Plattformen Sie aus Ihrem gesamten Online-Leben aussperren. Schlimmer noch, viele Plattformen verlangen, dass Sie ihnen persönliche Daten anvertrauen, um ein Konto zu erstellen.
-Web3 löst diese Probleme, indem es Ihnen ermöglicht, Ihre digitale Identität mit einer Ethereum-Adresse und einem Profil für Ihren [Ethereum Name Service (ENS)](/glossary/#ens) zu steuern. Wenn Sie eine Ethereum-Adresse benutzen, können Sie eine einzige plattformübergreifende Anmeldung nutzen, die sicher, zensurresistent und anonym ist.
+Web3 löst diese Probleme, indem es dir ermöglicht, deine digitale Identität mit einer Ethereum-Adresse und einem [Ethereum Name Service (ENS)](/glossary/#ens)-Profil zu steuern. Wenn Sie eine Ethereum-Adresse benutzen, können Sie eine einzige plattformübergreifende Anmeldung nutzen, die sicher, zensurresistent und anonym ist.
-### Ursprüngliche Zahlungen {#native-payments}
+### Native Zahlungen {#native-payments}
-Die Zahlungsinfrastruktur von Web2 stützt sich auf Banken und Zahlungsdienstleister und schließt Menschen ohne Bankkonto oder solche, die zufällig im falschen Land leben, aus. Web3 verwendet Token wie [ETH](/glossary/#ether), um Geld direkt im Browser zu senden, und benötigt keine vertrauenswürdige dritte Partei.
+Die Zahlungsinfrastruktur von Web2 stützt sich auf Banken und Zahlungsdienstleister und schließt Menschen ohne Bankkonto oder solche, die zufällig im falschen Land leben, aus.
+Web3 verwendet Token wie [ETH](/glossary/#ether), um Geld direkt im Browser zu senden, und benötigt keine vertrauenswürdige dritte Partei.
Mehr zu ETH
-## Web3-Einschränkungen {#web3-limitations}
+## Einschränkungen von Web3 {#web3-limitations}
Trotz der zahlreichen Vorteile von Web3 in seiner jetzigen Form gibt es nach wie vor viele Einschränkungen, die das Ökosystem überwinden muss, um sich weiter zu entfalten.
### Zugänglichkeit {#accessibility}
-Wichtige Web3-Funktionen, wie z. B. das Anmelden mit Ethereum, sind bereits für jedermann zum Nulltarif verfügbar. Doch die relativen Transaktionskosten sind für viele noch immer unerschwinglich. Es ist wahrscheinlich, dass Web3 aufgrund der hohen Transaktionsgebühren in weniger wohlhabenden Entwicklungsländern womöglich weniger genutzt wird. Bei Ethereum werden diese Herausforderungen durch [die Roadmap](/roadmap/) und [Layer-2-Skalierungslösungen](/glossary/#layer-2) bewältigt. Die Technologie steht bereit. Doch wir benötigen einen höheren Grad an Akzeptanz auf Ebene 2, um Web3 allen zugänglich zu machen.
+Wichtige Web3-Funktionen, wie z. B. das Anmelden mit Ethereum, sind bereits für jedermann zum Nulltarif verfügbar. Doch die relativen Transaktionskosten sind für viele noch immer unerschwinglich. Es ist wahrscheinlich, dass Web3 aufgrund der hohen Transaktionsgebühren in weniger wohlhabenden Entwicklungsländern womöglich weniger genutzt wird. Auf Ethereum werden diese Herausforderungen durch [die Roadmap](/roadmap/) und [Layer-2-Skalierungslösungen](/glossary/#layer-2) bewältigt. Die Technologie steht bereit. Doch wir benötigen einen höheren Grad an Akzeptanz auf Ebene 2, um Web3 allen zugänglich zu machen.
### Benutzererfahrung {#user-experience}
-Die technische Hürde für den Einstieg in die Nutzung von Web3 ist derzeit zu hoch. Benutzer müssen sich mit Sicherheitsfragen auseinandersetzen, komplexe technische Dokumentationen verstehen und sich auf Benutzeroberflächen zurechtfinden, die keine intuitive Navigation bieten. Insbesondere [Wallet-Anbieter](/wallets/find-wallet/) arbeiten an der Lösung dieses Problems, doch es sind noch weitere Fortschritte nötig, bevor sich Web3 großflächig etabliert.
+Die technische Hürde für den Einstieg in die Nutzung von Web3 ist derzeit zu hoch. Benutzer müssen sich mit Sicherheitsfragen auseinandersetzen, komplexe technische Dokumentationen verstehen und sich auf Benutzeroberflächen zurechtfinden, die keine intuitive Navigation bieten. Insbesondere [Wallet-Anbieter](/wallets/find-wallet/) arbeiten an der Lösung dieses Problems, aber es sind noch weitere Fortschritte nötig, bevor sich Web3 großflächig durchsetzt.
### Bildung {#education}
-Web3 führt neue Paradigmen ein, für die es erforderlich ist, andere Denkmuster als die im Web2.0 verwendeten zu erlernen. Eine ähnliche Aufklärungskampagne fand statt, als das Web1.0 in den späten 1990er Jahren an Popularität gewann. Die Befürworter des World Wide Web nutzten eine Reihe von Aufklärungstechniken, um die Öffentlichkeit aufzuklären, von einfachen Metaphern (die Datenautobahn, Browser, Surfen im Web) bis hin zu [TV-Übertragungen](https://www.youtube.com/watch?v=SzQLI7BxfYI). Web3 ist nicht schwierig, es ist einfach anders. Aufklärungsinitiativen, die Web2-Nutzer über diese Web3-Paradigmen informieren, sind für den Erfolg von entscheidender Bedeutung.
+Web3 führt neue Paradigmen ein, für die es erforderlich ist, andere Denkmuster als die im Web2.0 verwendeten zu erlernen. Eine ähnliche Aufklärungskampagne fand statt, als Web1.0 in den späten 1990er Jahren an Popularität gewann; Befürworter des World Wide Web nutzten eine Reihe von Bildungstechniken, um die Öffentlichkeit aufzuklären, von einfachen Metaphern (die Datenautobahn, Browser, Surfen im Web) bis hin zu [Fernsehübertragungen](https://www.youtube.com/watch?v=SzQLI7BxfYI). Web3 ist nicht schwierig, es ist einfach anders. Aufklärungsinitiativen, die Web2-Nutzer über diese Web3-Paradigmen informieren, sind für den Erfolg von entscheidender Bedeutung.
-Ethereum.org trägt zur Aufklärung über Web3 durch unser [Übersetzungsprogramm](/contributing/translation-program/) bei, das darauf abzielt, wichtige Ethereum-Inhalte in so viele Sprachen wie möglich zu übersetzen.
+Ethereum.org trägt durch unser [Übersetzungsprogramm](/contributing/translation-program/) zur Web3-Bildung bei, das darauf abzielt, wichtige Ethereum-Inhalte in so viele Sprachen wie möglich zu übersetzen.
### Zentralisierte Infrastruktur {#centralized-infrastructure}
@@ -141,23 +147,23 @@ Web3 ist ein junges und sich weiterentwickelndes Ökosystem. Gavin Wood prägte
Wir stehen erst am Anfang der Entwicklung eines besseren Internets mit Web3, doch mit der weiteren Verbesserung der dafür erforderlichen Infrastruktur sieht die Zukunft des Internets rosig aus.
-## Wie kann ich mich einbringen {#get-involved}
+## Wie kann ich mitmachen? {#get-involved}
-- [Eine Wallet wählen](/wallets/)
-- [Eine Community finden](/community/)
-- [Web3-Anwendungen erkunden](/apps/)
-- [Einer DAO beitreten](/dao/)
-- [Web3 als Grundlage nutzen](/developers/)
+- [Hol dir eine Wallet](/wallets/)
+- [Finde eine Community](/community/)
+- [Erkunde Web3-Anwendungen](/apps/)
+- [Tritt einer DAO bei](/dao/)
+- [Entwickle auf Web3](/developers/)
-## Weiterführende Informationen {#further-reading}
+## Weiterführende Lektüre {#further-reading}
Web3 ist nicht starr definiert. Zahlreiche Community-Teilnehmer haben unterschiedliche Ansichten dazu. Hier sind einige von ihnen:
-- [Was ist Web3? Das dezentralisierte Internet der Zukunft erklärt](https://www.freecodecamp.org/news/what-is-web3) – _Nader Dabit_
-- [Sinnhaftigkeit von Web3](https://medium.com/l4-media/making-sense-of-web-3-c1a9e74dcae) _, Josh Stark_
-- [Warum Web3 wichtig ist](https://future.a16z.com/why-web3-matters/) – _Chris Dixon_
-- [Warum Dezentralisierung wichtig ist](https://onezero.medium.com/why-decentralization-matters-5e3f79f7638e) – _Chris Dixon_
-- [Die Web3-Landschaft](https://a16z.com/wp-content/uploads/2021/10/The-web3-Readlng-List.pdf) – _a16z_
-- [Die Web3-Debatte](https://www.notboring.co/p/the-web3-debate) – _Packy McCormick_
+- [Was ist Web3? The Decentralized Internet of the Future Explained](https://www.freecodecamp.org/news/what-is-web3) – _Nader Dabit_
+- [Making Sense of Web 3](https://medium.com/l4-media/making-sense-of-web-3-c1a9e74dcae) – _Josh Stark_
+- [Why Web3 Matters](https://a16zcrypto.com/posts/article/why-web3-matters/) — _Chris Dixon_
+- [Why Decentralization Matters](https://onezero.medium.com/why-decentralization-matters-5e3f79f7638e) - _Chris Dixon_
+- [The Web3 Landscape](https://a16z.com/wp-content/uploads/2021/10/The-web3-Readlng-List.pdf) – _a16z_
+- [The Web3 Debate](https://www.notboring.co/p/the-web3-debate) – _Packy McCormick_
+
+
+## Warum ist das wichtig? {#why-does-this-matter}
+
+Ethereum-Apps können Dinge tun, die mit traditionellen Apps unmöglich wären. Zum Beispiel Geld an einen völlig Fremden verleihen, mit der Garantie, dass man das Geld inklusive Zinsen zurückbekommt. Ganz ohne einen 'vertrauenswürdigen' Mittelsmann wie einen Anwalt, der die Transaktion abwickelt.
+
+Es gibt Apps für alles: Gaming, Finanzen, Arbeit, Messaging, Speicher und viele mehr. Die meisten Apps laufen werbefrei und sind nicht durch eingeschränkten Zugang begrenzt.
+
+Sie benötigen lediglich eine Ethereum-Wallet und ein wenig ETH, um jede beliebige Ethereum-App nutzen zu können.
+
+## Wie funktioniert das? {#how-does-it-work}
+
+Apps laufen über Smart Contracts - Programmcodes, die auf der Ethereum-Blockchain ausgeführt werden. Anders als herkömmliche Apps brauchen sie kein Unternehmen, um zu funktionieren.
+
+| Funktion | Traditionelle Apps | Ethereum-Apps |
+| ----------------------------- | ---------------------------- | ------------------------------- |
+| **Wer kontrolliert sie?** | Ein Unternehmen | Keiner |
+| **Läuft auf** | Privaten Unternehmensservern | Öffentliche Ethereum-Blockchain |
+| **Kann sie zensiert werden?** | Ja | Nein |
+| **Wer besitzt Ihr Daten?** | Normalerweise nicht Sie | Sie besitzen Ihre Daten |
+
+
+ Dapp steht für dezentrale Anwendungen. Diese werden auf Blockchain-Netzwerken wie Ethereum gebaut. Man nennt sie dezentral, da das darunterliegende Netzwerk dezentralisiert ist.
+
+
+
+ Mit einigen Anwendungen können Sie Krypto-Tokens verhandeln oder kaufen, aber nicht alle Apps sind dafür gedacht. Wenn Sie Ihre ersten Token kaufen möchten, besuchen Sie [ETH kaufen](/get-eth).
+
+
+
+ Mit einer Krypto-Wallet können Sie Ihre Tokens sicher aufbewahren und Ihr Ethereum-Account einfach verwalten. Es gibt zahlreiche gute Wallets, die jeweils für unterschiedliche Zwecke entwickelt wurden. Um herauszufinden, welche Wallet für Sie am besten geeignet ist, besuchen Sie unsere [Liste der Wallets](/wallets/find-wallet).
+
\ No newline at end of file
diff --git a/public/content/translations/de/whitepaper/index.md b/public/content/translations/de/whitepaper/index.md
index ac993b51584..52f9524c268 100644
--- a/public/content/translations/de/whitepaper/index.md
+++ b/public/content/translations/de/whitepaper/index.md
@@ -8,32 +8,32 @@ hideEditButton: true
# Ethereum Whitepaper {#ethereum-whitepaper}
-_Diese einleitende Arbeit wurde ursprünglich 2014 von Vitalik Buterin, dem Gründer von [Ethereum](/what-is-ethereum/), vor dem Projektstart im Jahr 2015 veröffentlicht. Es ist erwähnenswert, dass sich Ethereum, wie viele gemeinschaftlich gesteuerte Open-Source-Softwareprojekte, seit seiner anfänglichen Einführung weiterentwickelt hat._
+_Dieses Einführungspapier wurde ursprünglich 2014 von Vitalik Buterin, dem Gründer von [Ethereum](/what-is-ethereum/), vor dem Start des Projekts im Jahr 2015 veröffentlicht. Es ist erwähnenswert, dass sich Ethereum, wie viele gemeinschaftlich gesteuerte Open-Source-Softwareprojekte, seit seiner anfänglichen Einführung weiterentwickelt hat._
-_Obwohl diese Arbeit schon einige Jahre alt ist, pflegen wir sie nach wie vor, weil sie weiterhin als nützliche Referenz und präzise Darstellung von Ethereum und seiner Vision dient. Um mehr über die neuesten Entwicklungen von Ethereum und dazu zu erfahren, wie Änderungen am Protokoll vorgenommen werden, empfehlen wir [diese Anleitung](/learn/)._
+_Obwohl diese Arbeit schon einige Jahre alt ist, pflegen wir sie nach wie vor, weil sie weiterhin als nützliche Referenz und präzise Darstellung von Ethereum und seiner Vision dient. _Um mehr über die neuesten Entwicklungen von Ethereum und darüber zu erfahren, wie Änderungen am Protokoll vorgenommen werden, empfehlen wir [diesen Leitfaden](/learn/)._
-[Forscher und Akademiker, die eine historische oder kanonische Version des Whitepapers [vom Dezember 2014] suchen, sollten diese PDF-Datei verwenden.](./whitepaper-pdf/Ethereum_Whitepaper_-_Buterin_2014.pdf)
+[Forscher und Akademiker, die eine historische oder kanonische Version des Whitepapers [vom Dezember 2014] suchen, sollten dieses PDF verwenden.](./whitepaper-pdf/Ethereum_Whitepaper_-_Buterin_2014.pdf)
-## Eine Plattform der nächsten Generation für Smart Contracts und dezentralisierte Anwendungen {#a-next-generation-smart-contract-and-decentralized-application-platform}
+## Eine Smart-Contract- und dezentralisierte Anwendungsplattform der nächsten Generation {#a-next-generation-smart-contract-and-decentralized-application-platform}
-Satoshi Nakamotos Entwicklung von Bitcoin im Jahr 2009 wurde oft als radikale Weiterentwicklung von Geld und Währung gefeiert, da es sich dabei um das erste Beispiel eines digitalen Assets handelt, das weder eine Besicherung noch einen "[intrinsischen Wert](http://bitcoinmagazine.com/8640/an-exploration-of-intrinsic-value-what-it-is-why-bitcoin-doesnt-have-it-and-why-bitcoin-does-have-it/)" oder einen zentralisierten Herausgeber oder Kontrolleur hat. Ein anderer, wohl wichtigerer Teil des Bitcoin-Experiments ist jedoch die zugrunde liegende Blockchain-Technologie als Instrument des verteilten Konsenses, und so verlagert sich die Aufmerksamkeit rasch auf diesen anderen Aspekt von Bitcoin. Zu den häufig zitierten alternativen Anwendungen der Blockchain-Technologie gehören die Verwendung digitaler Assets auf der Blockchain zur Darstellung benutzerdefinierter Währungen und Finanzinstrumente („[Colored Coins](https://docs.google.com/a/buterin.com/document/d/1AnkP_cVZTCMLIzw4DvsW6M8Q2JC0lIzrTLuoWu2z1BE/edit)“), das Eigentum an einem zugrunde liegenden physischen Gerät („[Smart Property](https://en.bitcoin.it/wiki/Smart_Property)“), nicht vertretbare Assets wie Domänennamen („[Namecoin](http://namecoin.org)“) sowie komplexere Anwendungen, bei denen digitale Assets direkt von einem Stück Code kontrolliert und beliebige Regeln ("[Smart Contracts](http://www.fon.hum.uva.nl/rob/Courses/InformationInSpeech/CDROM/Literature/LOTwinterschool2006/szabo.best.vwh.net/idea.html)") oder sogar Blockchain-basierte „[dezentralisierte autonome Organisationen](http://bitcoinmagazine.com/7050/bootstrapping-a-decentralized-autonomous-corporation-part-i/)“ (DAOs) implementiert werden. Ethereum beabsichtigt, eine Blockchain mit einer eingebauten, vollwertigen, Turing-kompletten Programmiersprache bereitzustellen, die zur Erstellung von „Verträgen“ verwendet werden kann, mit denen beliebige Statusübergangsfunktionen kodiert werden können, so dass Benutzer jedes der oben beschriebenen Systeme sowie viele andere, die wir uns noch nicht vorstellen können, erstellen können. Dazu muss nur eine entsprechende Logik in ein paar Zeilen Code geschrieben werden.
+Satoshi Nakamotos Entwicklung von Bitcoin im Jahr 2009 wurde oft als radikale Entwicklung in Geld und Währung gefeiert, da es das erste Beispiel eines digitalen Vermögenswerts ist, der gleichzeitig keine Deckung oder "[intrinsischen Wert](https://bitcoinmagazine.com/culture/an-exploration-of-intrinsic-value-what-it-is-why-bitcoin-doesnt-have-it-and-why-bitcoin-does-have-it)" und keinen zentralisierten Emittenten oder Kontrolleur hat. Ein anderer, wohl wichtigerer Teil des Bitcoin-Experiments ist jedoch die zugrunde liegende Blockchain-Technologie als Instrument des verteilten Konsenses, und so verlagert sich die Aufmerksamkeit rasch auf diesen anderen Aspekt von Bitcoin. Häufig genannte alternative Anwendungen der Blockchain-Technologie umfassen die Verwendung von On-Blockchain-Digital-Assets zur Darstellung benutzerdefinierter Währungen und Finanzinstrumente ("[Colored Coins](https://docs.google.com/a/buterin.com/document/d/1AnkP_cVZTCMLIzw4DvsW6M8Q2JC0lIzrTLuoWu2z1BE/edit)"), das Eigentum an einem zugrunde liegenden physischen Gerät ("[Smart Property](https://en.bitcoin.it/wiki/Smart_Property)"), nicht-fungible Vermögenswerte wie Domainnamen ("[Namecoin](http://namecoin.org)") sowie komplexere Anwendungen, bei denen digitale Vermögenswerte direkt von einem Stück Code gesteuert werden, das beliebige Regeln implementiert ("[Smart Contracts](http://www.fon.hum.uva.nl/rob/Courses/InformationInSpeech/CDROM/Literature/LOTwinterschool2006/szabo.best.vwh.net/idea.html)") oder sogar blockchainbasierte "[dezentrale autonome Organisationen](http://bitcoinmagazine.com/7050/bootstrapping-a-decentralized-autonomous-corporation-part-i/)" (DAOs). Ethereum beabsichtigt, eine Blockchain mit einer eingebauten, vollwertigen, Turing-kompletten Programmiersprache bereitzustellen, die zur Erstellung von „Verträgen“ verwendet werden kann, mit denen beliebige Statusübergangsfunktionen kodiert werden können, so dass Benutzer jedes der oben beschriebenen Systeme sowie viele andere, die wir uns noch nicht vorstellen können, erstellen können. Dazu muss nur eine entsprechende Logik in ein paar Zeilen Code geschrieben werden.
## Einführung in Bitcoin und bestehende Konzepte {#introduction-to-bitcoin-and-existing-concepts}
-### Historie {#history}
+### Geschichte {#history}
-Das Konzept der dezentralisierten digitalen Währung sowie alternativer Anwendungen wie Eigentumsregistern gibt es seit Jahrzehnten. Die anonymen E-Cash-Protokolle der 1980er und 1990er Jahre, die sich hauptsächlich auf ein kryptografisches Primitiv stützten, das als Chaumian Blinding bekannt ist, boten eine Währung mit einem hohen Maß an Datenschutz, aber die Protokolle konnten sich aufgrund ihrer Abhängigkeit von einem zentralisierten Vermittler größtenteils nicht durchsetzen. 1998 war Wei Dais [b-money](http://www.weidai.com/bmoney.txt) der erste Vorschlag, der die Idee der Geldschöpfung durch das Lösen von Rechenrätseln und einen dezentralen Konsens vorstellte, aber der Vorschlag enthielt nur wenige Details darüber, wie der dezentralisiertee Konsens tatsächlich umgesetzt werden könnte. 2005 stellte Hal Finney das Konzept der „[wiederverwendbaren Proofs of Work](https://nakamotoinstitute.org/finney/rpow/)“ vor, ein System, das Ideen von b-money zusammen mit Adam Backs schwierig zu berechnenden Hashcash-Puzzles verwendet, um ein Konzept für eine Kryptowährung zu schaffen, aber auch hier blieb es hinter dem Ideal zurück, da es sich auf vertrauenswürdige Rechner als Backend stützte. 2009 setzte Satoshi Nakamoto zum ersten Mal eine dezentralisierte Währung durch die Kombination von Kryptografie mit öffentlichem Schlüssel und einem Konsensalgorithmus zur Nachverfolgung der Eigentumsverhältnisse von Coins, dem sogenannten „Proof-of-Work“, in die Praxis umgesetzt.
+Das Konzept der dezentralisierten digitalen Währung sowie alternativer Anwendungen wie Eigentumsregistern gibt es seit Jahrzehnten. Die anonymen E-Cash-Protokolle der 1980er und 1990er Jahre, die sich hauptsächlich auf ein kryptografisches Primitiv stützten, das als Chaumian Blinding bekannt ist, boten eine Währung mit einem hohen Maß an Datenschutz, aber die Protokolle konnten sich aufgrund ihrer Abhängigkeit von einem zentralisierten Vermittler größtenteils nicht durchsetzen. 1998 wurde Wei Dais [b-money](http://www.weidai.com/bmoney.txt) der erste Vorschlag, der die Idee der Geldschöpfung durch die Lösung von Rechenrätseln sowie eines dezentralen Konsens einführte, aber der Vorschlag enthielt nur wenige Details darüber, wie ein dezentraler Konsens tatsächlich umgesetzt werden könnte. Im Jahr 2005 führte Hal Finney ein Konzept von „[wiederverwendbaren Proofs of Work](https://nakamotoinstitute.org/finney/rpow/)“ ein, ein System, das Ideen von b-money zusammen mit Adam Backs rechnerisch schwierigen Hashcash-Puzzles verwendet, um ein Konzept für eine Kryptowährung zu schaffen, das aber wieder einmal hinter dem Ideal zurückblieb, da es auf Trusted Computing als Backend angewiesen war. 2009 setzte Satoshi Nakamoto zum ersten Mal eine dezentralisierte Währung durch die Kombination von Kryptografie mit öffentlichem Schlüssel und einem Konsensalgorithmus zur Nachverfolgung der Eigentumsverhältnisse von Coins, dem sogenannten „Proof-of-Work“, in die Praxis umgesetzt.
-Der Mechanismus hinter Proof-of-Work war ein Durchbruch in diesem Bereich, da er zwei Probleme gleichzeitig löste. Erstens bot er einen einfachen und einigermaßen effektiven Konsensalgorithmus, der es den Knoten im Netzwerk ermöglichte, sich gemeinsam auf eine Reihe kanonischer Aktualisierungen des Status des Bitcoin-Ledgers zu einigen. Zweitens wurde ein Mechanismus bereitgestellt, der den freien Eintritt in den Konsensprozess ermöglicht und das politische Problem der Entscheidung darüber, wer den Konsens beeinflussen darf, löst, während gleichzeitig Sybil-Angriffe verhindert werden. Dies geschieht, indem eine formale Barriere für die Teilnahme, wie z. B. das Erfordernis, als eindeutige Einheit auf einer bestimmten Liste registriert zu sein, durch eine wirtschaftliche Barriere ersetzt wird – das Gewicht eines einzelnen Knotens im Konsensabstimmungsprozess ist direkt proportional zur Rechenleistung, die der Knoten bereitstellt. Seitdem wurde ein alternativer Ansatz namens _Proof-of-Stake_ vorgeschlagen, bei dem die Gewichtung eines Knotens proportional zu seinen Währungsbeständen und nicht zu seinen Rechenressourcen erfolgt; die Erörterung der relativen Vorzüge der beiden Ansätze würde den Rahmen dieser Arbeit sprengen, aber es sei darauf hingewiesen, dass beide Ansätze als Rückgrat einer Kryptowährung dienen können.
+Der Mechanismus hinter Proof-of-Work war ein Durchbruch in diesem Bereich, da er zwei Probleme gleichzeitig löste. Erstens bot er einen einfachen und einigermaßen effektiven Konsensalgorithmus, der es den Knoten im Netzwerk ermöglichte, sich gemeinsam auf eine Reihe kanonischer Aktualisierungen des Status des Bitcoin-Ledgers zu einigen. Zweitens wurde ein Mechanismus bereitgestellt, der den freien Eintritt in den Konsensprozess ermöglicht und das politische Problem der Entscheidung darüber, wer den Konsens beeinflussen darf, löst, während gleichzeitig Sybil-Angriffe verhindert werden. Dies geschieht, indem eine formale Barriere für die Teilnahme, wie z. B. das Erfordernis, als eindeutige Einheit auf einer bestimmten Liste registriert zu sein, durch eine wirtschaftliche Barriere ersetzt wird – das Gewicht eines einzelnen Knotens im Konsensabstimmungsprozess ist direkt proportional zur Rechenleistung, die der Knoten bereitstellt. Seitdem wurde ein alternativer Ansatz namens _Proof-of-Stake_ vorgeschlagen, bei dem das Gewicht eines Knotens proportional zu seinen Währungsbeständen und nicht zu den Rechenressourcen berechnet wird; die Diskussion der relativen Vorzüge der beiden Ansätze würde den Rahmen dieses Papiers sprengen, aber es sollte beachtet werden, dass beide Ansätze als Rückgrat einer Kryptowährung dienen können.
-### Bitcoin als Statusübergangssystem {#bitcoin-as-a-state-transition-system}
+### Bitcoin als Zustandsübergangssystem {#bitcoin-as-a-state-transition-system}
-
+
Aus technischer Sicht kann man sich das Ledger einer Kryptowährung wie Bitcoin als ein Statusübergangssystem vorstellen, bei dem es einen „Status“ gibt, der aus dem Eigentumsstatus aller vorhandenen Bitcoins besteht, und eine „Statusübergangsfunktion“, die einen Status und eine Transaktion annimmt und einen neuen Status als Ergebnis ausgibt. In einem Standard-Banksystem beispielsweise ist der Status eine Bilanzaufstellung, eine Transaktion ist eine Anforderung, X $ von A nach B zu verschieben, und die Statusübergangsfunktion verringert den Wert auf dem Konto von A um X $ und erhöht den Wert auf dem Konto von B um X $. Wenn das Konto von A von vornherein weniger als X $ aufweist, gibt die Statusfunktion einen Fehler zurück. Daher kann man formell definieren:
```
-APPLY(S,TX) -> S' or ERROR
+APPLY(S,TX) -> S' oder ERROR
```
In dem oben definierten Bankensystem:
@@ -50,11 +50,11 @@ APPLY({ Alice: $50, Bob: $50 },"send $70 from Alice to Bob") = ERROR
Der „Status“ in Bitcoin ist die Sammlung aller Münzen (technisch gesehen „unverbrauchte Transaktionsausgaben“ oder UTXO), die geprägt und noch nicht ausgegeben wurden, wobei jede UTXO einen Nennwert und einen Eigentümer hat (definiert durch eine 20-Byte-Adresse, die im Wesentlichen ein kryptografischer öffentlicher Schlüssel ist[fn1](#notes)). Eine Transaktion enthält eine oder mehrere Eingaben, wobei jede Eingabe eine Referenz auf einen bestehenden UTXO und eine kryptografische Signatur enthält, die durch den privaten Schlüssel erzeugt wurde, der mit der Adresse des Eigentümers verknüpft ist, sowie eine oder mehrere Ausgaben, wobei jede Ausgabe einen neuen UTXO enthält, der dem Status hinzugefügt werden soll.
-Die Statusübergangsfunktion `APPLY(S,TX) -> S'` kann in etwa wie folgt definiert werden:
+Die Zustandsübergangsfunktion `APPLY(S,TX) -> S'` kann grob wie folgt definiert werden:
-
- Für jede Eingabe in
TX:
+ Für jeden Input in TX:
-
Wenn der referenzierte UTXO nicht in
S ist, wird ein Fehler zurückgegeben.
@@ -65,10 +65,10 @@ Die Statusübergangsfunktion `APPLY(S,TX) -> S'` kann in etwa wie folgt definier
-
- Wenn die Summe der Nennwerte aller Eingangs-UTXO kleiner ist als die Summe der Nennwerte aller Ausgangs-UTXO, wird ein Fehler zurückgegeben.
+ Wenn die Summe der Nennwerte aller Eingabe-UTXO kleiner ist als die Summe der Nennwerte aller Ausgabe-UTXO, wird ein Fehler zurückgegeben.
-
-
S ausgeben, wobei alle Eingangs-UTXO entfernt und alle Ausgangs-UTXO hinzugefügt wurden.
+ Gibt S zurück, wobei alle Eingabe-UTXOs entfernt und alle Ausgabe-UTXOs hinzugefügt wurden.
@@ -78,16 +78,16 @@ Die erste Hälfte des ersten Schritts verhindert, dass Transaktionsabsender, Coi
-Wenn wir Zugang zu einem vertrauenswürdigen zentralisierten Dienst hätten, wäre dieses System leicht zu implementieren; es könnte einfach genau wie beschrieben kodiert werden, wobei die Festplatte eines zentralisierten Servers verwendet wird, um den Status zu verfolgen. Da wir jedoch mit Bitcoin versuchen, ein dezentralisiertes Währungssystem aufzubauen, müssen wir das Status-Transaktionssystem mit einem Konsenssystem kombinieren, um sicherzustellen, dass alle über die Reihenfolge der Transaktionen übereinstimmen. Der dezentralisierte Konsensprozess von Bitcoin erfordert, dass die Knoten im Netzwerk kontinuierlich versuchen, Pakete von Transaktionen, sogenannte „Blöcke“, zu erzeugen. Das Netzwerk ist darauf ausgelegt, ungefähr alle zehn Minuten einen Block zu erzeugen, wobei jeder Block einen Zeitstempel, eine Nonce, einen Verweis auf den vorherigen Block (also den entsprechenden Hash) und eine Liste aller Transaktionen enthält, die seit dem vorherigen Block stattgefunden haben. Im Laufe der Zeit entsteht so eine persistente, ständig wachsende „Blockchain“, die sich kontinuierlich aktualisiert, um den neuesten Status des Bitcoin-Ledgers darzustellen.
+Wenn wir Zugang zu einem vertrauenswürdigen zentralisierten Dienst hätten, wäre dieses System leicht zu implementieren; es könnte einfach genau wie beschrieben kodiert werden, wobei die Festplatte eines zentralisierten Servers verwendet wird, um den Status zu verfolgen. Da wir jedoch mit Bitcoin versuchen, ein dezentralisiertes Währungssystem aufzubauen, müssen wir das Status-Transaktionssystem mit einem Konsenssystem kombinieren, um sicherzustellen, dass alle über die Reihenfolge der Transaktionen übereinstimmen. Der dezentralisierte Konsensprozess von Bitcoin erfordert, dass die Knoten im Netzwerk kontinuierlich versuchen, Pakete von Transaktionen, sogenannte „Blöcke“, zu erzeugen. Das Netzwerk soll etwa alle zehn Minuten einen Block produzieren, wobei jeder Block einen Zeitstempel, eine Nonce, einen Verweis auf den vorherigen Block (d. h. den Hash des vorherigen Blocks) und eine Liste aller Transaktionen enthält, die seit dem vorherigen Block stattgefunden haben. Im Laufe der Zeit entsteht so eine persistente, ständig wachsende „Blockchain“, die sich kontinuierlich aktualisiert, um den neuesten Status des Bitcoin-Ledgers darzustellen.
Der Algorithmus zur Überprüfung der Gültigkeit eines Blocks, ausgedrückt in diesem Paradigma, lautet wie folgt:
1. Prüfen, ob der vorherige Block, auf den der Block verweist, existiert und gültig ist.
2. Prüfen, ob der Zeitstempel des Blocks größer ist als der des vorherigen Blocks[fn2](#notes) und weniger als 2 Stunden in der Zukunft liegt.
3. Prüfen, ob der Proof-of-Work des Blocks gültig ist.
-4. Der Status am Ende des vorherigen Blocks soll `S[0]` lauten.
-5. Annehmen, dass `TX` die Transaktionsliste des Blocks mit `n` Transaktionen ist. Für alle `i` in `0...n-1` `S[i+1] = APPLY(S[i],TX[i])` festlegen. Falls eine Anwendung einen Fehler zurückgibt, abbrechen und „false“ zurückgeben.
-6. „true“ zurückgeben und `S[n]` als den Status am Ende dieses Blocks registrieren.
+4. Sei `S[0]` der Zustand am Ende des vorherigen Blocks.
+5. Angenommen, `TX` ist die Transaktionsliste des Blocks mit `n` Transaktionen. Für alle `i` in `0...n-1`, setze `S[i+1] = APPLY(S[i],TX[i])`. Wenn eine Anwendung einen Fehler zurückgibt, beende und gib false zurück.
+6. Gib true zurück und registriere `S[n]` als Zustand am Ende dieses Blocks.
Im Wesentlichen muss jede Transaktion im Block einen gültigen Statusübergang von dem ursprünglich kanonischen Status vor der Ausführung der Transaktion zu einem neuen Status bereitstellen. Beachten Sie, dass der Status auf keine Weise im Block kodiert ist; er ist eine reine Abstraktion, die sich der validierende Knoten merken muss und die nur (sicher) für einen Block berechnet werden kann, indem man vom Genesis-Status ausgeht und jede Transaktion in jedem Block nacheinander anwendet. Zusätzlich sei darauf hingewiesen, dass die Reihenfolge, in der der Miner Transaktionen in den Block einfügt, wichtig ist; wenn es zwei Transaktionen A und B in einem Block gibt, wobei B einen von A geschaffenen UTXO ausgibt, ist der Block gültig, wenn A vor B kommt, aber nicht umgekehrt.
@@ -102,9 +102,9 @@ Um den Zweck des Minings besser zu verstehen, wollen wir untersuchen, was im Fal
3. Eine weitere Transaktion durchführen, die dieselben 100 BTC an ihn selbst sendet
4. Versuchen, das Netzwerk davon zu überzeugen, dass seine Transaktion an sich selbst zuerst kam.
-Sobald Schritt (1) erfolgt ist, nimmt nach ein paar Minuten ein Miner die Transaktion in einen Block auf, beispielsweise in Block Nummer 270000. Nach etwa einer Stunde werden der Kette nach diesem Block fünf weitere Blöcke hinzugefügt worden sein, wobei jeder dieser Blöcke indirekt auf die Transaktion verweist und sie somit „bestätigt“. An diesem Punkt akzeptiert der Händler die Zahlung als abgeschlossen und liefert das Produkt; da wir davon ausgehen, dass es sich um eine digitale Ware handelt, erfolgt die Lieferung sofort. Nun erstellt der Angreifer eine weitere Transaktion, die die 100 BTC an ihn selbst sendet. Wenn der Angreifer sie einfach in die freie Wildbahn entlässt, wird die Transaktion nicht verarbeitet; Miner werden versuchen, `APPLY(S,TX)` auszuführen, und feststellen, dass `TX` ein UTXO verbraucht, das sich nicht mehr im Status befindet. Stattdessen erstellt der Angreifer eine „Abspaltung“ der Blockchain, indem er zu Beginn eine andere Version von Block 270000 mint, die auf denselben Block 269999 als übergeordneten Block verweist, aber mit der neuen Transaktion anstelle der alten. Da die Blockdaten unterschiedlich sind, muss der Proof-of-Work neu erstellt werden. Außerdem hat die neue Version des Blocks 270000 des Angreifers einen anderen Hash, sodass die ursprünglichen Blöcke 270001 bis 270005 nicht auf ihn „verweisen“; somit sind die ursprüngliche Kette und die neue Kette des Angreifers völlig getrennt. Die Regel besagt, dass bei einer Abspaltung die längste Blockchain als Wahrheit angesehen wird, sodass legitime Minder an der Kette 270005 arbeiten, während der Angreifer allein an der Kette 270000 arbeitet. Damit der Angreifer seine Blockchain zur längsten machen kann, müsste er über mehr Rechenleistung verfügen als der Rest des Netzwerks zusammen, um aufholen zu können (daher „51-%-Attacke“).
+Sobald Schritt (1) erfolgt ist, nimmt nach ein paar Minuten ein Miner die Transaktion in einen Block auf, beispielsweise in Block Nummer 270000. Nach etwa einer Stunde werden der Kette nach diesem Block fünf weitere Blöcke hinzugefügt worden sein, wobei jeder dieser Blöcke indirekt auf die Transaktion verweist und sie somit „bestätigt“. An diesem Punkt akzeptiert der Händler die Zahlung als abgeschlossen und liefert das Produkt; da wir davon ausgehen, dass es sich um eine digitale Ware handelt, erfolgt die Lieferung sofort. Nun erstellt der Angreifer eine weitere Transaktion, die die 100 BTC an ihn selbst sendet. Wenn der Angreifer sie einfach veröffentlicht, wird die Transaktion nicht verarbeitet; Miner werden versuchen, `APPLY(S,TX)` auszuführen und feststellen, dass `TX` einen UTXO verbraucht, der sich nicht mehr im Zustand befindet. Stattdessen erstellt der Angreifer eine „Abspaltung“ der Blockchain, indem er zu Beginn eine andere Version von Block 270000 mint, die auf denselben Block 269999 als übergeordneten Block verweist, aber mit der neuen Transaktion anstelle der alten. Da die Blockdaten unterschiedlich sind, muss der Proof-of-Work neu erstellt werden. Außerdem hat die neue Version des Blocks 270000 des Angreifers einen anderen Hash, sodass die ursprünglichen Blöcke 270001 bis 270005 nicht auf ihn „verweisen“; somit sind die ursprüngliche Kette und die neue Kette des Angreifers völlig getrennt. Die Regel besagt, dass bei einer Abspaltung die längste Blockchain als Wahrheit angesehen wird, sodass legitime Minder an der Kette 270005 arbeiten, während der Angreifer allein an der Kette 270000 arbeitet. Damit der Angreifer seine Blockchain zur längsten machen kann, müsste er über mehr Rechenleistung verfügen als der Rest des Netzwerks zusammen, um aufholen zu können (daher „51-%-Attacke“).
-### Merkle Trees {#merkle-trees}
+### Merkle-Bäume {#merkle-trees}
@@ -118,11 +118,11 @@ Das Merkle Tree-Protokoll ist für die langfristige Nachhaltigkeit wohl unerläs
### Alternative Blockchain-Anwendungen {#alternative-blockchain-applications}
-Die Idee, den Grundgedanken der Blockchain auf andere Konzepte zu übertragen, hat ebenfalls eine lange Geschichte. 2005 veröffentlichte Nick Szabo das Konzept von „[sicheren Eigentumstiteln mit Eigentümerauthorität](https://nakamotoinstitute.org/secure-property-titles/)“ – ein Dokument, welches beschreibt, wie „neue Fortschritte in der replizierten Datenbanktechnologie“ ein Blockchain-basiertes Sytem für die Speicherung eines Registers darüber, wer der Eigentümer wovon ist, ermöglichen, wobei ein ausgeklügeltes Framework mit Konzepten wie Homesteading, Adverse Possession und georgischer Grundsteuer geschaffen wird. Leider gab es zu dieser Zeit kein effektives repliziertes Datenbanksystem, sodass das Protokoll nie in die Praxis umgesetzt wurde. Nach 2009, nachdem der dezentralisierte Konsens von Bitcoin entwickelt wurde, entstand jedoch schnell eine Reihe von alternativen Anwendungen.
+Die Idee, den Grundgedanken der Blockchain auf andere Konzepte zu übertragen, hat ebenfalls eine lange Geschichte. Im Jahr 2005 veröffentlichte Nick Szabo das Konzept der „[sicheren Eigentumstitel mit Eigentümerautorität](https://nakamotoinstitute.org/library/secure-property-titles/)“, ein Dokument, das beschreibt, wie „neue Fortschritte in der replizierten Datenbanktechnologie“ ein blockchainbasiertes System zur Speicherung eines Registers darüber ermöglichen, wer welches Land besitzt, und dabei ein ausgeklügeltes Rahmenwerk mit Konzepten wie Homesteading, Ersitzung (Adverse Possession) und der georgianischen Grundsteuer schaffen. Leider gab es zu dieser Zeit kein effektives repliziertes Datenbanksystem, sodass das Protokoll nie in die Praxis umgesetzt wurde. Nach 2009, nachdem der dezentralisierte Konsens von Bitcoin entwickelt wurde, entstand jedoch schnell eine Reihe von alternativen Anwendungen.
-- **Namecoin** – [Namecoin](https://namecoin.org/) wurde 2010 erschaffen und lässt sich am besten als eine dezentralisierte Datenbank zur Namensregistrierung beschrieben. In dezentralen Protokollen wie Tor, Bitcoin und BitMessage muss es eine Möglichkeit geben, Konten zu identifizieren, damit andere Leute mit ihnen interagieren können. Aber in allen bisherigen Lösungen ist der einzige verfügbare Identifikator ein pseudo-zufälliger Hash wie `1LW79wp5ZBqaHW1jL5TCiBCrhQYtHagUWy`. Im Idealfall möchte man ein Konto mit einem Namen wie „george“ haben können. Das Problem ist jedoch, dass, wenn eine Person ein Konto mit dem Namen „george“ einrichten kann, eine andere Person das gleiche Verfahren nutzen kann, um sich ebenfalls als „george“ zu registrieren und sich als diese Person auszugeben. Die einzige Lösung ist ein First-to-File-Paradigma, bei dem der erste Registrant erfolgreich ist und der zweite scheitert – ein Problem, das sich perfekt für das Bitcoin-Konsensprotokoll eignet. Namecoin ist die älteste und erfolgreichste Implementierung eines Namensregistrierungssystems, das auf einer solchen Idee beruht.
-- **Colored Coins** – [Colored Coins](https://docs.google.com/a/buterin.com/document/d/1AnkP_cVZTCMLIzw4DvsW6M8Q2JC0lIzrTLuoWu2z1BE/edit) dienen als Protokoll, das die Möglichkeit bietet, eine eigene digitale Währung zu erschaffen oder – in dem wichtigen trivialen Fall einer Währung mit einer Einheit – digitale Token, auf der Bitcoin-Blockchain. Im Colored-Coins-Protokoll wird eine neue Währung „veröffentlicht“, indem man einem bestimmten Bitcoin-UTXO öffentlich eine Farbe zuweist. Das Protokoll definiert rekursiv die Farbe anderer UTXO als die gleiche wie die der Eingaben, die die Transaktion ausgegeben hat, welche diese erzeugte (bei Eingaben mit gemischten Farben gelten einige spezielle Regeln). Dies ermöglicht es den Benutzern, Wallets zu verwalten, die nur UTXO einer bestimmten Farbe enthalten, und sie wie ähnlich wie reguläre Bitcoins zu versenden und über die Blockchain zurückzuverfolgen, um die Farbe eines UTXO zu ermitteln, den sie erhalten haben.
-- **Metacoins** – die Idee hinter Metacoin ist ein Protokoll, das auf Bitcoin aufbaut und Bitcoin-Transaktionen nutzt, um Metacoin-Transaktionen mit einer anderen Statusübergangsfunktion zu speichern: `APPLY'`. Da das Metacoin-Protokoll nicht verhindern kann, dass ungültige Metacoin-Transaktionen in der Bitcoin-Blockchain auftreten, wird eine Regel hinzugefügt, die besagt, dass, wenn `APPLY'(S,TX)` einen Fehler zurückgibt, das Protokoll standardmäßig auf `APPLY'(S,TX) = S` festgelegt wird. Dies bietet einen einfachen Mechanismus zur Erstellung eines willkürlichen Kryptowährungsprotokolls, möglicherweise mit fortgeschrittenen Funktionen, die nicht in Bitcoin selbst implementiert werden können, jedoch mit sehr geringen Entwicklungskosten, da die Komplexität des Minings und der Vernetzung bereits durch das Bitcoin-Protokoll verarbeitet wird. Metacoins wurden verwendet, um einige Klassen von Finanzverträgen, Namensregistrierung und dezentralisierten Austausch zu implementieren.
+- **Namecoin** – 2010 erstellt, wird [Namecoin](https://namecoin.org/) am besten als eine dezentrale Namensregistrierungsdatenbank beschrieben. In dezentralen Protokollen wie Tor, Bitcoin und BitMessage muss es eine Möglichkeit geben, Konten zu identifizieren, damit andere Personen mit ihnen interagieren können, aber in allen bestehenden Lösungen ist die einzige Art von verfügbarem Identifikator ein pseudozufälliger Hash wie `1LW79wp5ZBqaHW1jL5TCiBCrhQYtHagUWy`. Im Idealfall möchte man ein Konto mit einem Namen wie „george“ haben können. Das Problem ist jedoch, dass, wenn eine Person ein Konto mit dem Namen „george“ einrichten kann, eine andere Person das gleiche Verfahren nutzen kann, um sich ebenfalls als „george“ zu registrieren und sich als diese Person auszugeben. Die einzige Lösung ist ein First-to-File-Paradigma, bei dem der erste Registrant erfolgreich ist und der zweite scheitert – ein Problem, das sich perfekt für das Bitcoin-Konsensprotokoll eignet. Namecoin ist die älteste und erfolgreichste Implementierung eines Namensregistrierungssystems, das auf einer solchen Idee beruht.
+- **Colored Coins** – Der Zweck von [Colored Coins](https://docs.google.com/a/buterin.com/document/d/1AnkP_cVZTCMLIzw4DvsW6M8Q2JC0lIzrTLuoWu2z1BE/edit) ist es, als Protokoll zu dienen, das es Menschen ermöglicht, ihre eigenen digitalen Währungen zu erstellen – oder, im wichtigen trivialen Fall einer Währung mit einer Einheit, digitale Token auf der Bitcoin-Blockchain. Im Colored-Coins-Protokoll wird eine neue Währung „veröffentlicht“, indem man einem bestimmten Bitcoin-UTXO öffentlich eine Farbe zuweist. Das Protokoll definiert rekursiv die Farbe anderer UTXO als die gleiche wie die der Eingaben, die die Transaktion ausgegeben hat, welche diese erzeugte (bei Eingaben mit gemischten Farben gelten einige spezielle Regeln). Dies ermöglicht es den Benutzern, Wallets zu verwalten, die nur UTXO einer bestimmten Farbe enthalten, und sie wie ähnlich wie reguläre Bitcoins zu versenden und über die Blockchain zurückzuverfolgen, um die Farbe eines UTXO zu ermitteln, den sie erhalten haben.
+- **Metacoins** – die Idee hinter einem Metacoin ist, ein Protokoll zu haben, das auf Bitcoin aufbaut, Bitcoin-Transaktionen verwendet, um Metacoin-Transaktionen zu speichern, aber eine andere Zustandsübergangsfunktion, `APPLY'`, hat. Da das Metacoin-Protokoll ungültige Metacoin-Transaktionen nicht daran hindern kann, in der Bitcoin-Blockchain zu erscheinen, wird eine Regel hinzugefügt, dass, wenn `APPLY'(S,TX)` einen Fehler zurückgibt, das Protokoll standardmäßig `APPLY'(S,TX) = S` annimmt. Dies bietet einen einfachen Mechanismus zur Erstellung eines willkürlichen Kryptowährungsprotokolls, möglicherweise mit fortgeschrittenen Funktionen, die nicht in Bitcoin selbst implementiert werden können, jedoch mit sehr geringen Entwicklungskosten, da die Komplexität des Minings und der Vernetzung bereits durch das Bitcoin-Protokoll verarbeitet wird. Metacoins wurden verwendet, um einige Klassen von Finanzverträgen, Namensregistrierung und dezentralisierten Austausch zu implementieren.
Im Allgemeinen gibt es also zwei Ansätze für den Aufbau eines Konsensprotokolls: Aufbau eines unabhängigen Netzwerks und Aufbau eines Protokolls auf Bitcoin. Der erste Ansatz, der bei Anwendungen wie Namecoin zwar einigermaßen erfolgreich war, ist schwer umzusetzen; jede einzelne Implementierung muss eine unabhängige Blockchain starten sowie den gesamten notwendigen Code für Statusübergänge und Netzwerkverbindungen entwickeln und testen. Außerdem prognostizieren wir, dass die Menge an Anwendungen für die Technologie des dezentralisierten Konsenses einer Potenzgesetzverteilung folgen wird, bei der die überwiegende Mehrheit der Anwendungen für eine eigene Blockchain zu klein sein wird, und stellen fest, dass es große Klassen von dezentralisierten Anwendungen gibt, insbesondere autonome dezentralisierte Organisationen, die miteinander interagieren müssen.
@@ -134,10 +134,10 @@ Auch ohne jegliche Erweiterungen ermöglicht das Bitcoin-Protokoll tatsächlich
Die Skriptsprache, wie sie in Bitcoin implementiert ist, hat jedoch mehrere wichtige Einschränkungen:
-- **Mangel an Turing-Completeness** – das heißt, dass die Bitcoin-Skriptsprache zwar eine große Teilmenge von Berechnungen unterstützt, aber nicht annähernd alle. Die Hauptkategorie, die fehlt, sind Schleifen. Dies geschieht zur Vermeidung von Endlosschleifen während der Transaktionsverifizierung; theoretisch ist dies ein überwindbares Hindernis für Skriptprogrammierer, da jede Schleife simuliert werden kann, indem man den zugrunde liegenden Code einfach mehrmals mit einer if-Aussage wiederholt, aber dies führt zu Skripten, die sehr ineffizient im Platzverbrauch sind. Zum Beispiel würde die Implementierung eines alternativen Signaturalgorithmus für elliptische Kurven wahrscheinlich 256 wiederholte Multiplikationsrunden erfordern, die alle einzeln im Code enthalten sind.
-- **Werteblindheit** – es gibt keine Möglichkeit für ein UTXO-Skript, eine feingranulare Kontrolle über den Betrag zu ermöglichen, der abgehoben werden kann. Zum Beispiel wäre ein leistungsfähiges Anwendungsbeispiel für einen Oracle-Vertrag ein Hedging-Vertrag, bei dem A und B BTC im Wert von 1000 $ einbringen und nach 30 Tagen das Skript 1000 $ in BTC an A und den Rest an B sendet. Dafür wäre ein Oracle erforderlich, um den Wert von 1 BTC in USD zu bestimmen, aber selbst dann stellt es eine massive Verbesserung in Bezug auf Vertrauen und Infrastrukturanforderungen gegenüber den vollständig zentralisierten Lösungen dar, die jetzt verfügbar sind. Allerdings ist dies aufgrund der Tatsache, dass UTXO nicht teilbar sind, nur durch einen sehr ineffizienten Kniff möglich. Dabei werden viele UTXO mit unterschiedlichen Nennwerten erstellt (z. B. ein UTXO mit dem Wert 2k für jedes k bis 30). Der Oracle entscheidet dann, welcher UTXO an A und welcher an B geschickt wird.
-- **Nicht vorhandener Status** – UTXO können entweder ausgegeben oder nicht ausgegeben sein; es gibt keine Möglichkeit für mehrstufige Verträge oder Skripte, die einen anderen internen Status als diesen speichern. Dies erschwert die Erstellung von mehrstufigen Optionskontrakten, dezentralisierten Austauschangeboten oder zweistufigen kryptografischen Commitment-Protokollen (notwendig für sichere Berechnungskopfgelder). Es bedeutet auch, dass UTXO nur verwendet werden können, um einfache, einmalige Verträge zu erstellen und keine komplexeren „statusbehafteten“ Verträge wie dezentralisierte Organisationen, und die Implementierung von Meta-Protokollen wird erschwert. Ein binärer Status in Verbindung mit Werteblindheit bedeutet auch, dass eine weitere wichtige Anwendung, nämlich Abhebungslimits, unmöglich ist.
-- **Blockchain-Blindheit** – UTXO sind blind für Blockchain-Daten wie die Nonce, den Zeitstempel und den vorherigen Block-Hash. Dies schränkt Anwendungen im Glücksspiel und in mehreren anderen Kategorien erheblich ein, da der Skriptsprache eine potenziell wertvolle Quelle der Zufälligkeit entzogen wird.
+- **Mangel an Turing-Vollständigkeit** – das heißt, obwohl es eine große Teilmenge von Berechnungen gibt, die die Bitcoin-Skriptsprache unterstützt, unterstützt sie bei weitem nicht alles. Die Hauptkategorie, die fehlt, sind Schleifen. Dies geschieht zur Vermeidung von Endlosschleifen während der Transaktionsverifizierung; theoretisch ist dies ein überwindbares Hindernis für Skriptprogrammierer, da jede Schleife simuliert werden kann, indem man den zugrunde liegenden Code einfach mehrmals mit einer if-Aussage wiederholt, aber dies führt zu Skripten, die sehr ineffizient im Platzverbrauch sind. Zum Beispiel würde die Implementierung eines alternativen Signaturalgorithmus für elliptische Kurven wahrscheinlich 256 wiederholte Multiplikationsrunden erfordern, die alle einzeln im Code enthalten sind.
+- **Werteblindheit** – es gibt für ein UTXO-Skript keine Möglichkeit, eine feingranulare Kontrolle über den Betrag zu ermöglichen, der abgehoben werden kann. Zum Beispiel wäre ein leistungsfähiges Anwendungsbeispiel für einen Oracle-Vertrag ein Hedging-Vertrag, bei dem A und B BTC im Wert von 1000 $ einbringen und nach 30 Tagen das Skript 1000 $ in BTC an A und den Rest an B sendet. Dafür wäre ein Oracle erforderlich, um den Wert von 1 BTC in USD zu bestimmen, aber selbst dann stellt es eine massive Verbesserung in Bezug auf Vertrauen und Infrastrukturanforderungen gegenüber den vollständig zentralisierten Lösungen dar, die jetzt verfügbar sind. Da UTXOs jedoch alles oder nichts sind, besteht die einzige Möglichkeit, dies zu erreichen, in dem sehr ineffizienten Hack, viele UTXOs mit unterschiedlichen Nennwerten zu haben (z. B. ein UTXO von 2k für jedes k bis 30) und das Orakel auswählen zu lassen, welche UTXOs an A und welche an B gesendet werden.
+- **Fehlender Zustand** – UTXO können entweder ausgegeben oder nicht ausgegeben sein; es gibt keine Möglichkeit für mehrstufige Verträge oder Skripte, die einen anderen internen Zustand als diesen beibehalten. Dies erschwert die Erstellung von mehrstufigen Optionskontrakten, dezentralisierten Austauschangeboten oder zweistufigen kryptografischen Commitment-Protokollen (notwendig für sichere Berechnungskopfgelder). Es bedeutet auch, dass UTXO nur verwendet werden können, um einfache, einmalige Verträge zu erstellen und keine komplexeren „statusbehafteten“ Verträge wie dezentralisierte Organisationen, und die Implementierung von Meta-Protokollen wird erschwert. Ein binärer Status in Verbindung mit Werteblindheit bedeutet auch, dass eine weitere wichtige Anwendung, nämlich Abhebungslimits, unmöglich ist.
+- **Blockchain-Blindheit** – UTXO sind blind für Blockchain-Daten wie die Nonce, den Zeitstempel und den vorherigen Block-Hash. Dies schränkt Anwendungen im Glücksspiel und in mehreren anderen Kategorien erheblich ein, da der Skriptsprache eine potenziell wertvolle Quelle der Zufälligkeit entzogen wird.
Es gibt also drei Ansätze für die Entwicklung fortschrittlicher Anwendungen auf der Grundlage von Kryptowährungen: der Aufbau einer neuen Blockchain, die Verwendung von Skripten auf Bitcoin und der Aufbau eines Meta-Protokolls auf Bitcoin. Der Aufbau einer neuen Blockchain bietet unbegrenzte Freiheit bei der Entwicklung von Funktionssätzen, allerdings auf Kosten von Entwicklungszeit, Bootstrapping-Aufwand und Sicherheit. Scripting ist leicht zu implementieren und zu standardisieren, hat jedoch nur sehr begrenzte Möglichkeiten, und Meta-Protokolle haben trotz ihrer Einfachheit Probleme mit der Skalierbarkeit. Mit Ethereum wollen wir ein alternatives Framework schaffen, das sowohl die Entwicklungsfreundlichkeit erheblich verbessert als auch die Eigenschaften für leichte Clients weiter stärkt, während es Anwendungen gleichzeitig ermöglicht, eine gemeinsame wirtschaftliche Umgebung und die Sicherheit der Blockchain zu nutzen.
@@ -149,12 +149,12 @@ Die Absicht von Ethereum besteht darin, ein alternatives Protokoll zur Erstellun
In Ethereum wird der Status durch Objekte namens „Konten“ gebildet. Jedes Konto hat eine 20-Byte-Adresse, und Statusübergänge erfolgen durch direkte Übertragungen von Wert und Informationen zwischen den Konten. Ein Ethereum-Konto beinhaltet vier Felder:
-- Die **Nonce** – ein Zähler, der sicherstellt, dass jede Transaktion nur einmal verarbeitet werden kann
-- Der aktuelle **Ether-Saldo** des Kontos
+- Die **Nonce**, ein Zähler, der sicherstellt, dass jede Transaktion nur einmal verarbeitet werden kann
+- Das aktuelle **Ether-Guthaben** des Kontos
- Der **Vertragscode** des Kontos, falls vorhanden
-- Der **Speicherplatz** des Kontos (standardmäßig leer)
+- Der **Speicher** des Kontos (standardmäßig leer)
-„Ether“ ist der Krypto-Haupttreibstoff von Ethereum und wird verwendet, um Transaktionsgebühren zu bezahlen. Allgemein gibt es zwei Arten von Konten: **Konten in externem Eigentum**, die durch private Schlüssel kontrolliert werden, und **Vertragskonten**, die durch deren Vertragscode kontrolliert werden. Ein Konto in externem Eigentum besitzt keinen Code, und man kann Nachrichten von einem solchen Konto aus verschicken, indem man eine Transaktion erschafft und signiert. Jedes Mal, wenn ein Vertragskonto eine Nachricht erhält, wird dessen Code aktiviert, was es erlaubt, den internen Speicher zu lesen und zu bearbeiten und andere Nachrichten zu senden oder Vertragskonten im Gegenzug zu erschaffen.
+„Ether“ ist der Krypto-Haupttreibstoff von Ethereum und wird verwendet, um Transaktionsgebühren zu bezahlen. Im Allgemeinen gibt es zwei Arten von Konten: **extern verwaltete Konten**, die durch private Schlüssel gesteuert werden, und **Vertragskonten**, die durch ihren Vertragscode gesteuert werden. Ein Konto in externem Eigentum besitzt keinen Code, und man kann Nachrichten von einem solchen Konto aus verschicken, indem man eine Transaktion erschafft und signiert. Jedes Mal, wenn ein Vertragskonto eine Nachricht erhält, wird dessen Code aktiviert, was es erlaubt, den internen Speicher zu lesen und zu bearbeiten und andere Nachrichten zu senden oder Vertragskonten im Gegenzug zu erschaffen.
Beachten Sie, dass „Verträge“ in Ethereum nicht als etwas betrachtet werden sollten, das „erfüllt“ oder „eingehalten“ werden muss; vielmehr ähneln sie eher „autonomen Agenten“, die innerhalb der Ethereum-Ausführungsumgebung existieren, stets ein bestimmtes Stück Code ausführen, wenn sie durch eine Nachricht oder Transaktion „angesprochen“ werden, und die direkte Kontrolle über ihr eigenes Ether-Saldo sowie ihren eigenen Schlüssel-/Wertespeicher haben, um persistente Variablen zu verfolgen.
@@ -166,8 +166,8 @@ In Ethereum wird der Begriff „Transaktion“ verwendet, um das signierte Daten
- Eine Signatur, die den Absender identifiziert
- Den Ether-Betrag, der vom Absender an den Empfänger übertragen werden soll
- Ein optionales Datenfeld
-- Einen `STARTGAS`-Wert, welcher für die maximale Anzahl an Berechnungsschritten für die Transaktionsausführung steht
-- Einen `GASPRICE`-Wert, welcher für die Gebühr steht, die der Absender pro Berechnungsschritt bezahlt
+- Ein `STARTGAS`-Wert, der die maximale Anzahl von Rechenschritten darstellt, die die Transaktionsausführung durchführen darf
+- Ein `GASPRICE`-Wert, der die Gebühr darstellt, die der Absender pro Rechenschritt bezahlt
Bei den ersten drei handelt es sich um Standardfelder, die bei jeder Kryptowährung erwartet werden. Das Datenfeld hat standardmäßig keine Funktion, aber die virtuelle Maschine hat einen Opcode, mit dem ein Vertrag auf die Daten zugreifen kann; als Beispielanwendung: Wenn ein Vertrag als On-Blockchain-Domain-Registrierungsdienst fungiert, könnte er die an ihn übermittelten Daten so interpretieren, dass sie zwei „Felder“ enthalten – das erste Feld eine zu registrierende Domain und das zweite Feld die IP-Adresse, auf die sie registriert werden soll. Der Vertrag liest diese Werte aus den Nachrichtendaten und speichert sie in geeigneter Weise ab.
@@ -178,24 +178,24 @@ Die Felder `STARTGAS` und `GASPRICE` sind entscheidend für das Anti-Denial-of-S
Verträge haben die Möglichkeit, „Nachrichten“ an andere Verträge zu senden. Nachrichten sind virtuelle Objekte, die niemals serialisiert werden und nur in der Ethereum-Ausführungsumgebung existieren. Eine Nachricht enthält:
- Den Absender der Nachricht (implizit)
-- Der Empfänger der Nachricht
+- Den Empfänger der Nachricht
- Die Menge an Ether, die mit der Nachricht übertragen werden soll
- Ein optionales Datenfeld
-- Einen `STARTGAS`-Wert
+- Ein `STARTGAS`-Wert
Eine Nachricht ist im Grunde genommen wie eine Transaktion, nur dass sie von einem Vertrag und nicht von einem externen Akteur erzeugt wird. Eine Nachricht wird erzeugt, wenn ein Vertrag, der gerade Code ausführt, den Opcode `CALL` ausführt, der eine Nachricht erzeugt und ausführt. Eine Nachricht führt wie eine Transaktion dazu, dass das Empfängerkonto den Code ausführt. Somit können Verträge auf genau die gleiche Weise wie externe Akteure Beziehungen zu anderen Verträgen haben.
Beachten Sie, dass das Gas-Limit, das einer Transaktion oder einem Vertrag zugewiesen wird, für das gesamte Gas gilt, das von dieser Transaktion und allen Unterausführungen verbraucht wird. Wenn beispielsweise ein externer Akteur A eine Transaktion an B mit 1000 Gas sendet und B 600 Gas verbraucht, bevor er eine Nachricht an C sendet, während die interne Ausführung von C 300 Gas verbraucht, bevor sie zurückkehrt, kann B noch 100 Gas ausgeben, bevor das Gas aufgebraucht ist.
-### Ethereum-Statusübergangfunktion {#ethereum-state-transition-function}
+### Ethereum-Zustandsübergangsfunktion {#ethereum-state-transition-function}
-
+
-Die Ethereum-Statusübergangsfunktion `APPLY(S,TX) -> S'` kann wie folgt definiert werden:
+Die Ethereum-Zustandsübergangsfunktion, `APPLY(S,TX) -> S'` kann wie folgt definiert werden:
-1. Prüfen, ob die Transaktion korrekt aufgebaut ist (sprich, die richtige Anzahl von Werten enthält), ob die Signatur gültig ist und ob die Nonce mit der im Konto des Absenders übereinstimmt. Falls nicht, einen Fehler zurückgeben.
-2. Die Transaktionsgebühr als `STARTGAS * GASPRICE` berechnen und die Absenderadresse aus der Signatur bestimmen. Die Gebühr vom Saldo des Absenders abziehen und die Nonce des Absenders erhöhen. Wenn nicht genügend zu verbrauchender Saldo vorhanden ist, einen Fehler zurückgeben.
-3. `GAS = STARTGAS` initialisieren und eine bestimmte Gas-Menge pro Byte abziehen, um für die Bytes in der Transaktion zu bezahlen.
+1. Überprüfen Sie, ob die Transaktion wohlgeformt ist (d. h. die richtige Anzahl von Werten hat), die Signatur gültig ist und die Nonce mit der Nonce im Konto des Absenders übereinstimmt. Falls nicht, einen Fehler zurückgeben.
+2. Berechne die Transaktionsgebühr als `STARTGAS * GASPRICE`, und bestimme die Absenderadresse aus der Signatur. Die Gebühr vom Saldo des Absenders abziehen und die Nonce des Absenders erhöhen. Wenn nicht genügend zu verbrauchender Saldo vorhanden ist, einen Fehler zurückgeben.
+3. Initialisiere `GAS = STARTGAS`, und ziehe eine bestimmte Menge an Gas pro Byte ab, um für die Bytes in der Transaktion zu bezahlen.
4. Den Transaktionswert vom Konto des Absenders auf das Konto des Empfängers übertragen. Falls das Empfängerkonto noch nicht existiert, dieses erstellen. Wenn das Empfängerkonto ein Vertrag ist, den Code des Vertrags entweder bis zum Abschluss oder bis zur Gas-Erschöpfung ausführen.
5. Wenn die Wertübertragung fehlgeschlagen ist, weil der Absender nicht genügend Geld hatte oder die Codeausführung das Gas aufgebraucht hat, alle Statusänderungen zurücksetzen, mit Ausnahme der Zahlung der Gebühren, und die Gebühren dem Konto des Miners hinzufügen.
6. Andernfalls die Gebühren für das verbleibende Gas an den Absender erstatten und die Gebühren für das verbrauchte Gas an den Miner senden.
@@ -207,49 +207,49 @@ if !self.storage[calldataload(0)]:
self.storage[calldataload(0)] = calldataload(32)
```
-Beachten Sie, dass der tatsächliche Vertragscode als Low-Level-EVM-Code geschrieben ist; dieses Beispiel ist zur Klarheit in Serpent, einer unserer High-Level-Sprachen, verfasst und kann in EVM-Code kompiliert werden. Angenommen, der Speicher des Vertrags beginnt leer und eine Transaktion wird mit einem Wert von 10 Ether, 2000 Gas, einem Gas-Preis von 0,001 Ether und 64 Byte Daten gesendet, wobei die Bytes 0–31 für die Zahl `2` und die Bytes 32–63 für den String `CHARLIE` stehen. In diesem Fall ist der Prozess der Statusübergangsfunktion wie folgt:
+Beachten Sie, dass der tatsächliche Vertragscode als Low-Level-EVM-Code geschrieben ist; dieses Beispiel ist zur Klarheit in Serpent, einer unserer High-Level-Sprachen, verfasst und kann in EVM-Code kompiliert werden. Angenommen, der Speicher des Vertrags ist anfangs leer, und eine Transaktion wird mit einem Wert von 10 Ether, 2000 Gas, einem Gaspreis von 0,001 Ether und 64 Bytes an Daten gesendet, wobei die Bytes 0-31 die Zahl `2` und die Bytes 32-63 die Zeichenkette `CHARLIE` darstellen. In diesem Fall ist der Prozess der Statusübergangsfunktion wie folgt:
1. Sicherstellen, dass die Transaktion gültig und korrekt aufgebaut ist.
2. Überprüfen Sie, ob der Absender der Transaktion mindestens 2000 \* 0,001 = 2 Ether besitzt. Wenn ja, dann 2 Ether vom Konto des Absenders abziehen.
3. Gas = 2000 initialisieren; vorausgesetzt, die Transaktion ist 170 Byte lang und die Gebühren pro Byte betragen 5, 850 abziehen, sodass noch 1150 Gas verbleibt.
4. 10 weitere Ether vom Konto des Absenders abziehen und sie dem Konto des Vertrags hinzufügen.
-5. Den Code ausführen. In diesem Fall ist es einfach: Es wird überprüft, ob der Speicher des Vertrags an Index `2` verwendet wird, und festgestellt, dass dies nicht der Fall ist, und daher wird der Speicher an Index `2` auf den Wert `CHARLIE` gesetzt. Angenommen, dies verbraucht 187 Gas – dann beträgt der verbleibende Gasbetrag 1150 - 187 = 963.
+5. Den Code ausführen. In diesem Fall ist dies einfach: Es wird geprüft, ob der Speicher des Vertrags am Index `2` verwendet wird, festgestellt, dass dies nicht der Fall ist, und so wird der Speicher am Index `2` auf den Wert `CHARLIE` gesetzt. Angenommen, dies verbraucht 187 Gas – dann beträgt der verbleibende Gasbetrag 1150 - 187 = 963.
6. 963 \* 0,001 = 0,963 Ether zurück auf das Konto des Senders hinzufügen und den dadurch entstandenen Status zurückgeben.
-Wenn am empfangenden Ende der Transaktion kein Vertrag vorhanden war, wäre die gesamte Transaktionsgebühr einfach das Produkt aus dem angegebenen `GASPRICE` und der Länge der Transaktion in Bytes, wobei die bei der Transaktion gesendeten Daten irrelevant wären.
+Wenn am empfangenden Ende der Transaktion kein Vertrag vorhanden war, entspräche die gesamte Transaktionsgebühr einfach dem angegebenen `GASPRICE` multipliziert mit der Länge der Transaktion in Bytes, und die mit der Transaktion gesendeten Daten wären irrelevant.
-Beachten Sie, dass Nachrichten in Bezug auf Zurücksetzungen wie Transaktionen funktionieren: Wenn eine Nachrichtenausführung das Gas-Limit erreicht, wird die Ausführung dieser Nachricht sowie aller anderen durch diese Ausführung ausgelösten Ausführungen zurückgesetzt, jedoch müssen übergeordnete Ausführungen nicht zurückgesetzt werden. Das bedeutet, dass es für einen Vertrag „sicher“ ist, einen anderen Vertrag aufzurufen; wenn A B mit G Gas aufruft, ist garantiert, dass As Ausführung höchstens G Gas verliert. Schließlich sei darauf hingewiesen, dass es einen Opcode `CREATE` gibt, der einen Vertrag erstellt; seine Ausführungsmechanik ist grundsätzlich ähnlich wie bei `CALL`, mit dem Unterschied, dass die Ausgabe der Ausführung den Code eines neu erstellten Vertrags bestimmt.
+Beachten Sie, dass Nachrichten in Bezug auf Zurücksetzungen wie Transaktionen funktionieren: Wenn eine Nachrichtenausführung das Gas-Limit erreicht, wird die Ausführung dieser Nachricht sowie aller anderen durch diese Ausführung ausgelösten Ausführungen zurückgesetzt, jedoch müssen übergeordnete Ausführungen nicht zurückgesetzt werden. Das bedeutet, dass es für einen Vertrag „sicher“ ist, einen anderen Vertrag aufzurufen; wenn A B mit G Gas aufruft, ist garantiert, dass As Ausführung höchstens G Gas verliert. Beachten Sie schließlich, dass es einen Opcode, `CREATE`, gibt, der einen Vertrag erstellt; seine Ausführungsmechanik ist im Allgemeinen ähnlich wie `CALL`, mit der Ausnahme, dass die Ausgabe der Ausführung den Code eines neu erstellten Vertrags bestimmt.
### Codeausführung {#code-execution}
-Der Code in Ethereum-Verträgen ist in einer Low-Level-, Stack-basierten Bytecode-Sprache geschrieben, die als „Code der virtuellen Maschine von Ethereum“ oder „EVM-Code“ bezeichnet wird. Der Code besteht aus einer Reihe von Bytes, wobei jedes Byte für eine Operation steht. Im Allgemeinen ist die Codeausführung eine Endlosschleife, die darin besteht, wiederholt die Operation am aktuellen Programmzähler (der bei null beginnt) auszuführen und anschließend den Programmzähler um eins zu erhöhen, bis das Ende des Codes erreicht ist oder ein Fehler bzw. ein `STOP`- oder `RETURN`-Befehl erkannt wird. Die Operationen haben Zugang zu drei Arten von Speicher, in denen Daten gespeichert werden können:
+Der Code in Ethereum-Verträgen ist in einer Low-Level-, Stack-basierten Bytecode-Sprache geschrieben, die als „Code der virtuellen Maschine von Ethereum“ oder „EVM-Code“ bezeichnet wird. Der Code besteht aus einer Reihe von Bytes, wobei jedes Byte für eine Operation steht. Im Allgemeinen ist die Codeausführung eine Endlosschleife, die darin besteht, die Operation am aktuellen Programmzähler (der bei Null beginnt) wiederholt auszuführen und dann den Programmzähler um eins zu erhöhen, bis das Ende des Codes erreicht ist oder ein Fehler oder eine `STOP`- oder `RETURN`-Anweisung erkannt wird. Die Operationen haben Zugang zu drei Arten von Speicher, in denen Daten gespeichert werden können:
-- Der **Stack**, ein Last-in-First-out-Container, in den Werte gepusht und aus dem Werte gepoppt werden können
-- **Gedächtnis**, ein unendlich erweiterbares Byte-Array
-- Der langfristige **Speicher** des Vertrags, ein Schlüssel-/Wertespeicher. Anders als bei Stack und Gedächtnis, die nach Beendigung der Berechnung zurückgesetzt werden, bleibt der Speicher auf lange Sicht bestehen.
+- Der **Stack**, ein Last-In-First-Out-Container, in den Werte gepusht und aus dem sie gepoppt werden können
+- **Speicher**, ein unendlich erweiterbares Byte-Array
+- Der langfristige **Speicher** des Vertrags, ein Schlüssel/Wert-Speicher. Anders als bei Stack und Gedächtnis, die nach Beendigung der Berechnung zurückgesetzt werden, bleibt der Speicher auf lange Sicht bestehen.
Der Code kann auch auf den Wert, Absender und die Daten der eingehenden Nachricht sowie auf Block-Header-Daten zugreifen, und der Code kann auch ein Byte-Array von Daten als Ausgabe zurückgeben.
-Das formale Ausführungsmodell von EVM-Codes ist erstaunlich einfach. Während die virtuelle Maschine von Ethereum läuft, kann ihr vollständiger Berechnungsstatus durch das Tupel `(block_state, transaction, message, code, memory, stack, pc, gas)` definiert werden, wobei `block_state` den globalen Status darstellt, der alle Konten mit Salden und Speicher enthält. Zu Beginn jeder Ausführungsrunde wird die aktuelle Anweisung bestimmt, indem man das `pc`-te Byte des `code` nimmt (oder 0, wenn `pc >= len(code)`), und jede Anweisung hat ihre eigene Definition, wie sie das Tupel beeinflusst. Zum Beispiel entfernt `ADD` zwei Elemente vom Stack und pusht ihre Summe, reduziert `gas` um 1 und erhöht `pc` um 1, während `SSTORE` die obersten zwei Elemente vom Stack entfernt und das zweite Element im Speicher des Vertrags am durch das erste Element angegebenen Index einfügt. Obwohl es viele Möglichkeiten gibt, die Ausführung der virtuellen Maschine von Ethereum durch Just-in-Time-Kompilierung zu optimieren, kann eine grundlegende Implementierung von Ethereum in einigen Hundert Zeilen Code umgesetzt werden.
+Das formale Ausführungsmodell von EVM-Codes ist erstaunlich einfach. Während die Ethereum Virtual Machine läuft, kann ihr vollständiger Berechnungszustand durch das Tupel `(block_state, transaction, message, code, memory, stack, pc, gas)` definiert werden, wobei `block_state` der globale Zustand ist, der alle Konten enthält und Salden und Speicher umfasst. Zu Beginn jeder Ausführungsrunde wird die aktuelle Anweisung gefunden, indem das `pc`-te Byte von `code` genommen wird (oder 0, wenn `pc >= len(code)`), und jede Anweisung hat ihre eigene Definition in Bezug darauf, wie sie das Tupel beeinflusst. `ADD` zum Beispiel poppt zwei Elemente vom Stack und pusht ihre Summe, reduziert `gas` um 1 und inkrementiert `pc` um 1, und `SSTORE` poppt die obersten beiden Elemente vom Stack und fügt das zweite Element in den Speicher des Vertrags an dem vom ersten Element angegebenen Index ein. Obwohl es viele Möglichkeiten gibt, die Ausführung der virtuellen Maschine von Ethereum durch Just-in-Time-Kompilierung zu optimieren, kann eine grundlegende Implementierung von Ethereum in einigen Hundert Zeilen Code umgesetzt werden.
### Blockchain und Mining {#blockchain-and-mining}
-
+
Die Ethereum-Blockchain ähnelt in vielerlei Hinsicht der Bitcoin-Blockchain, obwohl sie auch einige Unterschiede aufweist. Der Hauptunterschied zwischen Ethereum und Bitcoin in Bezug auf die Blockchain-Architektur besteht darin, dass Ethereum-Blöcke im Gegensatz zu Bitcoin eine Kopie der Transaktionsliste und des aktuellen Status enthalten. Darüber hinaus werden zwei weitere Werte, Blocknummer und Schwierigkeit, ebenfalls im Block gespeichert. Der grundlegende Blockvalidierungsalgorithmus in Ethereum gestaltet sich wie folgt:
1. Prüfen, ob der vorherige Block, auf den verwiesen wird, existiert und gültig ist.
2. Sicherstellen, dass der Zeitstempel des Blocks größer ist als der des referenzierten vorherigen Blocks und weniger als 15 Minuten in der Zukunft liegt.
3. Sicherstellen, dass Blocknummer, Schwierigkeit, Transaktionswurzel, Onkelwurzel und Gas-Limit (verschiedene Ethereum-spezifische Low-Level-Konzepte) gültig sind.
-4. Prüfe, ob der Proof-of-Work des Blocks gültig ist.
+4. Prüfen, ob der Proof-of-Work des Blocks gültig ist.
5. Sei `S[0]` der Zustand am Ende des vorherigen Blocks.
-6. `TX` die Transaktionsliste des Blocks, die `n` Transaktionen umfasst, sein lassen. Für alle `i` in `0...n-1` `S[i+1] = APPLY(S[i],TX[i])` festlegen. Wenn irgendeine Anwendung einen Fehler zurückgibt oder wenn das insgesamt im Block verbrauchte Gas bis zu diesem Zeitpunkt das `GASLIMIT` überschreitet, einen Fehler zurückgeben.
-7. `S_FINAL` gleich `S[n]` sein lassen, jedoch unter Hinzufügung der Blockbelohnung, die an den Miner gezahlt wird.
-8. Prüfen, ob die Merkle-Tree-Wurzel des Status `S_FINAL` der im Block-Header angegebenen endgültigen Statuswurzel gleicht. Wenn dies der Fall ist, ist der Block gültig; andernfalls ist er nicht gültig.
+6. Sei `TX` die Transaktionsliste des Blocks mit `n` Transaktionen. Für alle `i` in `0...n-1`, setze `S[i+1] = APPLY(S[i],TX[i])`. Wenn eine Anwendung einen Fehler zurückgibt, oder wenn das bis zu diesem Zeitpunkt im Block verbrauchte Gesamt-Gas das `GASLIMIT` überschreitet, wird ein Fehler zurückgegeben.
+7. Sei `S_FINAL` gleich `S[n]`, aber mit Hinzufügung der an den Miner gezahlten Block-Belohnung.
+8. Prüfen Sie, ob die Merkle-Baumwurzel des Zustands `S_FINAL` mit der im Block-Header angegebenen finalen Zustands-Wurzel übereinstimmt. Wenn dies der Fall ist, ist der Block gültig; andernfalls ist er nicht gültig.
-Auf den ersten Blick könnte der Ansatz äußerst ineffizient erscheinen, weil er den gesamten Status mit jedem Block speichern muss – tatsächlich sollte die Effizienz jedoch mit der von Bitcoin vergleichbar sein. Der Grund dafür ist, dass der Status in der Baumstruktur gespeichert wird und nach jedem Block nur ein kleiner Teil des Baums geändert werden muss. Daher sollte im Allgemeinen zwischen zwei benachbarten Blöcken der Großteil des Baums identisch sein, und die Daten können somit einmal gespeichert und zweimal über Verweiser (also Hashes von Teilbäumen) referenziert werden. Um dies zu erreichen, wird eine spezielle Art von Baum, bekannt als „Patricia-Baum“, verwendet. Er beinhaltet eine Modifikation des Merkle-Tree-Konzepts, die es ermöglicht, Knoten effizient einzufügen und zu löschen, und nicht nur zu ändern. Darüber hinaus ist es, weil alle Statusinformationen Teil des letzten Blocks sind, nicht notwendig, die gesamte Blockchain-Historie zu speichern – eine Strategie, die, sofern sie auf Bitcoin angewendet werden kann, kalkulierte 5- bis 20-fache Einsparungen im Speicher bieten könnte.
+Auf den ersten Blick könnte der Ansatz äußerst ineffizient erscheinen, weil er den gesamten Status mit jedem Block speichern muss – tatsächlich sollte die Effizienz jedoch mit der von Bitcoin vergleichbar sein. Der Grund dafür ist, dass der Status in der Baumstruktur gespeichert wird und nach jedem Block nur ein kleiner Teil des Baums geändert werden muss. Im Allgemeinen sollte also zwischen zwei benachbarten Blöcken die große Mehrheit des Baumes gleich sein, und daher können die Daten einmal gespeichert und zweimal über Zeiger (d. h. Hashes von Teilbäumen) referenziert werden. Um dies zu erreichen, wird eine spezielle Art von Baum, bekannt als „Patricia-Baum“, verwendet. Er beinhaltet eine Modifikation des Merkle-Tree-Konzepts, die es ermöglicht, Knoten effizient einzufügen und zu löschen, und nicht nur zu ändern. Darüber hinaus ist es, weil alle Statusinformationen Teil des letzten Blocks sind, nicht notwendig, die gesamte Blockchain-Historie zu speichern – eine Strategie, die, sofern sie auf Bitcoin angewendet werden kann, kalkulierte 5- bis 20-fache Einsparungen im Speicher bieten könnte.
-Es wird häufig danach gefragt, „wo“ der Vertragscode in Bezug auf physische Hardware ausgeführt wird. Die Antwort darauf ist einfach: Der Vorgang der Ausführung des Vertragcodes ist Teil der Definition der Statusübergangsfunktion, die Teil des Blockvalidierungsalgorithmus ist. Wenn eine Transaktion also in Block `B` hinzugefügt wird, wird die durch diese Transaktion ausgelöste Codeausführung von allen Knoten, die Block `B` herunterladen und validieren, jetzt und in Zukunft ausgeführt.
+Es wird häufig danach gefragt, „wo“ der Vertragscode in Bezug auf physische Hardware ausgeführt wird. Die Antwort ist einfach: Der Prozess der Ausführung von Vertragscode ist Teil der Definition der Zustandsübergangsfunktion, die wiederum Teil des Blockvalidierungsalgorithmus ist. Wenn also eine Transaktion in Block `B` hinzugefügt wird, wird die durch diese Transaktion ausgelöste Codeausführung von allen Nodes, jetzt und in Zukunft, ausgeführt, die Block `B` herunterladen und validieren.
## Anwendungen {#applications}
@@ -272,7 +272,7 @@ Dies ist im Wesentlichen eine buchstäbliche Implementierung der Statussübergan
### Finanzderivate und wertstabile Währungen {#financial-derivatives-and-stable-value-currencies}
-Finanzderivate sind die häufigste Anwendung von „Smart Contracts“ und eine der am einfachsten in Code umzusetzenden. Die größte Herausforderung bei der Implementierung von Finanzverträgen besteht darin, dass die Mehrheit von ihnen auf einen externen Preisticker angewiesen ist; ein sehr begehrenswerter Anwendungsfall ist beispielsweise ein Smart Contract, der gegen die Volatilität von Ether (oder einer anderen Kryptowährung) im Verhältnis zum US-Dollar absichert. Dafür muss der Vertrag jedoch den Wert von ETH/USD kennen. Der einfachste Weg, dies zu erreichen, ist über einen „Datenfeed“-Vertrag, der von einer bestimmten Partei (z. B. NASDAQ) betrieben wird. Er ist so konzipiert, dass diese Partei in der Lage ist, den Vertrag nach Bedarf zu aktualisieren, und stellt eine Schnittstelle bereit, die es anderen Verträgen ermöglicht, eine Nachricht an diesen Vertrag zu senden und eine Rückmeldung zu erhalten, die den Preis enthält.
+Finanzderivate sind die häufigste Anwendung von „Smart Contracts“ und eine der am einfachsten in Code umzusetzenden. Die größte Herausforderung bei der Implementierung von Finanzverträgen besteht darin, dass die Mehrheit von ihnen auf einen externen Preisticker angewiesen ist; ein sehr begehrenswerter Anwendungsfall ist beispielsweise ein Smart Contract, der gegen die Volatilität von Ether (oder einer anderen Kryptowährung) im Verhältnis zum US-Dollar absichert. Dafür muss der Vertrag jedoch den Wert von ETH/USD kennen. Der einfachste Weg, dies zu tun, ist über einen „Datenfeed“-Vertrag, der von einer bestimmten Partei (z. B. NASDAQ) unterhalten wird und so konzipiert ist, dass diese Partei die Möglichkeit hat, den Vertrag nach Bedarf zu aktualisieren, und eine Schnittstelle bereitstellt, die es anderen Verträgen ermöglicht, eine Nachricht an diesen Vertrag zu senden und eine Antwort zu erhalten, die den Preis liefert.
Unter dieser Voraussetzung würde der Hedging-Vertrag wie folgt aussehen:
@@ -281,13 +281,13 @@ Unter dieser Voraussetzung würde der Hedging-Vertrag wie folgt aussehen:
3. Den USD-Wert von 1000 Ether, der durch das Abfragen des Datenfeed-Vertrags ermittelt wurde, im Speicher festhalten. Sagen wir, es sind x $.
4. Nach 30 Tagen A oder B erlauben, den Vertrag zu „ reaktivieren“, um x $ wertäquivalente Ether (berechnet durch erneutes Abfragen des Datenfeed-Vertrags, um den neuen Preis zu erhalten) an A und den Rest an B zu senden.
-Ein solcher Vertrag hätte ein erhebliches Potenzial im Kryptohandel. Eines der Hauptprobleme, die im Zusammenhang mit Kryptowährungen angeführt werden, ist die Tatsache, dass sie volatil sind; obwohl viele Benutzer und Händler die Sicherheit und Bequemlichkeit im Umgang mit kryptografischen Assets wünschen, möchten sie möglicherweise nicht riskieren, innerhalb eines einzigen Tages 23 % des Wertes ihrer Mittel zu verlieren. Bis jetzt war die häufigste vorgeschlagene Lösung durch Herausgeber unterstützte Assets; die Idee ist, dass ein Herausgeber eine Unterwährung schafft, in der er das Recht hat, Einheiten auszugeben und zurückzuziehen, und einem beliebigen Benutzer eine Einheit der Währung bereitstellt, der ihm (offline) eine Einheit eines bestimmten zugrunde liegenden Assets (z. B. Gold oder USD) gibt. Der Herausgeber verspricht dann, eine Einheit des zugrunde liegenden Assets an jeden zu liefern, der ihm eine Einheit des Krypto-Assets zurücksendet. Dieser Mechanismus ermöglicht es, jedes nicht-kryptografische Asset in ein kryptografisches Asset „aufzuwerten“, vorausgesetzt, dem Herausgeber kann vertraut werden.
+Ein solcher Vertrag hätte ein erhebliches Potenzial im Kryptohandel. Eines der Hauptprobleme, die im Zusammenhang mit Kryptowährungen angeführt werden, ist die Tatsache, dass sie volatil sind; obwohl viele Benutzer und Händler die Sicherheit und Bequemlichkeit im Umgang mit kryptografischen Assets wünschen, möchten sie möglicherweise nicht riskieren, innerhalb eines einzigen Tages 23 % des Wertes ihrer Mittel zu verlieren. Bisher war die am häufigsten vorgeschlagene Lösung emittentengestützte Vermögenswerte; die Idee ist, dass ein Emittent eine Unterwährung schafft, in der er das Recht hat, Einheiten auszugeben und zu widerrufen, und jedem, der ihm (offline) eine Einheit eines bestimmten zugrunde liegenden Vermögenswerts (z. B. Gold, USD) zur Verfügung stellt, eine Einheit der Währung bereitstellt. Der Herausgeber verspricht dann, eine Einheit des zugrunde liegenden Assets an jeden zu liefern, der ihm eine Einheit des Krypto-Assets zurücksendet. Dieser Mechanismus ermöglicht es, jedes nicht-kryptografische Asset in ein kryptografisches Asset „aufzuwerten“, vorausgesetzt, dem Herausgeber kann vertraut werden.
-In der Praxis sind Herausgeber jedoch nicht immer vertrauenswürdig, und in einigen Fällen ist die Bankinfrastruktur zu schwach oder zu feindlich, als dass solche Dienstleistungen existieren könnten. Finanzderivate bieten eine Alternative. Hier spielt anstelle eines einzelnen Herausgebers, der die Mittel zur Deckung eines Assets bereitstellt, ein dezentraler Markt von Spekulanten diese Rolle, die darauf wetten, dass der Preis eines kryptografischen Referenz-Assets (z. B. ETH) steigen wird. Anders als Herausgeber haben Spekulanten keine Option, ihren Verpflichtungen nicht nachzukommen, da der Hedging-Vertrag ihre Mittel in einem Treuhandkonto hält. Beachten Sie, dass dieser Ansatz nicht vollständig dezentralisiert ist, da eine vertrauenswürdige Quelle weiterhin benötigt wird, um den Preisticker bereitzustellen. Dennoch ist dies in Bezug auf die Reduzierung der Infrastrukturanforderungen (im Gegensatz zum Herausgeber, der für die Ausgabe der Preisfeeds keine Lizenzen benötigt und wahrscheinlich als freie Meinungsäußerung eingestuft werden kann) und die Verringerung des Betrugsrisikos eine erhebliche Verbesserung.
+In der Praxis sind Herausgeber jedoch nicht immer vertrauenswürdig, und in einigen Fällen ist die Bankinfrastruktur zu schwach oder zu feindlich, als dass solche Dienstleistungen existieren könnten. Finanzderivate bieten eine Alternative. Hier spielt anstelle eines einzelnen Emittenten, der die Mittel zur Deckung eines Vermögenswerts bereitstellt, ein dezentraler Markt von Spekulanten, die darauf wetten, dass der Preis eines kryptografischen Referenzvermögenswerts (z. B. ETH) steigen wird, diese Rolle. Anders als Herausgeber haben Spekulanten keine Option, ihren Verpflichtungen nicht nachzukommen, da der Hedging-Vertrag ihre Mittel in einem Treuhandkonto hält. Beachten Sie, dass dieser Ansatz nicht vollständig dezentralisiert ist, da eine vertrauenswürdige Quelle weiterhin benötigt wird, um den Preisticker bereitzustellen. Dennoch ist dies in Bezug auf die Reduzierung der Infrastrukturanforderungen (im Gegensatz zum Herausgeber, der für die Ausgabe der Preisfeeds keine Lizenzen benötigt und wahrscheinlich als freie Meinungsäußerung eingestuft werden kann) und die Verringerung des Betrugsrisikos eine erhebliche Verbesserung.
### Identitäts- und Reputationssysteme {#identity-and-reputation-systems}
-Die früheste alternative Kryptowährung, [Namecoin](http://namecoin.org/), versuchte, eine Bitcoin-ähnliche Blockchain zu nutzen, um ein Namensregistrierungssystem bereitzustellen, in dem Benutzer ihre Namen in einer öffentlichen Datenbank zusammen mit anderen Daten registrieren können. Ein häufig zitierter Anwendungsfall ist ein [DNS](https://wikipedia.org/wiki/Domain_Name_System)-System, das einen Domänennamen wie „bitcoin.org“ (oder „bitcoin.bit“ bei Namecoin) mit einer IP-Adresse verknüpft. Weitere Anwendungsfälle umfassen die E-Mail-Authentifizierung und potenziell fortschrittlichere Reputationssysteme. Hier ist der grundlegende Vertrag, um ein Namecoin-ähnliches Namensregistrierungssystem auf Ethereum bereitzustellen:
+Die früheste alternative Kryptowährung von allen, [Namecoin](http://namecoin.org/), versuchte, eine Bitcoin-ähnliche Blockchain zu verwenden, um ein Namensregistrierungssystem bereitzustellen, bei dem Benutzer ihre Namen in einer öffentlichen Datenbank zusammen mit anderen Daten registrieren können. Der wichtigste angeführte Anwendungsfall ist ein [DNS](https://wikipedia.org/wiki/Domain_Name_System)-System, das Domainnamen wie „bitcoin.org“ (oder im Fall von Namecoin „bitcoin.bit“) einer IP-Adresse zuordnet. Weitere Anwendungsfälle umfassen die E-Mail-Authentifizierung und potenziell fortschrittlichere Reputationssysteme. Hier ist der grundlegende Vertrag, um ein Namecoin-ähnliches Namensregistrierungssystem auf Ethereum bereitzustellen:
```py
def register(name, value):
@@ -295,33 +295,33 @@ def register(name, value):
self.storage[name] = value
```
-Der Vertrag ist sehr einfach; er ist lediglich eine Datenbank innerhalb des Ethereum-Netzwerks, die ergänzt, aber nicht verändert oder entfernt werden kann. Jeder kann einen Namen mit einem gewissen Wert registrieren, und diese Registrierung bleibt dann für immer bestehen. Ein ausgeklügelterer Namensregistrierungsvertrag besitzt auch eine „Funktionsklausel“, die es anderen Verträgen ermöglicht, Abfragen vorzunehmen, sowie einen Mechanismus für den „Eigentümer“ (d. h. den ersten Registrierer) eines Namens, um die Daten zu ändern oder das Eigentum zu übertragen. Darüber hinaus kann man sogar noch Reputations- und Web-of-Trust-Funktionalitäten hinzufügen.
+Der Vertrag ist sehr einfach; er ist lediglich eine Datenbank innerhalb des Ethereum-Netzwerks, die ergänzt, aber nicht verändert oder entfernt werden kann. Jeder kann einen Namen mit einem gewissen Wert registrieren, und diese Registrierung bleibt dann für immer bestehen. Ein anspruchsvollerer Namensregistrierungsvertrag wird auch eine „Funktionsklausel“ haben, die es anderen Verträgen ermöglicht, ihn abzufragen, sowie einen Mechanismus für den „Eigentümer“ (d. h. den ersten Registranten) eines Namens, um die Daten zu ändern oder das Eigentum zu übertragen. Darüber hinaus kann man sogar noch Reputations- und Web-of-Trust-Funktionalitäten hinzufügen.
-### Dezentralisierter Dateispeicher {#decentralized-file-storage}
+### Dezentraler Dateispeicher {#decentralized-file-storage}
In den letzten Jahren sind eine Reihe beliebter Online-Dateispeicher-Startups entstanden, wobei das bekannteste Dropbox ist. Diese Dienste erlauben es dem Benutzer, ein Backup seiner Festplatte hochzuladen, das dann gespeichert wird, sodass der Benutzer gegen eine monatliche Gebühr darauf zugreifen kann. Derzeit ist der Dateispeichermarkt jedoch manchmal relativ ineffizient; ein oberflächlicher Blick auf verschiedene vorhandene Lösungen zeigt, dass insbesondere im „uncanny valley“-Bereich von 20–200 GB, in dem weder kostenlose Quoten noch Rabatte für Unternehmen greifen, die monatlichen Preise für gängige Dateispeicherlösungen so hoch sind, dass man mehr für einen Monat bezahlt als für die gesamte Festplatte. Ethereum-Verträge können die Entwicklung eines dezentralisierten Dateispeicher-Ökosystems ermöglichen, in dem einzelne Benutzer kleine Beträge verdienen können, indem sie ihre eigenen Festplatten vermieten. Ungenutzter Speicherplatz kann dazu verwendet werden, die Kosten für den Dateispeicher weiter zu senken.
-Das zentrale Element eines solchen Systems wäre das, was wir als den „dezentralisierten Dropbox-Vertrag“ nennen. Dieser Vertrag funktioniert wie folgt. Zuerst wird die gewünschte Datenmenge in Blöcke aufgeteilt, wobei jeder Block im Sinne des Datenschutzes verschlüsselt wird, und daraus wird ein Merkle Tree erstellt. Anschließend wird ein Vertrag erstellt, der die Regel enthält, dass der Vertrag alle N Blöcke einen zufälligen Index im Merkle Tree auswählt (unter Verwendung des Hashes des vorherigen Blocks, der im Vertragscode zugänglich ist, als Zufallsquelle) und X Ether an die erste Entität vergibt, die eine Transaktion mit einem vereinfachten Nachweis über das Eigentum am Block an diesem bestimmten Index im Baum vorlegt. Wenn ein Benutzer seine Datei erneut herunterladen möchte, kann er ein Mikrozahlungsprotokoll verwenden (z. B. 1 Szabo pro 32 Kilobyte zahlen), um die Datei wiederherzustellen. Der gebühreneffizienteste Ansatz besteht darin, dass der Zahler die Transaktion bis zum Ende nicht veröffentlicht, sondern die Transaktion nach jeweils 32 Kilobyte durch eine etwas lukrativere mit demselben Nonce ersetzt.
+Das zentrale Element eines solchen Systems wäre das, was wir als den „dezentralisierten Dropbox-Vertrag“ nennen. Dieser Vertrag funktioniert wie folgt. Zuerst wird die gewünschte Datenmenge in Blöcke aufgeteilt, wobei jeder Block im Sinne des Datenschutzes verschlüsselt wird, und daraus wird ein Merkle Tree erstellt. Anschließend wird ein Vertrag erstellt, der die Regel enthält, dass der Vertrag alle N Blöcke einen zufälligen Index im Merkle Tree auswählt (unter Verwendung des Hashes des vorherigen Blocks, der im Vertragscode zugänglich ist, als Zufallsquelle) und X Ether an die erste Entität vergibt, die eine Transaktion mit einem vereinfachten Nachweis über das Eigentum am Block an diesem bestimmten Index im Baum vorlegt. Wenn ein Benutzer seine Datei erneut herunterladen möchte, kann er ein Micropayment-Channel-Protokoll (z. B. 1 Szabo pro 32 Kilobyte) verwenden, um die Datei wiederherzustellen; der gebühreneffizienteste Ansatz ist, dass der Zahler die Transaktion nicht bis zum Ende veröffentlicht, sondern die Transaktion nach jeweils 32 Kilobyte durch eine etwas lukrativere mit derselben Nonce ersetzt.
Eine wichtige Eigenschaft des Protokolls ist, dass man, obwohl es scheinen mag, als vertraue man zahlreichen zufälligen Knoten dabei, die Datei nicht zu vergessen, dieses Risiko auf nahezu null reduzieren kann, indem man die Datei durch geheimes Teilen in viele Stücke aufteilt und die Verträge überwacht, um sicherzustellen, dass jedes Stück noch im Besitz eines Knotens ist. Wenn ein Vertrag weiterhin Geld auszahlt, ist dies ein kryptografischer Beweis dafür, dass jemand da draußen die Datei noch speichert.
-### Dezentralisierte autonome Organisationen {#decentralized-autonomous-organizations}
+### Dezentrale autonome Organisationen {#decentralized-autonomous-organizations}
Das allgemeine Konzept einer „dezentralisierten autonomen Organisation“ bezieht sich auf eine virtuelle Entität, die eine bestimmte Gruppe von Mitgliedern oder Aktionären hat, die möglicherweise mit einer 67-%-Mehrheit das Recht haben, die Mittel der Entität auszugeben und ihren Code zu ändern. Die Mitglieder entscheiden gemeinsam, wie die Organisation ihre Mittel einsetzen sollte. Methoden zur Zuteilung der Mittel einer DAO könnten von Kopfgeldern und Gehältern bis hin zu exotischeren Mechanismen wie einer internen Währung reichen, um Arbeit zu belohnen. Dies stellt im Grunde die rechtlichen Rahmenbedingungen eines herkömmlichen Unternehmens oder einer Nonprofit-Organisation nach, nutzt dabei jedoch ausschließlich kryptografische Blockchain-Technologie zur Durchsetzung. Bisher hat sich viel von der Diskussion über DAOs um das „kapitalistische“ Modell einer „dezentralisierten autonomen Corporation“ (DAC) gedreht, mit dividendenberechtigten Aktionären und handelbaren Anteilen; eine Alternative, die vielleicht als „dezentralisierte autonome Community“ beschrieben werden kann, würde vorsehen, dass alle Mitglieder ein gleiches Mitspracherecht bei Entscheidungen haben und 67 % der bestehenden Mitglieder zustimmen müssen, um ein Mitglied hinzuzufügen oder zu entfernen. Die Anforderung, dass eine Person nur eine Mitgliedschaft haben kann, müsste dann kollektiv von der Gruppe durchgesetzt werden.
Ein allgemeiner Überblick über die Codierung einer DAO sieht folgendermaßen aus. Das einfachste Design besteht aus einem Stück selbstmodifizierendem Code, der sich ändert, wenn zwei Drittel der Mitglieder einer Änderung zustimmen. Obwohl Code theoretisch unveränderlich ist, kann man dies leicht umgehen und de facto Veränderlichkeit erreichen, indem man Teile des Codes in separaten Verträgen speichert und die Adressen der aufzurufenden Verträge im veränderbaren Speicher ablegt. In einer einfachen Implementierung eines solchen DAO-Vertrags gibt es drei Transaktionsarten, die anhand der in der Transaktion bereitgestellten Daten unterschieden werden:
-- `[0,i,K,V]`, um einen Vorschlag mit Index `i` zu registrieren, um die Adresse am Speicherindex `K` auf den Wert `V` zu ändern
+- `[0,i,K,V]`, um einen Vorschlag mit dem Index `i` zu registrieren, die Adresse am Speicherindex `K` auf den Wert `V` zu ändern
- `[1,i]`, um eine Stimme für den Vorschlag `i` zu registrieren
-- `[2,i]`, um den Vorschlag `i` abzuschließen, wenn genügend Stimmen abgegeben worden sind
+- `[2,i]`, um den Vorschlag `i` abzuschließen, wenn genügend Stimmen abgegeben wurden
-Der Vertrag hätte dann Klauseln für jeden Fall. Es würde eine Aufzeichnung aller offenen Änderungen am Speicher sowie eine Liste der entsprechenden Abstimmenden führen. Er würde auch eine Liste aller Mitglieder enthalten. Wenn eine Speicheränderung von zwei Dritteln der Mitglieder unterstützt wird, könnte eine abschließende Transaktion die Änderung ausführen. Ein ausgeklügelteres Gerüst würde auch eine integrierte Abstimmung für Funktionen wie das Senden einer Transaktion und das Hinzufügen und Entfernen von Mitgliedern beinhalten und könnte sogar eine [Liquid Democracy](https://wikipedia.org/wiki/Liquid_democracy)-ähnliche Stimmdelegation ermöglichen (d. h., jeder kann jemanden ernennen, der für ihn abstimmt, und die Ernennung ist transitiv, sodass, wenn A B ernennt und B C ernennt, C über As Stimme entscheidet). Dieses Design würde es der DAO ermöglichen, organisch als dezentralisierte Community zu wachsen, wodurch die Menschen letztendlich die Aufgabe an Spezialisten delegieren können, herauszufiltern, wer ein Mitglied ist. Anders als im „aktuellen System“ können Spezialisten jedoch im Laufe der Zeit leicht ein- und ausgehen, während sich die Ausrichtungen einzelner Community-Mitglieder ändern.
+Der Vertrag hätte dann Klauseln für jeden Fall. Es würde eine Aufzeichnung aller offenen Änderungen am Speicher sowie eine Liste der entsprechenden Abstimmenden führen. Er würde auch eine Liste aller Mitglieder enthalten. Wenn eine Speicheränderung von zwei Dritteln der Mitglieder unterstützt wird, könnte eine abschließende Transaktion die Änderung ausführen. Ein anspruchsvolleres Gerüst hätte auch eine eingebaute Abstimmungsfähigkeit für Funktionen wie das Senden einer Transaktion, das Hinzufügen und Entfernen von Mitgliedern und könnte sogar eine Stimmrechtsdelegation im Stil der [Liquid Democracy](https://wikipedia.org/wiki/Liquid_democracy) vorsehen (d. h., jeder kann jemanden beauftragen, für ihn zu stimmen, und die Beauftragung ist transitiv, sodass, wenn A B beauftragt und B C beauftragt, C über die Stimme von A entscheidet). Dieses Design würde es der DAO ermöglichen, organisch als dezentralisierte Community zu wachsen, wodurch die Menschen letztendlich die Aufgabe an Spezialisten delegieren können, herauszufiltern, wer ein Mitglied ist. Anders als im „aktuellen System“ können Spezialisten jedoch im Laufe der Zeit leicht ein- und ausgehen, während sich die Ausrichtungen einzelner Community-Mitglieder ändern.
Ein alternatives Modell ist das einer dezentralisierten Corporation, bei der jedes Konto null oder mehr Anteile haben kann und zwei Drittel der Anteile erforderlich sind, um eine Entscheidung zu treffen. Ein vollständiges Gerüst würde Funktionen für das Asset-Management beinhalten, die Möglichkeit, ein Angebot zum Kauf oder Verkauf von Aktien zu machen, sowie die Fähigkeit, Angebote zu akzeptieren (idealerweise mit einem Ordermatching-Mechanismus im Vertrag). Es würde auch eine Delegation im Stil der Liquid Democracy geben, die das Konzept eines „Vorstands“ verallgemeinert.
### Weitere Anwendungen {#further-applications}
-**1. Spar-Wallets**. Nehmen wir an, Alice möchte ihre Mittel schützen, ist jedoch besorgt, dass sie ihren privaten Schlüssel verlieren oder jemand ihn hacken könnte. Sie schließt mit Bob, einer Bank, einen Vertrag über Ether ab, und zwar wie folgt:
+**1. Spar-Wallets**. Nehmen wir an, Alice möchte ihre Mittel schützen, ist jedoch besorgt, dass sie ihren privaten Schlüssel verlieren oder jemand ihn hacken könnte. Sie schließt mit Bob, einer Bank, einen Vertrag über Ether ab, und zwar wie folgt:
- Alice allein kann maximal 1 % der Mittel pro Tag abheben.
- Bob allein kann maximal 1 % der Mittel pro Tag abheben, aber Alice hat die Möglichkeit, eine Transaktion mit ihrem Schlüssel durchzuführen, die diese Möglichkeit ausschaltet.
@@ -331,23 +331,23 @@ Normalerweise ist 1 % pro Tag genug für Alice, und wenn sie mehr abheben möcht
**2. Ernteversicherung**. Man kann leicht einen Vertrag für Finanzderivate erstellen, indem man anstelle eines Preisindexes einen Datenfeed über das Wetter verwendet. Wenn ein Landwirt in Iowa ein Derivat kauft, das umgekehrt auf die Niederschläge in Iowa basiert, erhält der Landwirt im Falle einer Dürre automatisch Geld, und wenn es genug regnet, wird der Landwirt glücklich sein, weil die Ernte gut gedeiht. Dies kann auf die Naturkatastrophenversicherung im Allgemeinen ausgeweitet werden.
-**3. Ein dezentralisierter Datenfeed**. Bei Finanzverträgen über Differenzen könnte es tatsächlich möglich sein, den Datenfeed über ein Protokoll namens „[SchellingCoin](https://blog.ethereum.org/2014/03/28/schellingcoin-a-minimal-trust-universal-data-feed/)“ zu dezentralisieren. SchellingCoin funktioniert im Wesentlichen wie folgt: N Parteien geben alle den Wert eines bestimmten Datums in das System ein (z. B. den ETH-USD-Preis), die Werte werden sortiert, und jeder, der zwischen dem 25. und dem 75. Perzentil liegt, erhält als Belohnung ein Token. Jeder hat den Anreiz, die Antwort zu geben, die auch alle anderen geben werden, und der einzige Wert, auf den sich eine große Anzahl von Spielern realistisch einigen kann, ist der offensichtliche Standard: die Wahrheit. Dies schafft ein dezentralisiertes Protokoll, das theoretisch beliebig viele Werte liefern kann, einschließlich des ETH-USD-Preises, der Temperatur in Berlin oder sogar des Ergebnisses einer bestimmten rechenintensiven Berechnung.
+**3. Ein dezentralisierter Datenfeed**. Bei finanziellen Differenzkontrakten könnte es tatsächlich möglich sein, den Daten-Feed über ein Protokoll namens „[SchellingCoin](https://blog.ethereum.org/2014/03/28/schellingcoin-a-minimal-trust-universal-data-feed/)“ zu dezentralisieren. SchellingCoin funktioniert im Grunde wie folgt: N Parteien geben alle den Wert eines gegebenen Datums (z. B. den ETH/USD-Preis) in das System ein, die Werte werden sortiert, und jeder zwischen dem 25. und 75. Perzentil erhält einen Token als Belohnung. Jeder hat den Anreiz, die Antwort zu geben, die auch alle anderen geben werden, und der einzige Wert, auf den sich eine große Anzahl von Spielern realistisch einigen kann, ist der offensichtliche Standard: die Wahrheit. Dies schafft ein dezentralisiertes Protokoll, das theoretisch beliebig viele Werte liefern kann, einschließlich des ETH-USD-Preises, der Temperatur in Berlin oder sogar des Ergebnisses einer bestimmten rechenintensiven Berechnung.
**4. Intelligentes Mehrfachsignatur-Treuhandkonto**. Bitcoin ermöglicht Mehrfachsignatur-Transaktionsverträge, bei denen beispielsweise drei von fünf Schlüsseln die Mittel ausgeben können. Ethereum erlaubt eine genauere Granularität; zum Beispiel können vier von fünf alles ausgeben, drei von fünf können bis zu 10 % pro Tag ausgeben, und zwei von fünf können bis zu 0,5 % pro Tag ausgeben. Zusätzlich ist die Ethereum-Mehrfachsignatur asynchron – zwei Parteien können ihre Signaturen zu unterschiedlichen Zeiten auf der Blockchain registrieren, und die letzte Signatur sendet automatisch die Transaktion.
-**5. Cloud-Computing**. Die EVM-Technologie kann auch genutzt werden, um eine verifizierbare Rechenumgebung zu schaffen, die es Benutzern ermöglicht, andere zu bitten, Berechnungen durchzuführen, und dann optional nach Beweisen zu fragen, dass Berechnungen an bestimmten zufällig ausgewählten Kontrollpunkten korrekt durchgeführt wurden. Dies erlaubt die Einrichtung eines Marktes für Cloud-Computing, in dem jeder Benutzer mit seinem Desktop, Laptop oder spezialisierten Server teilnehmen kann, und Stichprobenkontrollen sowie Sicherheitsanforderungen können verwendet werden, um sicherzustellen, dass das System vertrauenswürdig ist (d. h., Knoten können nicht profitabel betrügen). Obwohl ein solches System möglicherweise nicht für alle Aufgaben geeignet ist, können Aufgaben, die ein hohes Maß an Zwischenprozesskommunikation erfordern, beispielsweise nicht leicht in einer großen Cloud von Knoten durchgeführt werden. Andere Aufgaben lassen sich jedoch viel leichter parallelisieren; Projekte wie SETI@home, folding@home und genetische Algorithmen können leicht auf einer solchen Plattform implementiert werden.
+**5. Cloud-Computing**. Die EVM-Technologie kann auch genutzt werden, um eine verifizierbare Rechenumgebung zu schaffen, die es Benutzern ermöglicht, andere zu bitten, Berechnungen durchzuführen, und dann optional nach Beweisen zu fragen, dass Berechnungen an bestimmten zufällig ausgewählten Kontrollpunkten korrekt durchgeführt wurden. Dies ermöglicht die Schaffung eines Cloud-Computing-Marktes, an dem jeder Benutzer mit seinem Desktop, Laptop oder spezialisierten Server teilnehmen kann, und Stichprobenkontrollen zusammen mit Sicherheitsleistungen können verwendet werden, um sicherzustellen, dass das System vertrauenswürdig ist (d. h., Nodes können nicht gewinnbringend betrügen). Obwohl ein solches System möglicherweise nicht für alle Aufgaben geeignet ist, können Aufgaben, die ein hohes Maß an Zwischenprozesskommunikation erfordern, beispielsweise nicht leicht in einer großen Cloud von Knoten durchgeführt werden. Andere Aufgaben lassen sich jedoch viel leichter parallelisieren; Projekte wie SETI@home, folding@home und genetische Algorithmen können leicht auf einer solchen Plattform implementiert werden.
-**6. Peer-to-Peer-Glücksspiel**. Eine beliebige Anzahl von Peer-to-Peer-Glücksspielprotokollen, wie zum Beispiel Frank Stajano und Richard Claytons [Cyberdice](http://www.cl.cam.ac.uk/\~fms27/papers/2008-StajanoCla-cyberdice.pdf), kann auf der Ethereum-Blockchain implementiert werden. Das einfachste Glücksspielprotokoll ist tatsächlich einfach ein Differenzvertrag auf den nächsten Block-Hash, und fortgeschrittenere Protokolle können darauf aufbauen, um Glücksspieldienste mit nahezu null Gebühren zu schaffen, die keine Betrugsmöglichkeiten bieten.
+**6.** Peer-to-Peer-Glücksspiel\*\*. Beliebig viele Peer-to-Peer-Glücksspielprotokolle, wie z. B. Frank Stajanos und Richard Claytons [Cyberdice](http://www.cl.cam.ac.uk/~fms27/papers/2008-StajanoCla-cyberdice.pdf), können auf der Ethereum-Blockchain implementiert werden. Das einfachste Glücksspielprotokoll ist tatsächlich einfach ein Differenzvertrag auf den nächsten Block-Hash, und fortgeschrittenere Protokolle können darauf aufbauen, um Glücksspieldienste mit nahezu null Gebühren zu schaffen, die keine Betrugsmöglichkeiten bieten.
-**7. Prognosemärkte**. Wenn ein Oracle oder SchellingCoin vorhanden ist, lassen sich Prognosemärkte ebenfalls leicht implementieren, und in Kombination mit SchellingCoin könnten Prognosemärkte die erste gängige Anwendung von [Futarchie](http://hanson.gmu.edu/futarchy.html) als Governance-Protokoll für dezentralisierte Organisationen darstellen.
+**7.** Prognosemärkte\*\*. Sofern ein Oracle oder SchellingCoin vorhanden ist, sind auch Prognosemärkte einfach zu implementieren, und Prognosemärkte zusammen mit SchellingCoin könnten sich als die erste Mainstream-Anwendung der [Futarchie](https://mason.gmu.edu/~rhanson/futarchy.html) als Governance-Protokoll für dezentrale Organisationen erweisen.
-**8. On-Chain-dezentralisierte Marktplätze**, die das Identitäts- und Reputationssystem als Basis nutzen.
+**8. On-Chain dezentrale Marktplätze**, die das Identitäts- und Reputationssystem als Basis nutzen.
## Verschiedenes und Bedenken {#miscellanea-and-concerns}
### Modifizierte GHOST-Implementierung {#modified-ghost-implementation}
-Das „Greedy Heaviest Observed Subtree“(GHOST)-Protokoll ist eine Innovation, die erstmals von Yonatan Sompolinsky und Aviv Zohar im [Dezember 2013](https://eprint.iacr.org/2013/881.pdf) vorgestellt wurde. Die Motivation hinter GHOST ist, dass Blockchains mit schnellen Bestätigungszeiten derzeit unter einer verringerten Sicherheit leiden, aufgrund einer hohen Veralterungsrate – weil Blöcke eine bestimmte Zeit benötigen, um sich im Netzwerk auszubreiten. Wenn Miner A einen Block mint und dann Miner B zufällig einen weiteren Block mint, bevor der Block von Miner A zu B propagiert, wird der Block von Miner B letztlich verschwendet und trägt nicht zur Netzwerksicherheit bei. Darüber hinaus gibt es ein Zentralisierungsproblem: Wenn Miner A ein Mining-Pool mit 30 % Hash-Power ist und B 10 % Hash-Power hat, hat A ein Risiko von 70 %, einen veralteten Block zu erzeugen (da A die letzten 30 % der Zeit den letzten Block produziert hat und somit die Mining-Daten sofort erhält), während B ein Risiko von 90 % hat, einen veralteten Block zu erzeugen. Wenn das Blockintervall also kurz genug ist, um die Veralterungsrate hoch zu halten, wird A folglich allein aufgrund seiner Größe wesentlich effizienter sein. Durch die Kombination dieser beiden Effekte ist es sehr wahrscheinlich, dass Blockchains, die schnell Blöcke produzieren, dazu führen, dass ein Mining-Pool einen ausreichend großen Anteil der Netzwerk-Hash-Power hat, um de facto die Kontrolle über den Mining-Prozess zu übernehmen.
+Das „Greedy Heaviest Observed Subtree“ (GHOST)-Protokoll ist eine Innovation, die erstmals von Yonatan Sompolinsky und Aviv Zohar im [Dezember 2013](https://eprint.iacr.org/2013/881.pdf) vorgestellt wurde. Die Motivation hinter GHOST ist, dass Blockchains mit schnellen Bestätigungszeiten derzeit unter einer verringerten Sicherheit leiden, aufgrund einer hohen Veralterungsrate – weil Blöcke eine bestimmte Zeit benötigen, um sich im Netzwerk auszubreiten. Wenn Miner A einen Block mint und dann Miner B zufällig einen weiteren Block mint, bevor der Block von Miner A zu B propagiert, wird der Block von Miner B letztlich verschwendet und trägt nicht zur Netzwerksicherheit bei. Darüber hinaus gibt es ein Zentralisierungsproblem: Wenn Miner A ein Mining-Pool mit 30 % Hash-Power ist und B 10 % Hash-Power hat, hat A ein Risiko von 70 %, einen veralteten Block zu erzeugen (da A die letzten 30 % der Zeit den letzten Block produziert hat und somit die Mining-Daten sofort erhält), während B ein Risiko von 90 % hat, einen veralteten Block zu erzeugen. Wenn das Blockintervall also kurz genug ist, um die Veralterungsrate hoch zu halten, wird A folglich allein aufgrund seiner Größe wesentlich effizienter sein. Durch die Kombination dieser beiden Effekte ist es sehr wahrscheinlich, dass Blockchains, die schnell Blöcke produzieren, dazu führen, dass ein Mining-Pool einen ausreichend großen Anteil der Netzwerk-Hash-Power hat, um de facto die Kontrolle über den Mining-Prozess zu übernehmen.
Wie von Sompolinsky und Zohar beschrieben, löst GHOST das erste Problem des Verlusts an Netzwerksicherheit, indem er veraltete Blöcke in die Berechnung einbezieht, welche Kette die „längste“ ist; das heißt, nicht nur die übergeordneten und noch früheren Vorgänger eines Blocks, sondern auch die veralteten Nachfolger der Vorgänger des Blocks (in der Ethereum-Sprache „Uncles“) werden in die Berechnung einbezogen, welcher Block die größte Gesamtmenge an Proof-of-Work unterstützt. Um das zweite Problem des Zentralisierungs-Bias zu lösen, gehen wir über das von Sompolinsky und Zohar beschriebene Protokoll hinaus und bieten auch Blockbelohnungen für veraltete Blöcke an: Ein veralteter Block erhält 87,5 % seiner Grundbelohnung, und der Neffe, der den veralteten Block enthält, erhält die verbleibenden 12,5 %. Die Transaktionsgebühren werden jedoch nicht an die Onkel vergeben.
@@ -355,7 +355,7 @@ Ethereum implementiert eine vereinfachte Version von GHOST, die nur sieben Ebene
- Ein Block muss einen übergeordneten Block sowie 0 oder mehr Onkel angeben
- Ein Onkel, der im Block B enthalten ist, muss die folgenden Eigenschaften haben:
- - Es muss ein direkter Nachfahre des Vorfahren der k. Generation von B sein, wobei `2 <= k <= 7`.
+ - Es muss ein direkter Nachkomme des Vorfahren der k-ten Generation von B sein, wobei `2 <= k <= 7`.
- Er kann kein Vorfahre von B sein
- Ein Onkel muss ein gültiger Block-Header sein, muss aber kein zuvor verifizierter oder gar gültiger Block sein
- Ein Onkel muss sich von allen Onkeln unterscheiden, die in früheren Blöcken enthalten waren, sowie von allen anderen Onkeln, die im selben Block enthalten sind (keine doppelte Aufnahme)
@@ -369,12 +369,12 @@ Da jede Transaktion, die in die Blockchain veröffentlicht wird, Kosten für das
Wie sich jedoch herausstellt, hebt dieser Mangel im marktgestützten Mechanismus, bei einer bestimmten ungenauen vereinfachenden Annahme, sich selbst magisch auf. Das Argument lautet wie folgt. Nehmen wir an:
-1. Eine Transaktion führt zu `k` Operationen und bietet eine Belohnung von `kR` für jeden Miner, der sie einfügt, wobei `R` vom Absender festgelegt wird und `k` und `R` (grob gesagt) im Voraus für den Miner sichtbar sind.
-2. Eine Operation hat für jeden Knoten Verarbeitungskosten von `C` (d. h., alle Knoten haben die gleiche Effizienz).
-3. Es gibt `N` Mining-Knoten, die jeweils genau die gleiche Verarbeitungsleistung besitzen (d. h. `1/N` der Gesamtzahl).
+1. Eine Transaktion führt zu `k` Operationen und bietet jedem Miner, der sie einschließt, die Belohnung `kR`, wobei `R` vom Absender festgelegt wird und `k` und `R` (grob) für den Miner im Voraus sichtbar sind.
+2. Eine Operation hat für jeden Node Verarbeitungskosten von `C` (d. h. alle Nodes haben die gleiche Effizienz)
+3. Es gibt `N` Mining-Nodes mit jeweils exakt gleicher Rechenleistung (d. h. `1/N` der Gesamtleistung)
4. Es gibt keine Vollknoten ohne Mining.
-Ein Miner wäre bereit, eine Transaktion zu verarbeiten, wenn die erwartete Belohnung höher ist als die Kosten. Somit beträgt die erwartete Belohnung `kR/N`, da der Miner eine `1/N`-Chance hat, den nächsten Block zu verarbeiten, und die Verarbeitungskosten für den Miner einfach `kC` betragen. Folglich schließen Miner Transaktionen ein, bei denen `kR/N > kC` oder `R > NC` ist. Beachten Sie, dass `R` die Gebühr pro Operation ist, die vom Absender bereitgestellt wird, und somit eine untere Grenze für den Nutzen darstellt, den der Absender aus der Transaktion zieht, während `NC` die Gesamtkosten für das gesamte Netzwerk zur Verarbeitung einer Operation sind. Daher haben Miner den Anreiz, nur diejenigen Transaktionen einzuschließen, deren gesamter utilitaristischer Nutzen die Kosten übersteigt.
+Ein Miner wäre bereit, eine Transaktion zu verarbeiten, wenn die erwartete Belohnung höher ist als die Kosten. Daher beträgt die erwartete Belohnung `kR/N`, da der Miner eine `1/N`-Chance hat, den nächsten Block zu verarbeiten, und die Verarbeitungskosten für den Miner einfach `kC` betragen. Daher werden Miner Transaktionen einschließen, bei denen `kR/N > kC`, oder `R > NC` gilt. Beachten Sie, dass `R` die vom Absender bereitgestellte Gebühr pro Operation ist und somit eine untere Grenze für den Nutzen darstellt, den der Absender aus der Transaktion zieht, und `NC` sind die Kosten für das gesamte Netzwerk zusammen für die Verarbeitung einer Operation. Daher haben Miner den Anreiz, nur diejenigen Transaktionen einzuschließen, deren gesamter utilitaristischer Nutzen die Kosten übersteigt.
Allerdings gibt es in Wirklichkeit mehrere wichtige Abweichungen von diesen Annahmen:
@@ -383,29 +383,33 @@ Allerdings gibt es in Wirklichkeit mehrere wichtige Abweichungen von diesen Anna
3. Die Verteilung der Mining-Power könnte sich in der Praxis als radikal ungleichheitsfördernd erweisen.
4. Es gibt Spekulanten, politische Widersacher und Irre, deren Hilfsfunktion darin besteht, dem Netzwerk zu schaden, und sie können geschickt Verträge aufbauen, bei denen ihre Kosten deutlich unter denen der anderen prüfenden Knoten liegen.
-(1) führt dazu, dass Miner weniger Transaktionen einfügen, und (2) erhöht `NC`; daher heben sich diese beiden Effekte zumindest teilweise auf.[Wie?](https://web.archive.org/web/20250427212319/https://github.com/ethereum/wiki/issues/447#issuecomment-316972260#issuecomment-316972260) (3) und (4) sind das Hauptproblem; um sie zu lösen, setzen wir einfach eine dynamische Obergrenze fest: kein Block darf mehr Operationen enthalten als `BLK_LIMIT_FACTOR`-mal den langfristigen exponentiellen gleitenden Durchschnitt. Konkret:
+(1) bietet eine Tendenz für den Miner, weniger Transaktionen einzuschließen, und
+(2) erhöht `NC`; daher heben sich diese beiden Effekte zumindest teilweise
+gegenseitig auf.[Wie?](https://web.archive.org/web/20250427212319/https://github.com/ethereum/wiki/issues/447#issuecomment-316972260#issuecomment-316972260)
+(3) und (4) sind das Hauptproblem; um sie zu lösen, führen wir einfach eine variable Obergrenze ein: Kein Block kann mehr Operationen enthalten als das `BLK_LIMIT_FACTOR`-fache des langfristigen exponentiell gleitenden Durchschnitts.
+Konkret:
```js
blk.oplimit = floor((blk.parent.oplimit \* (EMAFACTOR - 1) +
floor(parent.opcount \* BLK\_LIMIT\_FACTOR)) / EMA\_FACTOR)
```
-`BLK_LIMIT_FACTOR` und `EMA_FACTOR` sind Konstanten, die vorläufig auf 65536 und 1,5 gesetzt werden, aber wahrscheinlich nach weiteren Analysen geändert werden.
+`BLK_LIMIT_FACTOR` und `EMA_FACTOR` sind Konstanten, die vorerst auf 65536 und 1.5 gesetzt werden, aber nach weiterer Analyse wahrscheinlich geändert werden.
Ein weiterer Faktor, der große Blockgrößen in Bitcoin unattraktiv macht, ist, dass größere Blöcke länger zur Propagation benötigen und somit eine höhere Wahrscheinlichkeit haben, zu veralten. In Ethereum benötigen Blöcke, die viel Gas verbrauchen, auch länger zur Propagation, weil sie größer sind und weil die Verarbeitung der Statusübergänge der Transaktionen zur Validierung mehr Zeit in Anspruch nimmt. Diese Verzögerungsabschreckung ist ein bedeutender Aspekt in Bitcoin, jedoch aufgrund des GHOST-Protokolls weniger ausgeprägt in Ethereum; daher bietet das Verlassen auf regulierte Blockgrenzen eine stabilere Basis.
-### Berechnungen und Turing-Completeness {#computation-and-turing-completeness}
+### Berechnung und Turing-Vollständigkeit {#computation-and-turing-completeness}
-Ein wichtiger Hinweis ist, dass die virtuelle Maschine von Ethereum Turing-komplett ist; das bedeutet, dass der EVM-Code jede Berechnung, die möglicherweise ausgeführt werden kann, einschließlich Endlosschleifen, codieren kann. Der EVM-Code ermöglicht das Looping auf zwei Arten. Erstens gibt es eine `JUMP`-Anweisung, die das Programm an einen früheren Punkt im Code springen lässt, und eine `JUMPI`-Anweisung für bedingtes Springen, die solche Aussagen wie `while x < 27: x = x * 2` zulässt. Zweitens können Verträge andere Verträge aufrufen, was potenziell die Ausführung von Schleifen durch Rekursion ermöglicht. Dies führt zwangsläufig zu einem Problem: Können böswillige Benutzer Miner und vollständige Knoten im Grunde genommen ausschalten, indem sie sie in eine Endlosschleife zwingen? Das Problem ergibt sich aus einer Thematik in der Informatik, die als Halteproblem bekannt ist: Es gibt keine allgemeine Methode, um zu erkennen, ob ein bestimmtes Programm jemals zum Stillstand kommt oder nicht.
+Ein wichtiger Hinweis ist, dass die virtuelle Maschine von Ethereum Turing-komplett ist; das bedeutet, dass der EVM-Code jede Berechnung, die möglicherweise ausgeführt werden kann, einschließlich Endlosschleifen, codieren kann. Der EVM-Code ermöglicht das Looping auf zwei Arten. Erstens gibt es eine `JUMP`-Anweisung, die es dem Programm ermöglicht, zu einer früheren Stelle im Code zurückzuspringen, und eine `JUMPI`-Anweisung für bedingte Sprünge, die Anweisungen wie `while x < 27: x = x * 2` ermöglicht. Zweitens können Verträge andere Verträge aufrufen, was potenziell die Ausführung von Schleifen durch Rekursion ermöglicht. Dies führt zwangsläufig zu einem Problem: Können böswillige Benutzer Miner und vollständige Knoten im Grunde genommen ausschalten, indem sie sie in eine Endlosschleife zwingen? Das Problem ergibt sich aus einer Thematik in der Informatik, die als Halteproblem bekannt ist: Es gibt keine allgemeine Methode, um zu erkennen, ob ein bestimmtes Programm jemals zum Stillstand kommt oder nicht.
Wie im Abschnitt zu den Statusübergängen beschrieben funktioniert unsere Lösung, indem eine Transaktion die maximale Anzahl an Rechenschritten festlegt, die sie ausführen darf. Wenn die Ausführung länger dauert, wird die Berechnung zurückgesetzt, aber die Gebühren werden dennoch bezahlt. Nachrichten funktionieren auf die gleiche Weise. Um die Motivation hinter unserer Lösung zu verdeutlichen, betrachten Sie die folgenden Beispiele:
- Ein Angreifer erstellt einen Vertrag, der eine Endlosschleife ausführt, und sendet dann eine Transaktion, die diese Schleife beim Miner aktiviert. Der Miner verarbeitet die Transaktion, führt die Endlosschleife aus und wartet darauf, dass das Gas ausgeht. Auch wenn die Ausführung kein Gas mehr hat und mitten im Vorgang stoppt, ist die Transaktion weiterhin gültig, und der Miner erhält von dem Angreifer die Gebühr für jeden Rechenschritt.
-- Ein Angreifer erstellt eine sehr lange Endlosschleife mit der Absicht, den Miner dazu zu bringen, so lange zu rechnen, dass, wenn die Berechnung abgeschlossen ist, bereits einige weitere Blöcke erstellt wurden und es dem Miner nicht möglich ist, die Transaktion zur Einforderung der Gebühr einzuschließen. Allerdings muss der Angreifer einen Wert für `STARTGAS` angeben, der die Anzahl der Rechenschritte begrenzt, die die Ausführung benötigen kann. Dadurch weiß der Miner bereits im Voraus, dass die Berechnung eine übermäßig große Anzahl von Schritten benötigen wird.
-- Ein Angreifer entdeckt einen Vertrag mit Code in der Form `send(A,contract.storage[A]); contract.storage[A] = 0` und sendet eine Transaktion mit gerade genug Gas, um den ersten Schritt auszuführen, aber nicht den zweiten (d. h., eine Abhebung vorzunehmen, ohne den Saldo zu senken). Der Vertragsautor muss sich keine Sorgen um den Schutz vor solchen Angriffen machen, denn die Änderungen werden rückgängig gemacht, wenn die Ausführung im Änderungsprozess stoppt.
+- Ein Angreifer erstellt eine sehr lange Endlosschleife mit der Absicht, den Miner dazu zu bringen, so lange zu rechnen, dass, wenn die Berechnung abgeschlossen ist, bereits einige weitere Blöcke erstellt wurden und es dem Miner nicht möglich ist, die Transaktion zur Einforderung der Gebühr einzuschließen. Der Angreifer muss jedoch einen Wert für `STARTGAS` übermitteln, der die Anzahl der Rechenschritte begrenzt, die die Ausführung durchführen kann, sodass der Miner im Voraus weiß, dass die Berechnung eine übermäßig große Anzahl von Schritten erfordern wird.
+- Ein Angreifer sieht einen Vertrag mit Code der Form `send(A,contract.storage[A]); contract.storage[A] = 0` und sendet eine Transaktion mit gerade genug Gas, um den ersten Schritt auszuführen, aber nicht den zweiten (d. h. eine Auszahlung vorzunehmen, aber den Saldo nicht sinken zu lassen). Der Vertragsautor muss sich keine Sorgen um den Schutz vor solchen Angriffen machen, denn die Änderungen werden rückgängig gemacht, wenn die Ausführung im Änderungsprozess stoppt.
- Eine finanzielle Vereinbarung funktioniert, indem der Median von neun proprietären Datenfeeds genommen wird, um das Risiko zu minimieren. Ein Angreifer übernimmt einen der Datenfeeds, der so gestaltet ist, dass er über den variablen Adressaufruf-Mechanismus, der im Abschnitt über DAOs beschrieben ist, modifiziert werden kann, und wandelt ihn so um, dass er in einer Endlosschleife läuft, um damit zu versuchen, alle Unternehmungen, Mittel aus dem Finanzvertrag zu beanspruchen, an den Gas-Limit scheitern zu lassen. Jedoch kann der Finanzvertrag ein Gas-Limit für die Nachricht festlegen, um dieses Problem zu verhindern.
-Die Alternative zur Turing-Completeness ist Turing-Incompleteness, bei der `JUMP` und `JUMPI` nicht existieren und nur eine Kopie jedes Vertrags zu einem beliebigen Zeitpunkt im Aufrufstack existieren darf. Mit diesem System könnten das beschriebene Gebührensystem sowie die Unsicherheiten bezüglich der Wirksamkeit unserer Lösung möglicherweise entfallen, da die Kosten für die Ausführung eines Vertrags durch dessen Größe nach oben beschränkt wären. Zusätzlich ist Turing-Incompleteness nicht einmal eine allzu große Einschränkung; von allen Vertragsbeispielen, die wir intern konzipiert haben, benötigte bisher nur eines eine Schleife, und selbst diese Schleife konnte durch 26 Wiederholungen einer einzeiligen Codezeile entfernt werden. Angesichts der schwerwiegenden Folgen von Turing-Completeness und des begrenzten Nutzens – warum nicht einfach eine Turing-inkomplette Sprache verwenden? Tatsächlich ist Turing-Incompleteness jedoch alles andere als eine saubere Lösung für das Problem. Um den Grund zu verstehen, betrachten Sie die folgenden Verträge:
+Die Alternative zur Turing-Vollständigkeit ist die Turing-Unvollständigkeit, bei der `JUMP` und `JUMPI` nicht existieren und zu jedem Zeitpunkt nur eine Kopie jedes Vertrags im Aufrufstapel vorhanden sein darf. Mit diesem System könnten das beschriebene Gebührensystem sowie die Unsicherheiten bezüglich der Wirksamkeit unserer Lösung möglicherweise entfallen, da die Kosten für die Ausführung eines Vertrags durch dessen Größe nach oben beschränkt wären. Zusätzlich ist Turing-Incompleteness nicht einmal eine allzu große Einschränkung; von allen Vertragsbeispielen, die wir intern konzipiert haben, benötigte bisher nur eines eine Schleife, und selbst diese Schleife konnte durch 26 Wiederholungen einer einzeiligen Codezeile entfernt werden. Angesichts der schwerwiegenden Folgen von Turing-Completeness und des begrenzten Nutzens – warum nicht einfach eine Turing-inkomplette Sprache verwenden? Tatsächlich ist Turing-Incompleteness jedoch alles andere als eine saubere Lösung für das Problem. Um den Grund zu verstehen, betrachten Sie die folgenden Verträge:
```sh
C0: call(C1); call(C1);
@@ -418,7 +422,7 @@ C50: (einen Schritt eines Programms ausführen und die Änderung im Speicher auf
Nun soll eine Transaktion an A gedendet werden. Damit haben wir in 51 Transaktionen einen Vertrag, der 250 Rechenschritte benötigt. Miner könnten versuchen, solche „Logikbomben“ im Voraus zu erkennen, indem sie einen Wert neben jedem Vertrag beibehalten, der die maximale Anzahl an Rechenschritten angibt, die er ausführen kann. Dies müsste auch für Verträge gelten, die andere Verträge rekursiv aufrufen, was jedoch erfordert, dass Miner Verträge verbieten, die andere Verträge erstellen (da die Erstellung und Ausführung aller oben genannten 26 Verträge leicht zu einem einzigen Vertrag zusammengefasst werden könnte). Ein weiterer problematischer Aspekt besteht darin, dass das Adressfeld einer Nachricht variabel ist, weshalb es im Allgemeinen nicht einmal möglich sein könnte, im Voraus zu erkennen, welche anderen Verträge ein bestimmter Vertrag aufrufen könnte. Daher kommen wir unterm Strich zu einem überraschenden Schluss: Turing-Completeness ist überraschend einfach zu verwalten, und das Fehlen von Turing-Completeness ist ebenso überraschend schwierig zu verwalten, es sei denn, genau dieselben Kontrollmechanismen sind vorhanden – aber warum sollte man in diesem Fall das Protokoll nicht einfach Turing-komplett sein lassen?
-### Währung und Ausgabe {#currency-and-issuance}
+### Währung und Emission {#currency-and-issuance}
Das Ethereum-Netzwerk beinhaltet seine eigene integrierte Währung, Ether, die zwei Zwecke erfüllt: Zum einen dient sie als primäre Liquiditätsebene, um einen effizienten Austausch zwischen verschiedenen Arten von digitalen Assets zu ermöglichen, und zum anderen, wichtiger noch, stellt sie einen Mechanismus zur Bezahlung von Transaktionsgebühren bereit. Zur Vereinfachung und um zukünftige Streitigkeiten zu vermeiden (siehe die aktuelle Diskussion über mBTC/uBTC/Satoshi in Bitcoin), werden die Nennwerte vorab gekennzeichnet:
@@ -441,7 +445,7 @@ Das Ausgabemodell wird wie folgt aussehen:
| Währungseinheiten | 1,198-mal | 1,458-mal | 2,498-mal |
| Käufer | 83,5 % | 68,6 % | 40,0 % |
| Vor dem Verkauf ausgegebene Reserve | 8,26 % | 6,79 % | 3,96 % |
-| Nach dem Verkauf verwendete Reserve | 8.26% | 6.79% | 3.96% |
+| Nach dem Verkauf verwendete Reserve | 8,26 % | 6,79 % | 3,96 % |
| Miner | 0 % | 17,8 % | 52,0 % |
#### Langfristige Versorgungswachstumsrate (Prozent)
@@ -450,17 +454,17 @@ Das Ausgabemodell wird wie folgt aussehen:
_Trotz der linearen Währungsherausgabe tendiert, ähnlich wie bei Bitcoin, die Wachstumsrate des Angebots über die Zeit dennoch gegen null._
-Die zwei Hauptentscheidungen im obigen Modell sind (1) die Existenz und Größe eines Endowment-Pools sowie (2) die Existenz einer dauerhaft wachsenden linearen Versorgung im Gegensatz zu einer begrenzten Versorgung wie bei Bitcoin. Die Rechtfertigung des Endowment-Pools ist wie folgt. Wenn es keinen Endowment-Pool gäbe und die lineare Ausgabe auf 0,217-mal verringert würde, um die gleiche Inflationsrate zu erreichen, würde die Gesamtmenge an Ether um 16,5 % niedriger sein, was bedeutet, dass jede Einheit 19,8 % mehr wert wäre. Daher würden im Gleichgewicht 19,8 % mehr Ether im Verkauf gekauft werden, sodass jede Einheit wieder genau so viel Wert hätte wie zuvor. Die Organisation hätte dann auch 1,198-mal so viel BTC, das als in zwei Segmente unterteilt betrachtet werden kann: das ursprüngliche BTC und die zusätzlichen 0,198-mal. Folglich ist diese Situation _genau äquivalent_ zum Endowment, aber mit einem entscheidenden Unterschied: Die Organisation hält nur BTC und hat daher keinen Anreiz, den Wert der Ether-Einheit zu fördern.
+Die zwei Hauptentscheidungen im obigen Modell sind (1) die Existenz und Größe eines Endowment-Pools sowie (2) die Existenz einer dauerhaft wachsenden linearen Versorgung im Gegensatz zu einer begrenzten Versorgung wie bei Bitcoin. Die Rechtfertigung des Endowment-Pools ist wie folgt. Wenn es keinen Endowment-Pool gäbe und die lineare Ausgabe auf 0,217-mal verringert würde, um die gleiche Inflationsrate zu erreichen, würde die Gesamtmenge an Ether um 16,5 % niedriger sein, was bedeutet, dass jede Einheit 19,8 % mehr wert wäre. Daher würden im Gleichgewicht 19,8 % mehr Ether im Verkauf gekauft werden, sodass jede Einheit wieder genau so viel Wert hätte wie zuvor. Die Organisation hätte dann auch 1,198-mal so viel BTC, das als in zwei Segmente unterteilt betrachtet werden kann: das ursprüngliche BTC und die zusätzlichen 0,198-mal. Daher ist diese Situation _genau äquivalent_ zur Stiftung, aber mit einem wichtigen Unterschied: Die Organisation hält ausschließlich BTC und hat daher keinen Anreiz, den Wert der Ether-Einheit zu unterstützen.
-Das Modell des permanenten linearen Angebotswachstums verringert das Risiko dessen, was einige als übermäßige Vermögenskonzentration in Bitcoin ansehen, und bietet jetzt und in Zukunft eine faire Chance, Währungseinheiten zu erwerben, während gleichzeitig ein starker Anreiz besteht, Ether zu erwerben und zu halten, da die „Angebotswachstumsrate“ prozentual betrachtet im Laufe der Zeit dennoch gegen null tendiert. Außerdem vermuten wir, dass Münzen aufgrund von Nachlässigkeit, Tod usw. im Laufe der Zeit immer verloren gehen und dass der Münzverlust als Prozentsatz des Gesamtangebots pro Jahr modelliert werden kann. Infolgedessen wird sich das gesamte im Umlauf befindliche Währungsangebot tatsächlich irgendwann auf einen Wert stabilisieren, der der jährlichen Ausgabe geteilt durch die Verlustquote entspricht (z. B. bei einer Verlustquote von 1 % wird, sobald für das Angebot das 26-Fache erreicht ist, jährlich das 0,26-Fache gemint und das 0,26-Fache geht verloren, was ein Gleichgewicht erzeugt).
+Das Modell des permanenten linearen Angebotswachstums verringert das Risiko dessen, was einige als übermäßige Vermögenskonzentration in Bitcoin ansehen, und bietet jetzt und in Zukunft eine faire Chance, Währungseinheiten zu erwerben, während gleichzeitig ein starker Anreiz besteht, Ether zu erwerben und zu halten, da die „Angebotswachstumsrate“ prozentual betrachtet im Laufe der Zeit dennoch gegen null tendiert. Wir stellen auch die Theorie auf, dass, da Coins im Laufe der Zeit durch Unachtsamkeit, Tod usw. immer verloren gehen und der Coin-Verlust als Prozentsatz des Gesamtangebots pro Jahr modelliert werden kann, sich das gesamte im Umlauf befindliche Währungsangebot tatsächlich irgendwann auf einem Wert stabilisieren wird, der der jährlichen Emission geteilt durch die Verlustrate entspricht (z. B. bei einer Verlustrate von 1 % werden, sobald das Angebot das 26-fache erreicht, jedes Jahr 0,26X geschürft und 0,26X gehen verloren, wodurch ein Gleichgewicht entsteht).
-Beachten Sie, dass Ethereum in Zukunft wahrscheinlich zu einem Proof-of-Stake-Modell für Sicherheit wechseln wird, wodurch die Ausgaberate auf irgendwo zwischen null und 0,05-mal pro Jahr gesenkt wird. Für den Fall, dass die Ethereum-Organisation ihre Finanzierung verliert oder aus irgendeinem anderen Grund verschwindet, lassen wir einen „Gesellschaftsvertrag“ offen: Jeder hat das Recht, eine zukünftige Kandidat-Version von Ethereum zu erstellen, wobei die einzige Bedingung ist, dass die Menge an Ether höchstens gleich `60102216 * (1.198 + 0.26 * n)` sein darf, wobei `n` die Anzahl der Jahre nach dem Genesis-Block ist. Die Ersteller können frei entscheiden, einen Crowdsale durchzuführen oder auf andere Weise einen Teil oder die gesamte Differenz zwischen der von PoS angetriebenen Angebotsausweitung und der maximal erlaubten Angebotsausweitung zuzuweisen, um die Entwicklung zu bezahlen. Kandidaten-Upgrades, die nicht dem sozialen Vertrag entsprechen, dürfen berechtigterweise in konforme Versionen abgespalten werden.
+Beachten Sie, dass Ethereum in Zukunft wahrscheinlich zu einem Proof-of-Stake-Modell für Sicherheit wechseln wird, wodurch die Ausgaberate auf irgendwo zwischen null und 0,05-mal pro Jahr gesenkt wird. Für den Fall, dass die Ethereum-Organisation ihre Finanzierung verliert oder aus einem anderen Grund verschwindet, lassen wir einen „Gesellschaftsvertrag“ offen: Jeder hat das Recht, eine zukünftige Kandidatenversion von Ethereum zu erstellen, mit der einzigen Bedingung, dass die Menge an Ether höchstens gleich `60102216 * (1.198 + 0.26 * n)` sein darf, wobei `n` die Anzahl der Jahre nach dem Genesis-Block ist. Die Ersteller können frei entscheiden, einen Crowdsale durchzuführen oder auf andere Weise einen Teil oder die gesamte Differenz zwischen der von PoS angetriebenen Angebotsausweitung und der maximal erlaubten Angebotsausweitung zuzuweisen, um die Entwicklung zu bezahlen. Kandidaten-Upgrades, die nicht dem sozialen Vertrag entsprechen, dürfen berechtigterweise in konforme Versionen abgespalten werden.
### Mining-Zentralisierung {#mining-centralization}
Der Bitcoin-Mining-Algorithmus funktioniert, indem Miner SHA256 auf leicht modifizierte Versionen des Block-Headers Millionen von Malen berechnen, bis schließlich ein Knoten eine Version findet, deren Hash kleiner ist als das Ziel (derzeit etwa 2192). Allerdings ist dieser Mining-Algorithmus anfällig für zwei Formen der Zentralisierung. Erstens wird das Mining-Ökosystem von ASICs (Application-Specific Integrated Circuits) dominiert, also von Computerchips, die speziell für das Bitcoin-Mining entwickelt wurden und daher tausendmal effizienter in dieser spezifischen Aufgabe sind. Das bedeutet, dass Bitcoin-Mining nicht mehr eine stark dezentralisierte und egalitäre Aktivität ist, die Millionen von Dollar an Kapital erfordert, um effektiv teilzunehmen. Zweitens führen die meisten Bitcoin-Miner die Blockvalidierung nicht tatsächlich lokal durch; stattdessen verlassen sie sich auf einen zentralisierten Mining-Pool, um die Block-Header bereitzustellen. Dieses Problem ist wohl schlimmer: Zum Zeitpunkt der Erstellung dieses Textes kontrollieren die drei größten Mining-Pools indirekt etwa 50 % der Rechenleistung im Bitcoin-Netzwerk, obwohl dies dadurch gemildert wird, dass Miner zu anderen Mining-Pools wechseln können, wenn ein Pool oder ein Bündnis sich einen 51-%-Angriff vornimmt.
-Die aktuelle Absicht von Ethereum besteht darin, einen Mining-Algorithmus zu verwenden, bei dem Miner zufällige Daten aus dem Status abrufen, einige zufällig ausgewählte Transaktionen aus den letzten N Blöcken der Blockchain berechnen und den Hash des Ergebnisses zurückgeben müssen. Dies hat zwei wichtige Vorteile. Erstens können Ethereum-Verträge jede Art von Berechnung enthalten, sodass ein Ethereum-ASIC im Grunde genommen ein ASIC für allgemeine Berechnungen wäre – also ein besserer CPU. Zweitens erfordert das Mining Zugang zur gesamten Blockchain, was die Miner zwingt, die gesamte Blockchain zu speichern und mindestens in der Lage zu sein, jede Transaktion zu verifizieren. Dies macht zentralisierte Mining-Pools überflüssig; obwohl Mining-Pools immer noch die legitime Rolle haben können, die Zufälligkeit der Gewinnverteilung auszugleichen, kann diese Funktion ebenso gut von Peer-to-Peer-Pools ohne zentrale Kontrolle erfüllt werden.
+Die aktuelle Absicht von Ethereum besteht darin, einen Mining-Algorithmus zu verwenden, bei dem Miner zufällige Daten aus dem Status abrufen, einige zufällig ausgewählte Transaktionen aus den letzten N Blöcken der Blockchain berechnen und den Hash des Ergebnisses zurückgeben müssen. Dies hat zwei wichtige Vorteile. Erstens können Ethereum-Verträge jede Art von Berechnung enthalten, sodass ein Ethereum-ASIC im Wesentlichen ein ASIC für allgemeine Berechnungen wäre – d. h. eine bessere CPU. Zweitens erfordert das Mining Zugang zur gesamten Blockchain, was die Miner zwingt, die gesamte Blockchain zu speichern und mindestens in der Lage zu sein, jede Transaktion zu verifizieren. Dies macht zentralisierte Mining-Pools überflüssig; obwohl Mining-Pools immer noch die legitime Rolle haben können, die Zufälligkeit der Gewinnverteilung auszugleichen, kann diese Funktion ebenso gut von Peer-to-Peer-Pools ohne zentrale Kontrolle erfüllt werden.
Dieses Modell ist noch nicht getestet, und es könnte Schwierigkeiten dabei geben, bestimmte clevere Optimierungen zu vermeiden, wenn die Vertragsausführung als Mining-Algorithmus verwendet wird. Eine besonders interessante Eigenschaft dieses Algorithmus ist jedoch, dass er jedem ermöglicht, „den Brunnen zu vergiften“, indem er eine große Anzahl von Verträgen in die Blockchain einführt, die speziell dazu entwickelt wurden, bestimmte ASICs auszubremsen. Es bestehen wirtschaftliche Anreize für ASIC-Hersteller, einen solchen Trick zu verwenden, um gegeneinander vorzugehen. Daher ist die Lösung, die wir entwickeln, letztendlich eine adaptive wirtschaftlich-menschliche Lösung und nicht nur eine rein technische.
@@ -468,9 +472,9 @@ Dieses Modell ist noch nicht getestet, und es könnte Schwierigkeiten dabei gebe
Eine häufige Sorge im Zusammenhang mit Ethereum ist die Frage der Skalierbarkeit. Wie Bitcoin leidet auch Ethereum unter dem Nachteil, dass jede Transaktion von jedem Knoten im Netzwerk verarbeitet werden muss. Derzeit beläuft sich die Größe der Bitcoin-Blockchain auf etwa 15 GB und wächst um etwa 1 MB pro Stunde. Wenn das Bitcoin-Netzwerk die 2000 Transaktionen pro Sekunde von Visa verarbeiten würde, würde es alle drei Sekunden um 1 MB wachsen (1 GB pro Stunde, 8 TB pro Jahr). Ethereum wird voraussichtlich ein ähnliches Wachstumsverhalten aufweisen, verschärft durch die Tatsache, dass es viele Anwendungen auf der Ethereum-Blockchain geben wird, anstatt nur eine Währung wie bei Bitcoin. Positiv zu vermerken ist jedoch, dass Ethereum-Vollknoten nur den Status und nicht die gesamte Historie der Blockchain speichern müssen.
-Das Problem bei einer so großen Blockchain ist das Zentralisierungsrisiko. Wenn die Größe der Blockchain auf beispielsweise 100 TB ansteigt, wäre das wahrscheinlichste Szenario, dass nur eine sehr kleine Anzahl großer Unternehmen Vollknoten betreibt, während alle regulären Benutzer leichte SPV-Knoten verwenden. In einer solchen Situation entsteht die potenzielle Sorge, dass die Vollknoten sich zusammenschließen und alle einvernehmlich auf betrügerische Weise (z. B. die Blockbelohnung ändern oder sich selbst BTC geben) handeln könnten. Leichte Knoten hätten keine Möglichkeit, dies sofort zu erkennen. Natürlich würde wahrscheinlich mindestens ein ehrlicher Vollknoten existieren, und nach ein paar Stunden würden Informationen über den Betrug über Kanäle wie Reddit verbreitet werden. Aber zu diesem Zeitpunkt wäre es zu spät: Es wäre an den gewöhnlichen Benutzern, eine Initiative zu organisieren, um die betreffenden Blöcke auf die schwarze Liste zu setzen, was ein massives und vermutlich unpraktikables Koordinationsproblem darstellt – ähnlich dem einer erfolgreichen 51-%-Attacke. Im Fall von Bitcoin ist dies derzeit ein Problem, aber es gibt eine von [Peter Todd](https://web.archive.org/web/20140623061815/http://sourceforge.net/p/bitcoin/mailman/message/31709140/) vorgeschlagene Modifikation der Blockchain, die dieses Problem lindern wird.
+Das Problem bei einer so großen Blockchain ist das Zentralisierungsrisiko. Wenn die Größe der Blockchain auf beispielsweise 100 TB ansteigt, wäre das wahrscheinlichste Szenario, dass nur eine sehr kleine Anzahl großer Unternehmen Vollknoten betreibt, während alle regulären Benutzer leichte SPV-Knoten verwenden. In einer solchen Situation besteht die potenzielle Sorge, dass die Full-Nodes sich zusammenschließen und alle zustimmen könnten, auf profitable Weise zu betrügen (z. B. die Block-Belohnung ändern, sich selbst BTC geben). Leichte Knoten hätten keine Möglichkeit, dies sofort zu erkennen. Natürlich würde wahrscheinlich mindestens ein ehrlicher Vollknoten existieren, und nach ein paar Stunden würden Informationen über den Betrug über Kanäle wie Reddit verbreitet werden. Aber zu diesem Zeitpunkt wäre es zu spät: Es wäre an den gewöhnlichen Benutzern, eine Initiative zu organisieren, um die betreffenden Blöcke auf die schwarze Liste zu setzen, was ein massives und vermutlich unpraktikables Koordinationsproblem darstellt – ähnlich dem einer erfolgreichen 51-%-Attacke. Im Fall von Bitcoin ist dies derzeit ein Problem, aber es gibt eine von [Peter Todd vorgeschlagene](https://web.archive.org/web/20140623061815/http://sourceforge.net/p/bitcoin/mailman/message/31709140/) Blockchain-Modifikation, die dieses Problem lindern wird.
-Kurzfristig wird Ethereum zwei zusätzliche Strategien nutzen, um mit diesem Problem umzugehen. Erstens werden alle Miner aufgrund der Blockchain-basierten Mining-Algorithmen gezwungen, Vollknoten zu sein, wodurch eine Untergrenze für die Anzahl der Vollknoten geschaffen wird. Zweitens, und das ist noch wichtiger, werden wir nach der Verarbeitung jeder Transaktion einen Wurzelknoten eines Zwischenspeicherbaums in die Blockchain einfügen. Selbst wenn die Blockvalidierung zentralisiert ist, kann das Zentralisierungsproblem durch ein Verifizierungsprotokoll umgangen werden, solange mindestens ein ehrlicher verifizierender Knoten existiert. Wenn ein Miner einen ungültigen Block veröffentlicht, muss dieser Block schlecht formatiert sein, oder der Status `S[n]` ist falsch. Da `S[0]` bekanntlich korrekt ist, muss es einen ersten Status `S[i]` geben, der inkorrekt ist, wobei `S[i-1]` korrekt ist. Der verifizierende Knoten würde den Index `i` zusammen mit einem „Beweis der Ungültigkeit“ bereitstellen, der aus der Teilmenge der Patricia Tree-Knoten besteht, die benötigt wird, um `APPLY(S[i-1],TX[i]) -> S[i]` zu verarbeiten. Knoten würden in der Lage sein, diese Knoten zu verwenden, um diesen Teil der Berechnung auszuführen und festzustellen, dass das erzeugte `S[i]` nicht mit dem bereitgestellten `S[i]` übereinstimmt.
+Kurzfristig wird Ethereum zwei zusätzliche Strategien nutzen, um mit diesem Problem umzugehen. Erstens werden alle Miner aufgrund der Blockchain-basierten Mining-Algorithmen gezwungen, Vollknoten zu sein, wodurch eine Untergrenze für die Anzahl der Vollknoten geschaffen wird. Zweitens, und das ist noch wichtiger, werden wir nach der Verarbeitung jeder Transaktion einen Wurzelknoten eines Zwischenspeicherbaums in die Blockchain einfügen. Selbst wenn die Blockvalidierung zentralisiert ist, kann das Zentralisierungsproblem durch ein Verifizierungsprotokoll umgangen werden, solange mindestens ein ehrlicher verifizierender Knoten existiert. Wenn ein Miner einen ungültigen Block veröffentlicht, muss dieser Block entweder schlecht formatiert sein oder der Zustand `S[n]` ist falsch. Da `S[0]` bekanntermaßen korrekt ist, muss es einen ersten Zustand `S[i]` geben, der falsch ist, wobei `S[i-1]` korrekt ist. Der verifizierende Node würde den Index `i` zusammen mit einem „Ungültigkeitsbeweis“ bereitstellen, der aus der Teilmenge der Patricia-Tree-Nodes besteht, die zur Verarbeitung von `APPLY(S[i-1],TX[i]) -> S[i]` benötigt werden. Die Nodes könnten diese Nodes verwenden, um diesen Teil der Berechnung auszuführen, und sehen, dass das generierte `S[i]` nicht mit dem bereitgestellten `S[i]` übereinstimmt.
Ein weiterer, ausgeklügelterer Angriff würde darin bestehen, dass böswillige Miner unvollständige Blöcke veröffentlichen, sodass die vollständigen Informationen überhaupt nicht vorhanden sind, um zu bestimmen, ob die Blöcke gültig sind oder nicht. Die Lösung dafür ist ein Challenge-Response-Protokoll: Verifizierungsknoten geben „Herausforderungen“ in Form von Zieltransaktionsindizes aus, und beim Empfang behandelt ein leichter Knoten den Block als vertrauensunwürdig, bis ein anderer Knoten, sei es der Miner oder ein anderer Verifizierer, eine Teilmenge der Patricia-Knoten als Beweis der Gültigkeit bereitstellt.
@@ -480,38 +484,38 @@ Das Ethereum-Protokoll wurde ursprünglich als eine erweiterte Version einer Kry
Das Konzept einer beliebigen Statusübergangsfunktion, wie es im Ethereum-Protokoll umgesetzt ist, bietet eine Plattform mit einzigartigem Potenzial; Ethereum ist kein geschlossenes, einzweckiges Protokoll, das für einen spezifischen Anwendungsbereich in der Datenspeicherung, im Glücksspiel oder in Finanzen gedacht ist, sondern von Natur aus offen gestaltet. Wir glauben, dass es äußerst gut geeignet ist, als grundlegende Ebene für eine sehr große Anzahl sowohl finanzieller als auch nicht-finanzieller Protokolle in den kommenden Jahren zu dienen.
-## Anmerkungen und weiterführende Literatur {#notes-and-further-reading}
+## Hinweise und weiterführende Lektüre {#notes-and-further-reading}
-### Anmerkungen {#notes}
+### Hinweise {#notes}
1. Ein aufmerksamer Leser wird vielleicht feststellen, dass eine Bitcoin-Adresse in Wirklichkeit der Hash des öffentlichen Schlüssels der elliptischen Kurve und nicht der öffentliche Schlüssel selbst ist. In der Terminologie der Kryptografie ist es jedoch durchaus legitim, den Pubkey-Hash selbst als öffentlichen Schlüssel zu bezeichnen. Dies liegt daran, dass die Kryptografie von Bitcoin als ein spezifischer Algorithmus für digitale Signaturen betrachtet werden kann, bei dem der öffentliche Schlüssel aus dem Hash des ECC-Pubkeys besteht. Die Signatur besteht aus dem ECC-Pubkey verkettet mit der ECC-Signatur. Der Verifizierungsalgorithmus umfasst die Überprüfung des ECC-Pubkeys in der Signatur gegenüber dem ECC-Pubkey-Hash, der als öffentlicher Schlüssel bereitgestellt wird, und dann die Überprüfung der ECC-Signatur gegenüber dem ECC-Pubkey.
2. Technisch gesehen handelt es sich um den Median der 11 vorherigen Blöcke.
3. Intern sind sowohl 2 als auch „CHARLIE“ Zahlen[fn3](#notes), wobei „CHARLIE“ in Big-Endian zur Basis 256 dargestellt ist. Die Zahlen können mindestens 0 und höchstens 2256-1 sein.
-### Weiterführende Informationen {#further-reading}
+### Weiterführende Lektüre {#further-reading}
-1. [Intrinsischer Wert](http://bitcoinmagazine.com/8640/an-exploration-of-intrinsic-value-what-it-is-why-bitcoin-doesnt-have-it-and-why-bitcoin-does-have-it/)
+1. [Intrinsischer Wert](https://bitcoinmagazine.com/culture/an-exploration-of-intrinsic-value-what-it-is-why-bitcoin-doesnt-have-it-and-why-bitcoin-does-have-it)
2. [Smart Property](https://en.bitcoin.it/wiki/Smart_Property)
3. [Smart Contracts](https://en.bitcoin.it/wiki/Contracts)
-4. [B-Money](http://www.weidai.com/bmoney.txt)
-5. [Wiederverwendbare Proofs-of-Work](https://nakamotoinstitute.org/finney/rpow/)
-6. [Sichere Eigentumstitel mit Eigentümerautorität](https://nakamotoinstitute.org/secure-property-titles/)
-7. [Bitcoin-Whitepaper](http://bitcoin.org/bitcoin.pdf)
+4. [B-money](http://www.weidai.com/bmoney.txt)
+5. [Wiederverwendbare Proofs of Work](https://nakamotoinstitute.org/finney/rpow/)
+6. [Sichere Eigentumstitel mit Eigentümerautorität](https://nakamotoinstitute.org/library/secure-property-titles/)
+7. [Bitcoin Whitepaper](http://bitcoin.org/bitcoin.pdf)
8. [Namecoin](https://namecoin.org/)
-9. [Zookos Dreieck](https://wikipedia.org/wiki/Zooko's_triangle)
-10. [Colored Coins-Whitepaper](https://docs.google.com/a/buterin.com/document/d/1AnkP_cVZTCMLIzw4DvsW6M8Q2JC0lIzrTLuoWu2z1BE/edit)
-11. [Mastercoin-Whitepaper](https://github.com/mastercoin-MSC/spec)
-12. [Dezentralisierte autonome Corporations, Bitcoin Magazine](http://bitcoinmagazine.com/7050/bootstrapping-a-decentralized-autonomous-corporation-part-i/)
-13. [Vereinfachte Zahlungsverifizierung](https://en.bitcoin.it/wiki/Scalability#Simplified_payment_verification)
-14. [Merkle Trees](https://wikipedia.org/wiki/Merkle_tree)
-15. [Patricia Trees](https://wikipedia.org/wiki/Patricia_tree)
+9. [Zooko’s Triangle](https://wikipedia.org/wiki/Zooko's_triangle)
+10. [Colored Coins Whitepaper](https://docs.google.com/a/buterin.com/document/d/1AnkP_cVZTCMLIzw4DvsW6M8Q2JC0lIzrTLuoWu2z1BE/edit)
+11. [Mastercoin Whitepaper](https://github.com/mastercoin-MSC/spec)
+12. [Dezentralisierte autonome Gesellschaften, Bitcoin Magazine](http://bitcoinmagazine.com/7050/bootstrapping-a-decentralized-autonomous-corporation-part-i/)
+13. [Vereinfachte Zahlungsüberprüfung](https://en.bitcoin.it/wiki/Scalability#Simplified_payment_verification)
+14. [Merkle-Bäume](https://wikipedia.org/wiki/Merkle_tree)
+15. [Patricia-Bäume](https://wikipedia.org/wiki/Patricia_tree)
16. [GHOST](https://eprint.iacr.org/2013/881.pdf)
-17. [StorJ und autonome Agenten, Jeff Garzik](http://garzikrants.blogspot.ca/2013/01/storj-and-bitcoin-autonomous-agents.html)
+17. [StorJ und Autonome Agenten, Jeff Garzik](http://garzikrants.blogspot.ca/2013/01/storj-and-bitcoin-autonomous-agents.html)
18. [Mike Hearn über Smart Property beim Turing Festival](https://www.youtube.com/watch?v=MVyv4t0OKe4)
-19. [Ethereum RLP](https://web.archive.org/web/20250427212320/https://github.com/ethereum/wiki/wiki/%5BEnglish%5D-RLP)
-20. [Ethereum Merkle Patricia Trees](https://web.archive.org/web/20250427212320/https://github.com/ethereum/wiki/wiki/%5BEnglish%5D-Patricia-Tree)
-21. [Peter Todd über Merkle Sum Trees](https://web.archive.org/web/20140623061815/http://sourceforge.net/p/bitcoin/mailman/message/31709140/)
+19. [Ethereum RLP](/developers/docs/data-structures-and-encoding/rlp/)
+20. [Ethereum Merkle-Patricia-Bäume](/developers/docs/data-structures-and-encoding/patricia-merkle-trie/)
+21. [Peter Todd über Merkle-Summen-Bäume](https://web.archive.org/web/20140623061815/http://sourceforge.net/p/bitcoin/mailman/message/31709140/)
-_Informationen zur Geschichte des Whitepapers finden Sie in [diesem Wiki](https://web.archive.org/web/20250427212319/https://github.com/ethereum/wiki/blob/old-before-deleting-all-files-go-to-wiki-wiki-instead/old-whitepaper-for-historical-reference.md)._
+_Zur Geschichte des Whitepapers, siehe [dieses Wiki](https://web.archive.org/web/20250427212319/https://github.com/ethereum/wiki/blob/old-before-deleting-all-files-go-to-wiki-wiki-instead/old-whitepaper-for-historical-reference.md)._
-_Ethereum hat sich, wie viele durch die Community unterstützte Open-Source-Softwareprojekte, seit seinen Ursprüngen weiterentwickelt. Um mehr über die neuesten Entwicklungen von Ethereum zu erfahren und wie Änderungen am Protokoll vorgenommen werden, empfehlen wir [diese Anleitung](/learn/)._
+_Ethereum hat sich, wie viele durch die Community unterstützte Open-Source-Softwareprojekte, seit seinen Ursprüngen weiterentwickelt. _Um mehr über die neuesten Entwicklungen von Ethereum und darüber zu erfahren, wie Änderungen am Protokoll vorgenommen werden, empfehlen wir [diesen Leitfaden](/learn/)._
diff --git a/public/content/translations/de/wrapped-eth/index.md b/public/content/translations/de/wrapped-eth/index.md
new file mode 100644
index 00000000000..46670f6ecea
--- /dev/null
+++ b/public/content/translations/de/wrapped-eth/index.md
@@ -0,0 +1,70 @@
+---
+title: Was ist „Wrapped Ether“ (WETH)
+description: Eine Einführung in Wrapped Ether (WETH) – ein ERC20-kompatibler Wrapper für Ether (ETH).
+lang: de
+---
+
+# Wrapped Ether (WETH) {#intro-to-weth}
+
+
+
+
+Ether (ETH) ist die Hauptwährung von Ethereum. Es wird für verschiedene Zwecke verwendet, wie Staking, als Währung und zur Bezahlung von Gasgebühren für Berechnungen. **WETH ist im Grunde eine erweiterte Form von ETH mit gewisser zusätzlicher Funktionalität, die von vielen Anwendungen und [ERC-20-Token](/glossary/#erc-20)** benötigt wird, welche andere Arten von digitalen Assets auf Ethereum darstellen. Um mit diesen Token arbeiten zu können, muss ETH dieselben Regeln befolgen, auch als ERC-20-Standard bekannt.
+
+Um diese Lücke zu überbrücken, wurde Wrapped ETH (WETH) geschaffen. **Wrapped ETH ist ein Smart Contract, der es Ihnen ermöglicht, eine beliebige Menge an ETH in den Vertrag einzuzahlen und die gleiche Menge an geprägtem WETH** zu erhalten, die dem ERC-20-Token-Standard entspricht. WETH ist eine Darstellung von ETH, die es Ihnen erlaubt, damit als ERC-20-Token zu interagieren, nicht als natives Asset ETH. Sie benötigen weiterhin natives ETH, um Gasgebühren zu bezahlen. Stellen Sie also sicher, dass Sie ausreichend ETH besitzen, wenn Sie Einzahlungen vornehmen.
+
+Sie können WETH in ETH umwandeln, indem Sie den WETH-Smart Contract verwenden. Sie können eine beliebige Menge WETH mit dem WETH-Smart Contract einlösen und erhalten die gleiche Menge in ETH. Das eingezahlte WETH wird dann verbrannt und aus dem umlaufenden Angebot von WETH entfernt.
+
+**Ungefähr ~3 % des ETH-Angebots im Umlauf sind im WETH-Token-Vertrag gesperrt**, was ihn zu einem der am meisten verwendeten [Smart Contracts](/glossary/#smart-contract) macht. WETH ist besonders wichtig für Benutzer, die mit Anwendungen im Bereich der dezentralen Finanzen (DeFi) interagieren.
+
+## Warum müssen wir ETH als ERC-20 verpacken? {#why-do-we-need-to-wrap-eth}
+
+[ERC-20](/developers/docs/standards/tokens/erc-20/) definiert eine standardisierte Schnittstelle für übertragbare Token, sodass jeder Token erstellen kann, welche nahtlos mit Anwendungen und Token, die diesen Standard im Ethereum-Ökosystem verwenden, interagieren. Da **ETH älter als der ERC-20-Standard** ist, entspricht ETH nicht dieser Spezifikation. Das bedeutet, dass Sie ETH **nicht einfach** gegen andere ERC-20-Token eintauschen oder **ETH in Apps verwenden können, die den ERC-20-Standard nutzen**. Das Verpacken von ETH gibt Ihnen die Möglichkeit, Folgendes zu tun:
+
+- **ETH gegen ERC-20-Token eintauschen**: Sie können ETH nicht direkt gegen andere ERC-20-Token eintauschen. WETH ist eine Darstellung von Ether, die dem ERC-20-Fungible-Token-Standard entspricht und mit anderen ERC-20-Token getauscht werden kann.
+
+- **ETH in dApps verwenden**: Da ETH nicht ERC-20-kompatibel ist, müssten Entwickler separate Schnittstellen (eine für ETH und eine andere für ERC-20-Token) in dApps erstellen. Das Verpacken von ETH beseitigt dieses Hindernis und ermöglicht es Entwicklern, ETH und andere Token innerhalb derselben dApp zu verwalten. Viele Anwendungen für dezentrale Finanzen verwenden diesen Standard und schaffen Märkte für den Austausch dieser Token.
+
+## Wrapped Ether (WETH) und Ether (ETH): Was ist der Unterschied? {#weth-vs-eth-differences}
+
+| | **Ether (ETH)** | **Wrapped Ether (WETH)** |
+| ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angebot | Das Angebot von ETH wird durch das Ethereum-Protokoll verwaltet. Die [Ausgabe](/roadmap/merge/issuance) von ETH erfolgt durch Ethereum-Validatoren beim Verarbeiten von Transaktionen und beim Erstellen von Blöcken. | WETH ist ein ERC-20-Token, dessen Angebot durch einen Smart Contract verwaltet wird. Neue Einheiten von WETH werden durch den Vertrag ausgegeben, nachdem ETH-Einzahlungen von Benutzern eingegangen sind, oder WETH-Einheiten werden verbrannt, wenn ein Benutzer WETH gegen ETH eintauschen möchte. |
+| Eigentum | Das Eigentum wird durch das Ethereum-Protokoll über Ihr Kontoguthaben verwaltet. | Das Eigentum an WETH wird durch den Smart Contract für den WETH-Token verwaltet, der durch das Ethereum-Protokoll gesichert ist. |
+| Ressourcen | Ether (ETH) ist die akzeptierte Zahlungseinheit für Berechnungen im Ethereum-Netzwerk. Gasgebühren werden in Gwei (einer Einheit von Ether) angegeben. | Das Bezahlen von Gas mit WETH-Token wird nicht nativ unterstützt. |
+
+## Häufig gestellte Fragen {#faq}
+
+
+
+Sie zahlen Gasgebühren, um ETH mit dem WETH-Vertrag zu verpacken oder zu entpacken.
+
+
+
+
+
+WETH gilt allgemein als sicher, da es auf einem einfachen, bewährten Smart Contract basiert. Der WETH-Vertrag wurde zudem formal verifiziert, was den höchsten Sicherheitsstandard für Smart Contracts auf Ethereum darstellt.
+
+
+
+
+
+Neben der [kanonischen Implementierung von WETH](https://etherscan.io/token/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2), die auf dieser Seite beschrieben ist, gibt es auch andere Varianten. Diese können benutzerdefinierte Token sein, die von App-Entwicklern erstellt wurden, oder Versionen, die auf anderen Blockchains herausgegeben wurden, und sich unterschiedlich verhalten oder unterschiedliche Sicherheitseigenschaften haben. **Überprüfen Sie immer die Token-Informationen, um zu erfahren, mit welcher WETH-Implementierung Sie interagieren.**
+
+
+
+
+
+- [Ethereum-Mainnet](https://etherscan.io/token/0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2)
+- [Arbitrum](https://arbiscan.io/token/0x82af49447d8a07e3bd95bd0d56f35241523fbab1)
+- [Optimism](https://optimistic.etherscan.io/token/0x4200000000000000000000000000000000000006)
+
+
+
+## Weiterführende Lektüre {#further-reading}
+
+- [WTF ist WETH?](https://weth.tkn.eth.limo/)
+- [WETH-Token-Informationen auf Blockscout](https://eth.blockscout.com/token/0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2)
+- [Formale Verifizierung von WETH](https://zellic.io/blog/formal-verification-weth)
diff --git a/public/content/translations/de/zero-knowledge-proofs/index.md b/public/content/translations/de/zero-knowledge-proofs/index.md
index 54e585cd272..e96689a66d4 100644
--- a/public/content/translations/de/zero-knowledge-proofs/index.md
+++ b/public/content/translations/de/zero-knowledge-proofs/index.md
@@ -1,6 +1,6 @@
---
title: Null-Wissen-Beweise
-description: Eine nicht-technische Einführung in Null-Wissen-Beweise für Anfänger.
+description: Eine nicht-technische Einführung in Zero-Knowledge-Beweise für Anfänger.
lang: de
---
@@ -8,9 +8,9 @@ lang: de
Ein Null-Wissen-Beweis ist eine Methode, um die Gültigkeit einer Aussage zu beweisen, ohne die Aussage selbst offenzulegen. Der „Beweisanführer“ ist die Partei, die versucht, eine Aussage zu beweisen, während der „Verifizierer“ für die Validierung der Aussage verantwortlich ist.
-Null-Wissen-Beweise erschienen erstmals 1985 in einem Artikel, „[Die Wissenskomplexität von Interactive Proof Systems](http://people.csail.mit.edu/silvio/Selected%20Scientific%20Papers/Proof%20Systems/The_Knowledge_Complexity_Of_Interactive_Proof_Systems.pdf)“, der eine Definition der heute weit verbreiteten Null-Wissen-Beweise enthält:
+Zero-Knowledge-Beweise tauchten erstmals 1985 in einem Paper mit dem Titel „[The knowledge complexity of interactive proof systems](http://people.csail.mit.edu/silvio/Selected%20Scientific%20Papers/Proof%20Systems/The_Knowledge_Complexity_Of_Interactive_Proof_Systems.pdf)“ auf, das eine heute weit verbreitete Definition von Zero-Knowledge-Beweisen liefert:
-> Ein Null-Wissen-Protokoll ist eine Methode, bei der eine Partei (der Beweisführer) einer anderen Partei (dem Prüfer) **beweisen kann**, **dass etwas wahr ist, ohne dabei irgendwelche Informationen preiszugeben**, außer der Tatsache, dass diese spezifische Aussage wahr ist.
+> Ein Zero-Knowledge-Protokoll ist eine Methode, mit der eine Partei (der Beweisführer) einer anderen Partei (dem Verifizierer) **beweisen kann**, **dass etwas wahr ist, ohne irgendwelche Informationen preiszugeben**, außer der Tatsache, dass diese spezifische Aussage wahr ist.
Null-Wissen-Beweise haben sich im Laufe der Jahre verbessert und werden jetzt in mehreren realen Anwendungen eingesetzt.
@@ -22,29 +22,52 @@ Null-Wissen-Beweise stellten einen Durchbruch in der angewandten Kryptografie da
Aber es gibt Probleme mit diesem Ansatz, insbesondere dem Mangel an Privatsphäre. Persönlich identifizierbare Informationen (PII), die mit Drittanbieterdiensten geteilt werden, werden in zentralen Datenbanken gespeichert, die anfällig für Hacks sind. Da Identitätsdiebstahl zu einem ernsthaften Problem geworden ist, werden die Forderungen nach stärkeren Methoden zum Schutz der Privatsphäre bei der Weitergabe sensibler Informationen lauter.
-Null-Wissen-Beweise lösen dieses Problem, indem sie **die Notwendigkeit abschaffen, Informationen für den Beweis der Gültigkeit von Informationen zu offenbaren**. Das Null-Wissen-Protokoll betrachtet die Aussage (als „Zeuge“ bezeichnet) als Eingabe und generiert damit einen prägnanten Gültigkeitsbeweis. Dieser Beweis bietet starke Garantien dafür, dass eine Aussage wahr ist, ohne die Informationen offenzulegen, die zu ihrer Erstellung verwendet wurden.
+Zero-Knowledge-Beweise lösen dieses Problem, indem sie **die Notwendigkeit beseitigen, Informationen preiszugeben, um die Gültigkeit von Behauptungen zu beweisen**. Das Null-Wissen-Protokoll betrachtet die Aussage (als „Zeuge“ bezeichnet) als Eingabe und generiert damit einen prägnanten Gültigkeitsbeweis. Dieser Beweis bietet starke Garantien dafür, dass eine Aussage wahr ist, ohne die Informationen offenzulegen, die zu ihrer Erstellung verwendet wurden.
Zurück zu unserem vorherigen Beispiel: Der einzige Beweis, den Sie benötigen, um Ihren Anspruch zu beweisen, dass sie eine bestimmte Staatsangehörigkeit haben, ist ein Null-Wissen-Beweis. Der Verifizierer muss nur prüfen, ob bestimmte Eigenschaften des Beweises zutreffen, um sich davon zu überzeugen, dass die zugrunde liegende Aussage auch zutrifft.
-## Anwendungsfälle für Null-Wissen-Beweise {#use-cases-for-zero-knowledge-proofs}
+## Anwendungsfälle für Zero-Knowledge-Beweise {#use-cases-for-zero-knowledge-proofs}
### Anonyme Zahlungen {#anonymous-payments}
Kreditkartenzahlungen sind oft für mehrere Parteien sichtbar, einschließlich des Zahlungsanbieters, Banken und anderer interessierter Parteien (z. B. Regierungsbehörden). Obwohl die finanzielle Überwachung Vorteile hat, um illegale Aktivitäten zu identifizieren, untergräbt sie auch die Privatsphäre gewöhnlicher Bürger.
-Kryptowährungen sollten Benutzern ermöglichen, private Transaktionen zwischen Gleichgesinnten durchzuführen. Die meisten Kryptowährungstransaktionen sind jedoch auf öffentlichen Blockchains für jeden sichtbar. Benutzeridentitäten sind oft pseudonym und entweder absichtlich mit realen Identitäten verknüpft (z. B. indem ETH-Adressen in Twitter- oder GitHub-Profilen aufgenommen werden) oder können durch grundlegende On- und Off-Rhein-Datenanalyse mit realen Identitäten in Verbindung gebracht werden.
+Kryptowährungen sollten Benutzern ermöglichen, private Transaktionen zwischen Gleichgesinnten durchzuführen. Die meisten Kryptowährungstransaktionen sind jedoch auf öffentlichen Blockchains für jeden sichtbar. Benutzeridentitäten sind oft pseudonym und werden entweder absichtlich mit realen Identitäten verknüpft (z. B. durch die Angabe von ETH-Adressen in Twitter- oder GitHub-Profilen) oder können mithilfe einfacher On- und Off-Chain-Datenanalysen mit realen Identitäten in Verbindung gebracht werden.
Es gibt spezielle „Privatsphäre-Münzen“, die für vollständig anonyme Transaktionen entwickelt wurden. Datenschutzorientierte Blockchains wie Zcash und Monero schützen Transaktionsdetails, einschließlich Sender-/Empfängeradressen, Asset-Typ, Menge und den Transaktionszeitplan.
-Durch die Integration von Null-Wissen-Technologie in das Protokoll ermöglichen Datenschutz-fokussierte [Blockchain](/glossary/#blockchain)-Netzwerke den [Knoten](/glossary/#node), Transaktionen zu validieren, ohne Transaktionsdaten einsehen zu müssen.
+Durch das Einbetten von Zero-Knowledge-Technologie in das Protokoll ermöglichen datenschutzorientierte [Blockchain](/glossary/#blockchain)-Netzwerke, dass [Nodes](/glossary/#node) Transaktionen validieren, ohne auf Transaktionsdaten zugreifen zu müssen. [EIP-7503](https://eips.ethereum.org/EIPS/eip-7503) ist ein Beispiel für einen vorgeschlagenen Entwurf, der native private Wertübertragungen auf der Ethereum-Blockchain ermöglichen wird. Aufgrund einer Mischung aus Sicherheits-, Regulierungs- und UX-Bedenken sind solche Vorschläge jedoch schwer umzusetzen.
-**Null-Wissen-Beweise werden auch angewandt, um Transaktionen auf öffentlichen Blockchains zu anonymisieren**. Ein Beispiel ist Tornado Cash, ein dezentraler, nicht depotführender Dienst, der es Benutzern ermöglicht, private Transaktionen auf Ethereum durchzuführen. Tornado Cash verwendet Null-Wissen-Beweise, um Transaktionsdetails zu verschleiern und die finanzielle Privatsphäre zu gewährleisten. Da es sich hierbei um „Opt-in“-Datenschutz-Tools handelt, werden sie leider mit illegalen Aktivitäten in Verbindung gebracht. Um dies zu überwinden, muss der Datenschutz schließlich zum Standard auf öffentlichen Blockchains werden.
+**Null-Wissen-Beweise werden auch angewandt, um Transaktionen auf öffentlichen Blockchains zu anonymisieren**. Ein Beispiel ist Tornado Cash, ein dezentraler, nicht depotführender Dienst, der es Benutzern ermöglicht, private Transaktionen auf Ethereum durchzuführen. Tornado Cash verwendet Null-Wissen-Beweise, um Transaktionsdetails zu verschleiern und die finanzielle Privatsphäre zu gewährleisten. Da es sich hierbei um „Opt-in“-Datenschutz-Tools handelt, werden sie leider mit illegalen Aktivitäten in Verbindung gebracht. Um dies zu überwinden, muss der Datenschutz schließlich zum Standard auf öffentlichen Blockchains werden. Erfahre mehr über [Datenschutz auf Ethereum](/privacy/).
### Identitätsschutz {#identity-protection}
Aktuelle Identitätsmanagementsysteme setzen persönliche Informationen einem Risiko aus. Null-Wissen-Beweise können Einzelpersonen dabei helfen, Identitäten zu validieren und gleichzeitig vertrauliche Details zu schützen.
-Null-Wissen-Beweise sind besonders nützlich im Zusammenhang mit [dezentraler Identität](/decentralized-identity/). Dezentralisierte Identität (auch als „selbstbestimmte Identität“ bezeichnet) gibt dem Individuum die Möglichkeit, den Zugriff auf persönliche Identifikatoren zu kontrollieren. Die Möglichkeit, seine Staatsbürgerschaft nachzuweisen, ohne seine Steuer-ID oder Passdetails preiszugeben, ist ein gutes Beispiel dafür, wie die Null-Wissen-Technologie eine dezentralisierte Identität ermöglicht.
+Zero-Knowledge-Beweise sind besonders nützlich im Kontext der [dezentralen Identität](/decentralized-identity/). Dezentralisierte Identität (auch als „selbstbestimmte Identität“ bezeichnet) gibt dem Individuum die Möglichkeit, den Zugriff auf persönliche Identifikatoren zu kontrollieren. Die Möglichkeit, seine Staatsbürgerschaft nachzuweisen, ohne seine Steuer-ID oder Passdetails preiszugeben, ist ein gutes Beispiel dafür, wie die Null-Wissen-Technologie eine dezentralisierte Identität ermöglicht.
+
+
+
+
+ ZKP + Identität in Aktion: Bhutan National Digital ID (NDI) auf Ethereum
+
+
+
+ Ein reales Beispiel für die Verwendung von ZKP für Identitätsmanagementsysteme ist das National Digital ID (NDI)-System des Königreichs Bhutan, das auf Ethereum aufbaut. Bhutans NDI verwendet ZKPs, um es den Bürgern zu ermöglichen, Fakten über sich selbst kryptografisch zu beweisen, wie z. B. \"Ich bin Staatsbürger\" oder \"Ich bin über 18\", ohne die sensiblen persönlichen Daten auf ihrem Ausweis preiszugeben.
+
+
+ Erfahre mehr über Bhutan NDI in der Fallstudie zur dezentralen Identität.
+
+
+
+
+
+### Proof of Humanity {#proof-of-humanity}
+
+Eines der heute am häufigsten verwendeten Beispiele für Zero-Knowledge-Beweise in Aktion ist das [World ID protocol](https://world.org/blog/world/world-id-faqs), das man sich als „einen globalen digitalen Pass für das Zeitalter der KI“ vorstellen kann. Es ermöglicht Menschen, ihre Identität als einzigartige Individuen nachzuweisen, ohne persönliche Informationen preiszugeben. Dies wird durch ein Gerät namens „ORB“ erreicht, das die Iris einer Person scannt und einen Iris code generiert. Der Iris code wird überprüft und verifiziert, um zu bestätigen, dass es sich bei der Person um einen biologisch einzigartigen Menschen handelt. Nach der Überprüfung wird eine auf dem Gerät des Benutzers generierte Identitätszusage (die nicht mit den biometrischen Daten verknüpft oder daraus abgeleitet ist) zu einer sicheren Liste in der Blockchain hinzugefügt. Wenn der Benutzer dann nachweisen möchte, dass er ein verifizierter Mensch ist – sei es bei der Anmeldung, beim Abstimmen oder bei anderen Aktionen – kann er einen Zero-Knowledge-Beweis generieren, der seine Mitgliedschaft in der Liste bestätigt. Das Schöne an der Verwendung eines Zero Knowledge Beweises ist, dass nur eine Aussage offengelegt wird: Diese Person ist einzigartig. Alles andere bleibt privat.
+
+World ID stützt sich auf das [Semaphore protocol](https://docs.semaphore.pse.dev/), das vom [PSE team](https://pse.dev/) bei der Ethereum Foundation entwickelt wurde. Semaphore ist als einfache und dennoch leistungsstarke Methode zum Generieren und Überprüfen von Zero Knowledge Beweisen konzipiert. Damit können Benutzer nachweisen, dass sie Teil einer Gruppe sind (in diesem Fall verifizierte Menschen), ohne zu zeigen, welches Mitglied der Gruppe sie sind. Semaphore ist außerdem äußerst flexibel und ermöglicht die Erstellung von Gruppen auf Grundlage einer Vielzahl von Kriterien wie Identitätsprüfung, Teilnahme an Veranstaltungen oder Besitz von Anmeldeinformationen.
### Authentifizierung {#authentication}
@@ -56,11 +79,11 @@ Null-Wissen-Beweise können jedoch die Authentifizierung sowohl für Plattformen
Verifizierbare Berechnung ist eine weitere Anwendung der Null-Wissen-Technologie zur Verbesserung des Blockchain Designs. Verifizierbare Berechnung ermöglicht es uns, Berechnungen an eine andere Einheit auszulagern, während wir verifizierbare Ergebnisse aufrechterhalten. Die Entität reicht das Ergebnis zusammen mit einem Beweis ein, der bestätigt, dass das Programm korrekt ausgeführt wurde.
-Nachweisbare Berechnung ist **ausschlaggebend, um Bearbeitungszeiten auf Blockchains zu verbessern**, ohne bei der Sicherheit Kompromisse eingehen zu müssen. Um dies zu verstehen, müssen Sie die Unterschiede in den vorgeschlagenen Lösungen für die Skalierung von Ethereum kennen.
+Verifizierbare Berechnung ist **entscheidend für die Verbesserung der Verarbeitungsgeschwindigkeiten auf Blockchains**, ohne die Sicherheit zu verringern. Um dies zu verstehen, müssen Sie die Unterschiede in den vorgeschlagenen Lösungen für die Skalierung von Ethereum kennen.
-[On-Chain-Skalierungslösungen](/developers/docs/scaling/#on-chain-scaling), wie z. B. Sharding, erfordern umfangreiche Modifikationen der Basisschicht der Blockchain. Dieser Ansatz ist jedoch sehr komplex und Fehler bei der Implementierung können das Sicherheitsmodell von Ethereum untergraben.
+[On-Chain-Skalierungslösungen](/developers/docs/scaling/#onchain-scaling) wie Sharding erfordern eine umfassende Änderung der Basisschicht der Blockchain. Dieser Ansatz ist jedoch sehr komplex und Fehler bei der Implementierung können das Sicherheitsmodell von Ethereum untergraben.
-[Off-Chain-Skalierungslösungen](/developers/docs/scaling/#off-chain-scaling) erfordern keine Neugestaltung des Ethereum-Kernprotokolls. Stattdessen setzen sie auf ein Outsourcing-Computing-Modell, um die Durchsatzrate auf der Basisschicht von Ethereum zu verbessern.
+[Off-Chain-Skalierungslösungen](/developers/docs/scaling/#offchain-scaling) erfordern keine Neugestaltung des Kernprotokolls von Ethereum. Stattdessen setzen sie auf ein Outsourcing-Computing-Modell, um die Durchsatzrate auf der Basisschicht von Ethereum zu verbessern.
So funktioniert das in der Praxis:
@@ -68,49 +91,49 @@ So funktioniert das in der Praxis:
- Nach der Verarbeitung der Transaktionen gibt die andere Kette die Ergebnisse zurück, die auf den Zustand von Ethereum angewendet werden sollen.
-Der Vorteil hierbei ist, dass Ethereum keine Ausführung durchführen muss und nur Ergebnisse aus der ausgelagerten Berechnung auf seinen Status anwenden muss. Das reduziert Netzwerkstaus und verbessert auch die Transaktionsgeschwindigkeiten (Off-Chain-Protokolle sind darauf optimiert, eine schnellere Ausführung zu ermöglichen).
+Der Vorteil hierbei ist, dass Ethereum keine Ausführung durchführen muss und nur Ergebnisse aus der ausgelagerten Berechnung auf seinen Status anwenden muss. Dies reduziert die Netzwerküberlastung und verbessert auch die Transaktionsgeschwindigkeit (Offchain Protokolle optimieren für eine schnellere Ausführung).
-Die Blockchain benötigt eine Möglichkeit, Off-Chain-Transaktionen zu validieren, ohne sie erneut auszuführen, sonst geht der Vorteil der Off-Chain-Ausführung verloren.
+Die Kette benötigt eine Möglichkeit, Offchain Transaktionen zu validieren, ohne sie erneut auszuführen, da sonst der Wert der Offchain Ausführung verloren geht.
-Hier kommt verifizierbare Berechnung ins Spiel. Wenn ein Node außerhalb von Ethereum eine Transaktion ausführt, sendet er einen Null-Wissen-Beweis, um die Korrektheit der Off-Chain-Ausführung zu beweisen. Dieser Beweis (als [Gültigkeitsnachweis](/glossary/#validity-proof) bezeichnet) garantiert, dass eine Transaktion gültig ist, und ermöglicht es Ethereum, das Ergebnis auf ihren Zustand anzuwenden – ohne darauf zu warten, dass jemand dies anzweifelt.
+Hier kommt verifizierbare Berechnung ins Spiel. Wenn ein Knoten eine Transaktion außerhalb von Ethereum ausführt, übermittelt er einen Zero-Knowledge-Beweis, um die Richtigkeit der Offchain Ausführung nachzuweisen. Dieser Beweis (ein sogenannter [Gültigkeitsnachweis](/glossary/#validity-proof)) garantiert, dass eine Transaktion gültig ist, und ermöglicht es Ethereum, das Ergebnis auf seinen Zustand anzuwenden – ohne darauf zu warten, dass jemand ihn anficht.
-[Null-Wissen-Rollups](/developers/docs/scaling/zk-rollups) und [Validiums](/developers/docs/scaling/validium/) sind zwei Skalierungslösungen außerhalb der Blockchain, die Gültigkeitsnachweise verwenden, um eine sichere Skalierbarkeit zu ermöglichen. Diese Protokolle führen tausende von Transaktionen außerhalb von Ethereum aus und reichen Nachweise zur Überprüfung auf Ethereum ein. Sobald der Nachweis verifiziert ist, können diese Ergebnisse sofort angewendet werden, was Ethereum ermöglicht, mehr Transaktionen zu verarbeiten, ohne die Berechnung auf der Basisschicht zu erhöhen.
+[Zero-Knowledge-Rollups](/developers/docs/scaling/zk-rollups) und [Validiums](/developers/docs/scaling/validium/) sind zwei Off-Chain-Skalierungslösungen, die Gültigkeitsnachweise verwenden, um eine sichere Skalierbarkeit zu gewährleisten. Diese Protokolle führen Tausende von Transaktionen außerhalb der Kette aus und übermitteln Beweise zur Überprüfung an Ethereum. Sobald der Nachweis verifiziert ist, können diese Ergebnisse sofort angewendet werden, was Ethereum ermöglicht, mehr Transaktionen zu verarbeiten, ohne die Berechnung auf der Basisschicht zu erhöhen.
-### Verringerung von Bestechung und Kollusion bei On-Chain-Abstimmungen {#secure-blockchain-voting}
+### Reduzierung von Bestechung und Kollusion bei On-Chain-Abstimmungen {#secure-blockchain-voting}
-Blockchain-Abstimmungssysteme haben viele vorteilhafte Eigenschaften: Sie sind vollständig überprüfbar, sicher gegen Angriffe, widerstandsfähig gegen Zensur und frei von geografischen Einschränkungen. Aber selbst On-Chain-Wahlsysteme sind nicht immun gegen das Problem der **Absprachen**.
+Blockchain-Abstimmungssysteme haben viele vorteilhafte Eigenschaften: Sie sind vollständig überprüfbar, sicher gegen Angriffe, widerstandsfähig gegen Zensur und frei von geografischen Einschränkungen. Aber selbst On-Chain-Abstimmungssysteme sind nicht immun gegen das Problem der **Kollusion**.
-Definiert als „Koordinierung zur Begrenzung offener Konkurrenz durch Täuschung, Betrug und Irreführung anderer“ kann Kollusion in Form eines bösartigen Akteurs auftreten, der die Abstimmung durch Angebot von Bestechungsgeldern beeinflusst. Zum Beispiel könnte Alice Bestechungsgelder von Bob erhalten, um auf einem Stimmzettel für `Option B` zu stimmen, selbst wenn sie `Option A` bevorzugt.
+Definiert als „Koordinierung zur Begrenzung offener Konkurrenz durch Täuschung, Betrug und Irreführung anderer“ kann Kollusion in Form eines bösartigen Akteurs auftreten, der die Abstimmung durch Angebot von Bestechungsgeldern beeinflusst. Zum Beispiel könnte Alice von Bob bestochen werden, um bei einer Abstimmung für `option B` zu stimmen, obwohl sie `option A` bevorzugt.
Bestechung und Kollusion beschränken die Effektivität jedes Prozesses, der Abstimmung als Signalisierungsmechanismus verwendet (insbesondere dort, wo Benutzer beweisen können, wie sie abgestimmt haben). Dies kann erhebliche Auswirkungen haben, insbesondere wenn die Abstimmungen für die Zuteilung knapper Ressourcen verantwortlich sind.
-Zum Beispiel verlassen sich [quadratische Finanzierungsmechanismen](https://www.radicalxchange.org/concepts/plural-funding/) auf Spenden, um die Präferenz für bestimmte Optionen unter verschiedenen öffentlichen Wohlfahrtsprojekten zu messen. Jede Spende zählt als „Stimme“ für ein bestimmtes Projekt, wobei Projekte, die mehr Stimmen erhalten, mehr Gelder aus dem Matching-Pool erhalten.
+Zum Beispiel stützen sich [quadratische Finanzierungsmechanismen](https://www.radicalxchange.org/wiki/plural-funding/) auf Spenden, um die Präferenz für bestimmte Optionen bei verschiedenen Projekten für öffentliche Güter zu messen. Jede Spende zählt als „Stimme“ für ein bestimmtes Projekt, wobei Projekte, die mehr Stimmen erhalten, mehr Gelder aus dem Matching-Pool erhalten.
-Die Verwendung von On-Chain-Abstimmungen macht quadratische Finanzierungen anfällig für Absprachen: Blockchain-Transaktionen sind öffentlich, sodass Bestechungsgelder die On-Chain-Aktivitäten eines Bestechungsgeldes überprüfen können, um zu sehen, wie sie „abgestimmt“ haben. Auf diese Weise ist die quadratische Finanzierung kein effektives Mittel mehr, um Gelder auf der Grundlage der aggregierten Präferenzen der Gemeinschaft zuzuweisen.
+Durch die Verwendung von Offchain Voting ist die quadratische Finanzierung anfällig für Absprachen: Blockchain-Transaktionen sind öffentlich, sodass bestecher die Offchain Aktivitäten eines Bestechlichen überprüfen können, um zu sehen, wie dieser „abgestimmt“ hat. Auf diese Weise ist die quadratische Finanzierung kein effektives Mittel mehr, um Gelder auf der Grundlage der aggregierten Präferenzen der Gemeinschaft zuzuweisen.
-Glücklicherweise verwenden neuere Lösungen wie MACI (Minimum Anti-Collusion Infrastructure) Null-Wissen-Beweise, um On-Chain-Abstimmungen (z. B. quadratische Finanzierungsmechanismen) widerstandsfähig gegen Bestechung und Absprachen zu machen. MACI ist eine Reihe von intelligenten Verträgen und Skripten, die es einem zentralen Administrator (als „Koordinator“ bezeichnet) ermöglichen, Stimmen zusammenzufassen und Ergebnisse zu zählen, _ohne_ Einzelheiten darüber preiszugeben, wie jeder Einzelne abgestimmt hat. Trotzdem ist es immer noch möglich zu überprüfen, ob die Stimmen korrekt gezählt wurden, oder zu bestätigen, dass eine bestimmte Person an der Abstimmungsrunde teilgenommen hat.
+Glücklicherweise verwenden neuere Lösungen wie MACI (Minimum Anti-Collusion Infrastructure) Zero-Knowledge-Beweise, um On-Chain-Abstimmungen (z. B. quadratische Finanzierungsmechanismen) resistent gegen Bestechung und Kollusion zu machen. MACI ist ein Satz von Smart Contracts und Skripten, die es einem zentralen Administrator (genannt \"Koordinator\") ermöglichen, Stimmen zu sammeln und Ergebnisse zusammenzuzählen, _ohne_ Details darüber preiszugeben, wie jede einzelne Person abgestimmt hat. Trotzdem ist es immer noch möglich zu überprüfen, ob die Stimmen korrekt gezählt wurden, oder zu bestätigen, dass eine bestimmte Person an der Abstimmungsrunde teilgenommen hat.
#### Wie arbeitet MACI mit Null-Wissen-Beweisen? {#how-maci-works-with-zk-proofs}
-Zu Beginn stellt der Koordinator den MACI-Vertrag auf Ethereum bereit, danach können sich Benutzer für die Abstimmung anmelden (indem sie ihren öffentlichen Schlüssel im Smart Contract registrieren). Benutzer geben Stimmen ab, indem sie mit ihrem öffentlichen Schlüssel verschlüsselte Nachrichten an den Smart Contract senden (eine gültige Stimme muss unter anderem mit dem neuesten öffentlichen Schlüssel signiert werden, der mit der Identität des Benutzers verknüpft ist). Anschließend verarbeitet der Koordinator alle Nachrichten nach Ablauf der Abstimmungsperiode, zählt die Stimmen aus und verifiziert die Ergebnisse in der Kette.
+Zu Beginn stellt der Koordinator den MACI-Vertrag auf Ethereum bereit, danach können sich Benutzer für die Abstimmung anmelden (indem sie ihren öffentlichen Schlüssel im Smart Contract registrieren). Benutzer geben Stimmen ab, indem sie mit ihrem öffentlichen Schlüssel verschlüsselte Nachrichten an den Smart Contract senden (eine gültige Stimme muss unter anderem mit dem neuesten öffentlichen Schlüssel signiert werden, der mit der Identität des Benutzers verknüpft ist). Anschließend verarbeitet der Koordinator nach Ablauf der Abstimmungsphase alle Nachrichten, zählt die Stimmen und überprüft die Ergebnisse in der Kette.
-Bei MACI werden Null-Wissen-Beweise verwendet, um die Korrektheit der Berechnung sicherzustellen, indem es dem Koordinator unmöglich gemacht wird, Stimmen falsch zu verarbeiten und Ergebnisse auszuwerten. Dies wird erreicht, indem der Koordinator aufgefordert wird, ZK-SNARK-Beweise zu erstellen, die verifizieren, dass a) alle Nachrichten korrekt verarbeitet wurden, b) das Endergebnis der Summe aller _gültigen_ Stimmen entspricht.
+Bei MACI werden Null-Wissen-Beweise verwendet, um die Korrektheit der Berechnung sicherzustellen, indem es dem Koordinator unmöglich gemacht wird, Stimmen falsch zu verarbeiten und Ergebnisse auszuwerten. Dies wird erreicht, indem der Koordinator ZK-SNARK-Beweise erstellen muss, die verifizieren, dass a) alle Nachrichten korrekt verarbeitet wurden und b) das Endergebnis der Summe aller _gültigen_ Stimmen entspricht.
Somit garantiert MACI auch ohne eine Aufschlüsselung der Stimmen pro Benutzer (wie es normalerweise der Fall ist) die Integrität der Ergebnisse, die während des Auszählungsprozesses berechnet werden. Dieses Merkmal ist nützlich, um die Effektivität grundlegender geheimer Absprachen zu reduzieren. Wir können diese Möglichkeit untersuchen, indem wir das vorherige Beispiel von Bob verwenden, der Alice besticht, um für eine Option zu stimmen:
- Alice registriert sich für die Abstimmung, indem sie ihren öffentlichen Schlüssel an einen Smart Contract sendet.
-- Alice willigt ein, für `Option B` zu stimmen, im Austausch für ein Bestechungsgeld von Bob.
-- Alice stimmt für `Option B`.
+- Alice willigt ein, im Austausch für eine Bestechung von Bob für `option B` zu stimmen.
+- Alice stimmt für `option B`.
- Alice sendet heimlich eine verschlüsselte Transaktion, um den öffentlichen Schlüssel zu ändern, der ihrer Identität zugeordnet ist.
-- Alice sendet eine weitere (verschlüsselte) Nachricht an den Smart Contract, der für `Option A` abstimmt, unter Verwendung des neuen öffentlichen Schlüssels.
-- Alice zeigt Bob eine Transaktion, aus der hervorgeht, dass sie für `Option B` gestimmt hat (was ungültig ist, da der öffentliche Schlüssel nicht mehr mit Alices Identität im System verknüpft ist)
-- Während der Verarbeitung von Nachrichten überspringt der Koordinator Alices Stimme für `Option B` und zählt nur die Stimme für `Option A`. Daher schlägt Bobs Versuch fehl, mit Alice zusammenzuarbeiten und die Abstimmung in der Kette zu manipulieren.
+- Alice sendet eine weitere (verschlüsselte) Nachricht an den Smart Contract, um mit dem neuen öffentlichen Schlüssel für `option A` zu stimmen.
+- Alice zeigt Bob eine Transaktion, die belegt, dass sie für `option B` gestimmt hat (was ungültig ist, da der öffentliche Schlüssel nicht mehr mit Alices Identität im System verknüpft ist).
+- Während der Verarbeitung der Nachrichten überspringt der Koordinator Alices Stimme für `option B` und zählt nur die Stimme für `option A`. Daher scheitert Bobs Versuch, mit Alice zu kollaborieren und die Offchain Abstimmung zu manipulieren.
-Die Verwendung von MACI _erfordert_ das Vertrauen in den Koordinator, dass er sich nicht mit Bestechern zusammentut oder selbst versucht, Wähler zu bestechen. Der Koordinator kann Benutzernachrichten entschlüsseln (notwendig für die Erstellung des Beweises), damit er genau überprüfen kann, wie jede Person abgestimmt hat.
+Die Verwendung von MACI erfordert _jedoch_ das Vertrauen, dass der Koordinator nicht mit Bestechenden konspiriert oder selbst versucht, Wähler zu bestechen. Der Koordinator kann Benutzernachrichten entschlüsseln (notwendig für die Erstellung des Beweises), damit er genau überprüfen kann, wie jede Person abgestimmt hat.
-Aber in Fällen, in denen der Koordinator ehrlich bleibt, stellt MACI ein mächtiges Werkzeug dar, um die Unversehrtheit der Abstimmung in der Kette zu gewährleisten. Dies erklärt seine Beliebtheit bei quadratischen Finanzierungsanträgen (z. B. [clr.fund](https://clr.fund/#/about/maci)), die sich stark auf die Integrität der Abstimmungsentscheidungen jedes Einzelnen verlassen.
+Aber in Fällen, in denen der Koordinator ehrlich bleibt, stellt MACI ein mächtiges Werkzeug dar, um die Unantastbarkeit der Offchain Abstimmung zu gewährleisten. Dies erklärt seine Beliebtheit bei Anwendungen für quadratische Finanzierung (z.B. [clr.fund](https://clr.fund/#/about/maci)), die stark von der Integrität der Wahlentscheidungen jedes Einzelnen abhängen.
-[Erfahren Sie mehr über MACI](https://maci.pse.dev/).
+[Erfahre mehr über MACI](https://maci.pse.dev/).
## Wie funktionieren Null-Wissen-Beweise? {#how-do-zero-knowledge-proofs-work}
@@ -118,29 +141,29 @@ Ein Null-Wissen-Beweis ermöglicht es Ihnen, die Wahrheit einer Aussage zu bewei
Ein Null-Wissen-Protokoll muss folgende Kriterien erfüllen:
-1. **Vollständigkeit**: Wenn die Eingabe gültig ist, gibt das Null-Wissen-Protokoll immer „wahr“ zurück. Wenn also die zugrunde liegende Aussage wahr ist und der Beweisführer und der Verifizierer ehrlich handeln, kann der Beweis akzeptiert werden.
+1. **Vollständigkeit**: Wenn die Eingabe gültig ist, gibt das Zero-Knowledge-Protokoll immer „wahr“ zurück. Wenn also die zugrunde liegende Aussage wahr ist und der Beweisführer und der Verifizierer ehrlich handeln, kann der Beweis akzeptiert werden.
-2. **Zuverlässigkeit**: Wenn der Eingabewert ungültig ist, ist es theoretisch unmöglich, das Null-Wissen-Protokoll zu täuschen, um „wahr“ zurückzugeben. Daher kann ein lügender Beweisführer einen ehrlichen Verifizierer nicht dazu bringen, zu glauben, dass eine ungültige Aussage gültig ist (außer mit einem winzigen Wahrscheinlichkeitsspielraum).
+2. **Korrektheit**: Wenn die Eingabe ungültig ist, ist es theoretisch unmöglich, das Zero-Knowledge-Protokoll dazu zu bringen, „wahr“ zurückzugeben. Daher kann ein lügender Beweisführer einen ehrlichen Verifizierer nicht dazu bringen, zu glauben, dass eine ungültige Aussage gültig ist (außer mit einem winzigen Wahrscheinlichkeitsspielraum).
-3. **Null-Wissen**: Der Verifizierer erfährt nichts über eine Aussage außer deren Gültigkeit oder Falschheit (sie haben „Null-Wissen“ über die Aussage). Diese Anforderung hindert den Verifizierer auch daran, die ursprüngliche Eingabe (den Inhalt der Aussage) aus dem Beweis abzuleiten.
+3. **Zero-Knowledge**: Der Verifizierer erfährt nichts über eine Aussage über ihre Gültigkeit oder Falschheit hinaus (er hat „Zero-Knowledge“ über die Aussage). Diese Anforderung hindert den Verifizierer auch daran, die ursprüngliche Eingabe (den Inhalt der Aussage) aus dem Beweis abzuleiten.
-In der Grundform besteht ein Null-Wissen-Beweis aus drei Elementen: **Zeuge**, **Herausforderung** und **Antwort**.
+In seiner Grundform besteht ein Zero-Knowledge-Beweis aus drei Elementen: **Zeuge**, **Herausforderung** und **Antwort**.
-- **Zeuge**: Mit einem Null-Wissen-Beweis möchte der Beweisführer die Kenntnis einiger verborgener Informationen beweisen. Die geheimen Informationen sind der „Zeuge“ für den Beweis, und die angenommene Kenntnis des Beweisführers über den Zeugen stellt eine Reihe von Fragen auf, die nur von einer Partei mit Kenntnis der Informationen beantwortet werden können. Somit beginnt der Beweisführer den Beweisprozess, indem er zufällig eine Frage auswählt, die Antwort berechnet und sie an den Prüfer sendet.
+- **Zeuge**: Mit einem Zero-Knowledge-Beweis möchte der Beweisführer Kenntnisse über einige verborgene Informationen nachweisen. Die geheimen Informationen sind der „Zeuge“ für den Beweis, und die angenommene Kenntnis des Beweisführers über den Zeugen stellt eine Reihe von Fragen auf, die nur von einer Partei mit Kenntnis der Informationen beantwortet werden können. Somit beginnt der Beweisführer den Beweisprozess, indem er zufällig eine Frage auswählt, die Antwort berechnet und sie an den Prüfer sendet.
-- **Herausforderung**: Der Prüfer wählt zufällig eine andere Frage aus dem Satz aus und bittet den Beweisführer, sie zu beantworten.
+- **Herausforderung**: Der Verifizierer wählt zufällig eine weitere Frage aus der Menge aus und bittet den Beweisführer, sie zu beantworten.
-- **Antwort**: Der Beweisführer akzeptiert die Frage, berechnet die Antwort und sendet sie an den Prüfer zurück. Die Antwort des Beweisführers ermöglicht es dem Prüfer, zu überprüfen, ob ersterer wirklich Zugang zu dem Zeugen hat. Um sicherzustellen, dass der Beweisführer nicht blind rät und die richtigen Antworten zufällig erhält, wählt der Prüfer mehr Fragen aus, die er stellen möchte. Indem diese Interaktion viele Male wiederholt wird, sinkt die Wahrscheinlichkeit, dass der Beweisführer Wissen über den Zeugen vortäuscht, signifikant, bis der Prüfer zufrieden ist.
+- **Antwort**: Der Beweisführer nimmt die Frage an, berechnet die Antwort und gibt sie an den Verifizierer zurück. Die Antwort des Beweisführers ermöglicht es dem Prüfer, zu überprüfen, ob ersterer wirklich Zugang zu dem Zeugen hat. Um sicherzustellen, dass der Beweisführer nicht blind rät und die richtigen Antworten zufällig erhält, wählt der Prüfer mehr Fragen aus, die er stellen möchte. Indem diese Interaktion viele Male wiederholt wird, sinkt die Wahrscheinlichkeit, dass der Beweisführer Wissen über den Zeugen vortäuscht, signifikant, bis der Prüfer zufrieden ist.
Das Obige beschreibt die Struktur eines „interaktiven Null-Wissen-Beweises“. Frühe Null-Wissen-Protokolle verwendeten interaktive Beweise, bei denen die Überprüfung der Gültigkeit einer Aussage eine hin- und hergehende Kommunikation zwischen Beweisführern und Verifizierern erforderte.
-Ein gutes Beispiel dafür, wie interaktive Beweise funktionieren, ist die berühmte [Höhlengeschichte Ali Baba](https://en.wikipedia.org/wiki/Zero-knowledge_proof#The_Ali_Baba_cave) von Jean-Jacques Quisquater. In der Geschichte will Peggy (die Beweisführerin) Victor (dem Prüfer) beweisen, dass sie den geheimen Satz kennt, um eine magische Tür zu öffnen, ohne den Satz preiszugeben.
+Ein gutes Beispiel, das veranschaulicht, wie interaktive Beweise funktionieren, ist die berühmte [Ali-Baba-Höhlengeschichte](https://en.wikipedia.org/wiki/Zero-knowledge_proof#The_Ali_Baba_cave) von Jean-Jacques Quisquater. In der Geschichte will Peggy (die Beweisführerin) Victor (dem Prüfer) beweisen, dass sie den geheimen Satz kennt, um eine magische Tür zu öffnen, ohne den Satz preiszugeben.
-### Nicht-interaktive Null-Wissen-Beweise {#non-interactive-zero-knowledge-proofs}
+### Nicht-interaktive Zero-Knowledge-Beweise {#non-interactive-zero-knowledge-proofs}
Während die interaktive Prüfung revolutionär war, hatte sie nur begrenzten Nutzen, da sie erforderte, dass die beiden Parteien verfügbar waren und wiederholt interagierten. Selbst wenn ein Verifizierer von der Ehrlichkeit eines Beweisführers überzeugt wäre, wäre der Beweis für eine unabhängige Verifizierung nicht verfügbar (die Berechnung eines neuen Beweises erforderte einen neuen Satz von Nachrichten zwischen dem Beweisführer und dem Verifizierer).
-Um dieses Problem zu lösen, schlugen Manuel Blum, Paul Feldman und Silvio Micali die ersten [nicht-interaktiven Null-Wissen-Beweise](https://dl.acm.org/doi/10.1145/62212.62222) vor, wobei der Beweisführer und der Verifizierer einen gemeinsamen Schlüssel haben. Dies ermöglicht es dem Beweisführer, sein Wissen über einige Informationen (d. h. Zeugen) zu demonstrieren, ohne die Informationen selbst bereitzustellen.
+Um dieses Problem zu lösen, schlugen Manuel Blum, Paul Feldman und Silvio Micali die ersten [nicht-interaktiven Zero-Knowledge-Beweise](https://dl.acm.org/doi/10.1145/62212.62222) vor, bei denen Beweisführer und Verifizierer einen gemeinsamen Schlüssel haben. Dies ermöglicht es dem Beweisführer, sein Wissen über einige Informationen (d. h. Zeugen) zu demonstrieren, ohne die Informationen selbst bereitzustellen.
Im Gegensatz zu interaktiven Beweisen erforderten nicht-interaktive Beweise nur eine Kommunikationsrunde zwischen den Teilnehmern (Beweiser und Verifizierer). Der Beweisführer übergibt die geheime Information an einen speziellen Algorithmus, um einen Null-Wissen-Beweis zu berechnen. Dieser Beweis wird an den Prüfer geschickt, der mit einem anderen Algorithmus überprüft, ob der Beweisführer die geheime Information kennt.
@@ -148,25 +171,25 @@ Die nicht-interaktive Beweisführung reduziert die Kommunikation zwischen Beweis
Nicht-interaktive Beweise stellten einen Durchbruch für die Null-Wissen-Technologie dar und förderten die Entwicklung von Beweissystemen, die heute verwendet werden. Wir diskutieren im Folgenden diese Beweistypen:
-### Arten von Null-Wissen-Beweisen {#types-of-zero-knowledge-proofs}
+### Arten von Zero-Knowledge-Beweisen {#types-of-zero-knowledge-proofs}
#### ZK-SNARKs {#zk-snarks}
ZK-SNARK ist ein Akronym für **Zero-Knowledge Succinct Non-Interactive Argument of Knowledge**. Das ZK-SNARK-Protokoll hat folgende Eigenschaften:
-- **Null-Wissen**: Ein Prüfer kann die Integrität einer Aussage validieren, ohne irgendetwas anderes über die Aussage zu wissen. Das einzige Wissen, das der Prüfer von der Aussage hat, ist, ob sie wahr oder falsch ist.
+- **Zero-Knowledge**: Ein Verifizierer kann die Integrität einer Aussage validieren, ohne etwas anderes über die Aussage zu wissen. Das einzige Wissen, das der Prüfer von der Aussage hat, ist, ob sie wahr oder falsch ist.
-- **Prägnant**: Der Null-Wissen-Beweis ist kleiner als der Zeuge und lässt sich schnell verifizieren.
+- **Prägnant**: Der Zero-Knowledge-Beweis ist kleiner als der Zeuge und kann schnell verifiziert werden.
-- **Nicht interaktiv**: Der Beweis ist „nicht interaktiv“, da der Beweisführer und der Prüfer nur einmal interagieren, im Gegensatz zu interaktiven Beweisen, die mehrere Kommunikationsrunden erfordern.
+- **Nicht interaktiv**: Der Beweis ist „nicht interaktiv“, da Beweisführer und Verifizierer nur einmal interagieren, im Gegensatz zu interaktiven Beweisen, die mehrere Kommunikationsrunden erfordern.
-- **Argument**: Der Beweis erfüllt die Anforderung der „Solidität“, daher ist ein Betrug äußerst unwahrscheinlich.
+- **Argument**: Der Beweis erfüllt die Anforderung der „Korrektheit“, sodass Betrug extrem unwahrscheinlich ist.
-- **(Des) Wissens**: Der Null-Wissen-Beweis kann ohne Zugang zu den geheimen Informationen (Zeuge) nicht konstruiert werden. Es ist schwierig, wenn nicht unmöglich, für einen Beweisführer, der keinen Zeugen hat, einen gültigen Null-Wissen-Beweis zu berechnen.
+- **(des) Wissens**: Der Zero-Knowledge-Beweis kann ohne Zugang zu den geheimen Informationen (dem Zeugen) nicht konstruiert werden. Es ist schwierig, wenn nicht unmöglich, für einen Beweisführer, der keinen Zeugen hat, einen gültigen Null-Wissen-Beweis zu berechnen.
Der zuvor erwähnte „gemeinsame Schlüssel“ bezieht sich auf öffentliche Parameter, auf die sich der Beweisführer und der Prüfer zur Generierung und Überprüfung von Beweisen einigen. Die Generierung der öffentlichen Parameter (zusammen als Common Reference String (CRS) bekannt) ist eine sensible Operation aufgrund ihrer Bedeutung für die Sicherheit des Protokolls. Wenn die Entropie (Zufälligkeit), die bei der Erzeugung des CRS verwendet wird, in die Hände eines unehrlichen Beweises gelangt, können sie falsche Beweise berechnen.
-[Multi-Party-Computation (MPC)](https://en.wikipedia.org/wiki/Secure_multi-party_computation) ist eine Möglichkeit, die Risiken bei der Generierung öffentlicher Parameter zu verringern. Mehrere Parteien nehmen an einer [vertrauenswürdigen Einrichtungszeremonie](https://zkproof.org/2021/06/30/setup-ceremonies/amp/) teil, bei der jede Person einige zufällige Werte beisteuert, um die CRS zu generieren. Solange eine ehrliche Partei ihren Anteil an der Entropie zerstört, behält das ZK-SNARK-Protokoll seine rechnerische Solidität.
+[Multi-Party Computation (MPC)](https://en.wikipedia.org/wiki/Secure_multi-party_computation) ist eine Möglichkeit, die Risiken bei der Erzeugung öffentlicher Parameter zu reduzieren. Mehrere Parteien nehmen an einer [vertrauenswürdigen Setup-Zeremonie](https://zkproof.org/2021/06/30/setup-ceremonies/amp/) teil, bei der jede Person einige Zufallswerte zur Erzeugung des CRS beiträgt. Solange eine ehrliche Partei ihren Anteil an der Entropie zerstört, behält das ZK-SNARK-Protokoll seine rechnerische Solidität.
Vertrauenswürdige Einrichtungen erfordern, dass Benutzer den Teilnehmern in der Parametererzeugung vertrauen. Die Entwicklung von ZK-STARKs hat jedoch die Entwicklung von Beweisprotokollen ermöglicht, die ohne vertrauenswürdige Einrichtungen auskommen.
@@ -174,23 +197,23 @@ Vertrauenswürdige Einrichtungen erfordern, dass Benutzer den Teilnehmern in der
ZK-STARK ist ein Akronym für **Zero-Knowledge Scalable Transparent Argument of Knowledge**. ZK-STARKs ähneln ZK-SNARKs, außer dass sie Folgendes sind:
-- **Skalierbar**: ZK-STARK ist schneller als ZK-SNARK beim Generieren und Verifizieren von Beweisen, wenn die Größe des Zeugen größer ist. Bei STARK-Beweisen steigen die Beweis- und Verifikationszeiten nur geringfügig an, wenn das Geheimnis wächst (im Gegensatz zu SNARK-Beweisen, bei denen die Beweis- und Verifikationszeiten linear mit der Größe des Geheimnisses ansteigen).
+- **Skalierbar**: ZK-STARK ist bei der Erzeugung und Verifizierung von Beweisen schneller als ZK-SNARK, wenn der Zeuge größer ist. Bei STARK-Beweisen steigen die Beweis- und Verifikationszeiten nur geringfügig an, wenn das Geheimnis wächst (im Gegensatz zu SNARK-Beweisen, bei denen die Beweis- und Verifikationszeiten linear mit der Größe des Geheimnisses ansteigen).
-- **Transparent**: ZK-STARK verlässt sich auf öffentlich überprüfbare Zufälligkeit, um öffentliche Parameter zum Nachweisen und Verifizieren anstelle eines vertrauenswürdigen Setups zu generieren. Dadurch sind sie im Vergleich zu ZK-SNARKs transparenter.
+- **Transparent**: ZK-STARK stützt sich auf öffentlich nachprüfbare Zufälligkeit, um öffentliche Parameter für die Beweiserstellung und Verifizierung zu generieren, anstatt auf ein vertrauenswürdiges Setup. Dadurch sind sie im Vergleich zu ZK-SNARKs transparenter.
ZK-STARKs erzeugen größere Beweise als ZK-SNARKs, was in der Regel zu höheren Verifikationsaufwänden führt. Es gibt jedoch Fälle (wie z. B. der Nachweis großer Datensätze), in denen ZK-STARKs im Vergleich zu ZK-SNARKs kosteneffektiver sein können.
-## Nachteile der Verwendung von Null-Wissen-Beweisen {#drawbacks-of-using-zero-knowledge-proofs}
+## Nachteile der Verwendung von Zero-Knowledge-Beweisen {#drawbacks-of-using-zero-knowledge-proofs}
-### Kosten für Hardware {#hardware-costs}
+### Hardware-Kosten {#hardware-costs}
Das Generieren von Null-Wissen-Beweisen setzt sehr komplexe Berechnungen voraus, die am besten auf spezialisierten Maschinen durchgeführt werden. Da diese Maschinen teuer sind, sind sie oft für Einzelpersonen nicht erschwinglich. Darüber hinaus müssen Anwendungen, die Null-Wissen-Technologie verwenden möchten, Hardwarekosten einkalkulieren – was die Kosten für Endbenutzer erhöhen kann.
-### Kosten der Nachweisprüfung {#proof-verification-costs}
+### Kosten für die Beweisverifizierung {#proof-verification-costs}
Die Überprüfung von Beweisen erfordert auch komplexe Berechnungen und erhöht die Kosten für die Implementierung von Null-Wissen-Technologie in Anwendungen. Diese Kosten sind besonders relevant im Zusammenhang mit dem Nachweis von Berechnungen. Beispielsweise zahlen ZK-Rollups ~500.000 Gas, um einen einzelnen ZK-SNARK-Beweis auf Ethereum zu verifizieren, wobei für ZK-STARKs noch höhere Gebühren anfallen.
-### Vertrauensannahme {#trust-assumptions}
+### Vertrauensannahmen {#trust-assumptions}
In ZK-SNARK wird der Common Reference String (öffentliche Parameter) einmal generiert und steht Parteien zur Wiederverwendung zur Verfügung, die am Null-Wissen-Protokoll teilnehmen möchten. Öffentliche Parameter werden im Rahmen einer vertrauenswürdigen Einrichtungszeremonie erstellt, bei der von den Teilnehmern angenommen wird, dass sie ehrlich sind.
@@ -202,12 +225,14 @@ ZK-SNARK nutzt Elliptische-Kurven-Kryptografie für die Verschlüsselung. Obwohl
ZK-STARK gilt als immun gegen die Bedrohung durch Quantencomputer, da es für seine Sicherheit nur auf kollisionsresistente Hashfunktionen angewiesen ist. Im Gegensatz zu öffentlich-privaten Schlüsselpaaren, die in der Elliptische-Kurven-Kryptografie zum Einsatz kommen, ist kollisionsresistentes Hashing für Quantencomputing-Algorithmen schwieriger zu knacken.
-## Weiterführende Informationen {#further-reading}
-
-- [Übersicht der Anwendungsfälle für Zero-Knowledge Proofs](https://pse.dev/projects) – _Team für Datenschutz- und Skalierungsuntersuchungen_
-- [SNARKs vs. STARKS vs. Rekursive SNARKs](https://www.alchemy.com/overviews/snarks-vs-starks) – _Alchemy-Übersichten_
-- [Ein Null-Wissen-Beweis: Verbesserung des Datenschutzes auf einer Blockchain](https://www.altoros.com/blog/zero-knowledge-proof-improving-privacy-for-a-blockchain/) — _Dmitri Lawrenow_
-- [zk-SNARKs – Ein realistisches Null-Wissen-Beispiel mit Tiefgang](https://medium.com/coinmonks/zk-snarks-ein-realistisches-Zero-Knowledge-Beispiel-und-Deep-Dive-c5e6eaa7131c) – _Adam Luciano_
-- [ZK-STARKs – Schaffen Sie verifizierbares Vertrauen, sogar gegenüber Quantencomputern](https://medium.com/coinmonks/zk-starks-schaffen-verifizierbares-Vertrauen-selbst-gegen-Quantencomputer-dd9c6a2bb13d) — _Adam Luciano_
-- [An approximate introduction to how zk-SNARKs are possible (Eine Näherungseinführung in die Realisierbarkeit von zk-SNARKs](https://vitalik.eth.limo/general/2021/01/26/snarks.html) – _Vitalik Buterin_
-- [Warum Null-Wissen-Beweise (Zero Knowledge Proofs, ZKPs) eine bahnbrechende Neuerung für die selbstbestimmte Identität sind](https://frankiefab.hashnode.dev/why-zero-knowledge-proofs-zkps-is-a-game-changer-for-self-sovereign-identity) — _Franklin Ohaegbulam_
+## Weiterführende Lektüre {#further-reading}
+
+- [Übersicht über Anwendungsfälle für Zero-Knowledge-Beweise](https://pse.dev/projects) – _Privacy and Scaling Explorations Team_
+- [SNARKs vs. STARKs vs. rekursive SNARKs](https://www.alchemy.com/overviews/snarks-vs-starks) – _Alchemy Overviews_
+- [A Zero-Knowledge Proof: Improving Privacy on a Blockchain](https://www.altoros.com/blog/zero-knowledge-proof-improving-privacy-for-a-blockchain/) – _Dmitry Lavrenov_
+- [zk-SNARKs — A Realistic Zero-Knowledge Example and Deep Dive](https://medium.com/coinmonks/zk-snarks-a-realistic-zero-knowledge-example-and-deep-dive-c5e6eaa7131c) – _Adam Luciano_
+- [ZK-STARKs — Create Verifiable Trust, even against Quantum Computers](https://medium.com/coinmonks/zk-starks-create-verifiable-trust-even-against-quantum-computers-dd9c6a2bb13d) – _Adam Luciano_
+- [An approximate introduction to how zk-SNARKs are possible](https://vitalik.eth.limo/general/2021/01/26/snarks.html) – _Vitalik Buterin_
+- [Why Zero Knowledge Proofs (ZKPs) is a Game Changer for Self-Sovereign Identity](https://frankiefab.hashnode.dev/why-zero-knowledge-proofs-zkps-is-a-game-changer-for-self-sovereign-identity) – _Franklin Ohaegbulam_
+- [EIP-7503 Explained: Enabling Private Transfers On Ethereum With ZK Proofs](https://research.2077.xyz/eip-7503-zero-knowledge-wormholes-for-private-ethereum-transactions#introduction) – _Emmanuel Awosika_
+- [ZK Card Game: game to learn ZK fundamentals and real-life use cases](https://github.com/ZK-card/zk-cards) – _ZK-Cards_
diff --git a/src/intl/de/common.json b/src/intl/de/common.json
index 78123ba510f..5bb2fb5b2e7 100644
--- a/src/intl/de/common.json
+++ b/src/intl/de/common.json
@@ -32,9 +32,6 @@
"content-resources": "Inhaltsressourcen",
"content-standardization": "Standardisierung der Inhalte",
"contributing": "Mitwirken",
- "contributor-quiz-banner-title": "Sind Sie unsicher, wo Sie anfangen sollen?",
- "contributor-quiz-banner-description": "Nehmen Sie an einem kurzen Quiz teil und finden Sie heraus, wie Sie auf ethereum.org mitwirken können.",
- "contributor-quiz-banner-button": "Nehmen Sie an einem Quiz teil",
"contributors": "Mitwirkende",
"contributors-thanks": "Vielen Dank an jeden, der zu dieser Seite beigetragen hat!",
"cookie-policy": "Cookie-Richtlinien",
@@ -308,7 +305,7 @@
"nav-history-description": "Eine Zeitleiste mit allen wichtigen Abspaltungen und Aktualisierungen",
"nav-history-label": "Die technische Geschichte von Ethereum",
"nav-learn-by-coding-description": "Tools, die Ihnen dabei helfen, mit Ethereum zu experimentieren",
- "nav-local-env-description": "Wählen Sie Ihren Ethereum-Entwichlungsstack und richten Sie ihn ein",
+ "nav-local-env-description": "Wählen Sie Ihren Ethereum-Entwicklungsstack aus und richten Sie ihn ein",
"nav-networks-home-description": "Günstigere und schnellere Transaktionen für Ethereum",
"nav-networks-introduction-label": "Einführung",
"nav-networks-introduction-description": "Ethereum hat sich zu einem Netzwerk von Netzwerken erweitert",
@@ -364,7 +361,7 @@
"nav-staking-saas-label": "Staking mit einer Dienstleistung",
"nav-staking-solo-description": "Benutzen Sie Hardware zu Hause und tragen Sie persönlich zur Sicherheit und Dezentralisierung des Ethereum-Netzwerks bei",
"nav-staking-solo-label": "Solo-Staking",
- "nav-start-building-description": "Hilfreiche Informationen für neue Mitglieder",
+ "nav-start-building-description": "Nützliche Informationen für Einsteiger",
"nav-start-with-crypto-title": "Hier starten",
"nav-start-with-crypto-description": "Ihre ersten Schritte zur Verwendung von Ethereum",
"nav-translation-program-description": "Eine gemeinsame Bemühung, ethereum.org in alle Sprachen zu übersetzen",
@@ -438,6 +435,7 @@
"set-up-local-env": "Lokale Umgebung einrichten",
"sharding": "Sharding",
"show-all": "Alles anzeigen",
+ "show-more": "Mehr anzeigen",
"show-less": "Weniger anzeigen",
"single-slot-finality": "Einzelplatzendgültigkeit",
"site-description": "Ethereum ist eine globale, dezentrale Plattform für Geld und neue Anwendungsmöglichkeiten. Auf Ethereum können Sie Code schreiben, mit dem sich Geld steuern lässt, und Anwendungen erstellen, die überall auf der Welt zugänglich sind.",
diff --git a/src/intl/de/glossary-tooltip.json b/src/intl/de/glossary-tooltip.json
new file mode 100644
index 00000000000..5371eb2b4d9
--- /dev/null
+++ b/src/intl/de/glossary-tooltip.json
@@ -0,0 +1,164 @@
+{
+ "51%-attack-term": "51 %-Angriff",
+ "51%-attack-definition": "Eine Art von Angriff, bei dem eine Gruppe die Kontrolle über die Mehrheit der Knoten übernimmt. Dadurch könnten sie die Blockchain manipulieren, indem sie Transaktionen rückgängig machen und Ether sowie andere Token doppelt ausgeben.",
+ "abi-term": "Binäre Anwendungsschnittstelle (ABI)",
+ "abi-definition": "Eine JSON-Datei, die die in einem Smart Contract enthaltenen Funktionen und Variablen definiert. Die ABI ermöglicht es, Bytecode in für Menschen lesbare Formate abzubilden.",
+ "account-term": "Konto",
+ "account-definition": "Ein Ethereum-Konto ist eine digitale Identität auf der Ethereum-Blockchain. Es ermöglicht Nutzerinnen und Nutzern, Ether oder andere digitale Vermögenswerte zu senden und zu empfangen sowie mit Smart Contracts zu interagieren.",
+ "address-term": "Adresse",
+ "address-definition": "Eine Ethereum-Adresse ist ein eindeutiger Identifikator zum Empfangen von Tokens. Sie funktioniert ähnlich wie eine Bankkontonummer für Kryptowährungen und dient dazu, Ihr Ethereum-Konto zu identifizieren.",
+ "anti-sybil-term": "Anti-Sybil",
+ "anti-sybil-definition": "Methoden, um zu verhindern, dass Personen im Internet vorgeben, gleichzeitig mehrere Benutzer zu sein, und um sicherzustellen, dass jeder Benutzer eine echte, separate Person ist. Dies trägt dazu bei, dass Online-Interaktionen fair und ehrlich bleiben.",
+ "apr-term": "APR",
+ "apr-definition": "APR, oder Annual Percentage Rate (effektiver Jahreszins), spiegelt die jährlichen Kosten für das Leihen von Geld, einschließlich Zinsen und Gebühren, als Prozentsatz wider.",
+ "attestation-term": "Attestierung",
+ "attestation-definition": "Eine Behauptung einer Entität, dass etwas wahr ist. Im Kontext von Ethereum müssen Konsens-Validatoren eine Behauptung darüber aufstellen, was sie für den Zustand der Chain halten. Zu bestimmten Zeiten ist jeder Validator dafür verantwortlich, verschiedene Attestierungen zu veröffentlichen, die die Ansicht dieses Validators über die Chain formell deklarieren, einschließlich des letzten finalisierten Checkpoints und des aktuellen Kopfes der Chain. Mehr über Attestierungen.",
+ "block-term": "Block",
+ "block-definition": "Ein Block ist der Speicherort für Transaktionen oder digitale Aktionen. Sobald ein Block voll ist, wird er mit dem vorherigen Block verknüpft, wodurch eine Kette von Blöcken – die „Blockchain“ – entsteht. Mehr über Blöcke.",
+ "blockchain-term": "Blockchain",
+ "blockchain-definition": "Eine Blockchain ist eine Datenbank von Transaktionen, die auf allen Rechnern im Netzwerk dupliziert und verteilt wird und so sicherstellt, dass Daten nicht nachträglich verändert werden können.",
+ "bridge-term": "Brücke",
+ "bridge-definition": "Eine Blockchain-Bridge wird verwendet, um Vermögenswerte von einem Blockchain-Netzwerk auf ein anderes zu übertragen.",
+ "consensus-term": "Konsens",
+ "consensus-definition": "Wenn mehr als 2/3 der Computer in einem Netzwerk übereinstimmen, dass sie denselben Datensatz haben, wird sichergestellt, dass alle auf dem gleichen Stand sind. Hierbei geht es nicht um die Regeln, die sie befolgen, sondern darum sicherzustellen, dass sie alle dieselben Informationen haben.",
+ "consensus-client-term": "Konsens-Client",
+ "consensus-client-definition": "Konsens-Clients (wie Prysm, Teku, Nimbus, Lighthouse, Lodestar) führen den Proof-of-Stake-Konsensalgorithmus von Ethereum aus, der es dem Netzwerk ermöglicht, eine Einigung über den Kopf der Beacon-Chain zu erzielen. Konsens-Clients beteiligen sich nicht an der Validierung/Verbreitung von Transaktionen oder der Ausführung von Zustandsübergängen. Dies wird von Ausführungs-Clients übernommen. Konsens-Clients attestieren oder schlagen keine neuen Blöcke vor. Dies wird vom Validator-Client erledigt, der ein optionales Add-on für den Konsens-Client ist.",
+ "consensus-layer-term": "Konsensebene",
+ "consensus-layer-definition": "Die Konsens-Ebene von Ethereum ist das Netzwerk der Konsens-Clients.",
+ "cryptoeconomics-term": "Cryptoeconomics",
+ "cryptoeconomics-definition": "Das Studium mathematischer und ökonomischer Prinzipien zum Entwurf sicherer und vertrauenswürdiger digitaler Plattformen. Ziel ist es, sicherzustellen, dass alle Teilnehmer die Regeln befolgen und für ihren Beitrag zur Sicherheit und zum Betrieb des Netzwerks belohnt werden.",
+ "cryptography-term": "Kryptographie",
+ "cryptography-definition": "Es handelt sich um die Praxis, Kommunikation privat und sicher zu gestalten, sodass nur die Personen, für die die Informationen bestimmt sind, diese lesen können.",
+ "dao-term": "Dezentralisierte autonome Organisation (DAO)",
+ "dao-definition": "Eine DAO ist eine digitale Organisation, die durch auf einer Blockchain programmierte Regeln gesteuert wird. Entscheidungen werden dabei durch die Stimmen der Mitglieder getroffen – nicht von einer zentralen Instanz. Mehr über dezentrale autonome Organisationen (DAOs).",
+ "dapp-term": "DApp",
+ "dapp-definition": "Eine dApp ist eine dezentrale Anwendung, die auf einem Blockchain-Netzwerk läuft und Dienste ohne eine zentrale Kontrollinstanz anbietet. Mehr über dezentrale Anwendungen.",
+ "data-availability-term": "Datenverfügbarkeit",
+ "data-availability-definition": "Jeder Node kann Transaktionen auf einer Blockchain unabhängig verifizieren, um Transparenz und Vertrauen in das System zu wahren.",
+ "defi-term": "DeFi",
+ "defi-definition": "Eine breite Kategorie von Ethereum-Apps, die darauf abzielen, durch die Blockchain abgesicherte Finanzdienstleistungen ohne Zwischenhändler anzubieten. Mehr über dezentralisierte Finanzen (DeFi)",
+ "dex-term": "Dezentralisierte Börse (DEX)",
+ "dex-definition": "Eine Art von Ethereum-App, mit der Sie Token mit Peers im Netzwerk tauschen können. DEXes unterliegen im Gegensatz zu zentralisierten Börsen keinen geografischen Beschränkungen – jeder kann teilnehmen.",
+ "difficulty-bomb-term": "Schwierigkeitsbombe",
+ "difficulty-bomb-definition": "Geplante exponentielle Erhöhung der Proof-of-Work-Schwierigkeitseinstellung, die den Übergang zu Proof-of-Stake motivieren und die Wahrscheinlichkeit eines Forks verringern sollte. Die Schwierigkeitsbombe wurde mit The Merge abgeschafft.",
+ "ecdsa-term": "Algorithmus für digitale Signaturen mit elliptischen Kurven (ECDSA)",
+ "ecdsa-definition": "Ein kryptographischer Algorithmus, der von Ethereum verwendet wird, um sicherzustellen, dass Gelder nur von ihren Besitzern ausgegeben werden können. Er ist die bevorzugte Methode zur Erstellung von öffentlichen und privaten Schlüsseln. Relevant für die Generierung von Konto-Adressen und die Verifizierung von Transaktionen.",
+ "ens-term": "Ethereum Namensservice (Ethereum Name Service, ENS)",
+ "ens-definition": "Der Ethereum Name Service ist wie ein Telefonbuch des Internets für Ethereum-Adressen. Anstatt lange Wallet-Adressen zu verwenden, ermöglicht ENS die Nutzung einfacher Namen wie „john.eth“, um digitales Geld und Vermögenswerte zu senden und zu empfangen.",
+ "epoch-term": "Epoche",
+ "epoch-definition": "Ein Zeitraum von 32 Slots, wobei jeder Slot 12 Sekunden dauert, also insgesamt 6,4 Minuten. Validator-Komitees werden aus Sicherheitsgründen jede Epoche neu gemischt. Jede Epoche bietet die Möglichkeit, dass die Chain finalisiert wird. Jedem Validator werden zu Beginn jeder Epoche neue Aufgaben zugewiesen. Mehr zu Proof-of-Stake",
+ "eoa-term": "Extern geführtes Konto (EOA)",
+ "eoa-definition": "Externally Owned Accounts (EOAs) sind der häufigste Typ von Ethereum-Konten. Sie werden von einer Person durch private Schlüssel/Wiederherstellungsphrase kontrolliert. Mehr über Ethereum-Wallets.",
+ "erc-term": "Ethereum-Anfrage zur Kommentierung (ERC)",
+ "erc-definition": "ERC (Ethereum Request for Comments) ist eine Art technischer Dokumentation, die in der Ethereum-Community verwendet wird, um neue Nutzungsstandards für das Ethereum-Netzwerk vorzuschlagen.",
+ "erc-1155-term": "ERC-1155",
+ "erc-1155-definition": "Ein Ethereum-Token-Standard, ähnlich wie NFTs (z. B. einzigartige Sammlerstücke), der jedoch zusätzlich ermöglicht, austauschbare Objekte (z. B. Währungen) innerhalb eines einzigen Smart Contracts zu erstellen.",
+ "erc-20-term": "ERC-20",
+ "erc-20-definition": "Ist der Standardsatz von Regeln, nach denen die meisten Token im Ethereum-Netzwerk erstellt werden.",
+ "erc-721-term": "ERC-721",
+ "erc-721-definition": "Ein Standardsatz von Regeln, der zur Erstellung von NFTs (nicht fungiblen Token) verwendet wird.",
+ "ether-term": "Ether",
+ "ether-definition": "Die native Kryptowährung von Ethereum, die üblicherweise als „ETH“ bezeichnet wird. Sie wird verwendet, um Transaktionsgebühren zu decken, wenn das Ethereum-Ökosystem und Anwendungen verwendet werden. Mehr über Ether.",
+ "events-term": "Ereignisse",
+ "events-definition": "Ermöglicht die Verwendung von EVM-Protokollierungseinrichtungen. Dapps können auf Ereignisse lauschen und sie verwenden, um JavaScript-Callbacks in der Benutzeroberfläche auszulösen. Mehr über Ereignisse und Protokolle",
+ "execution-client-term": "Ausführungs-Client",
+ "execution-client-definition": "Ausführungs-Clients (früher als „Eth1-Clients“ bekannt), wie Besu, Erigon, Go-Ethereum (Geth), Nethermind, haben die Aufgabe, Transaktionen zu verarbeiten und zu verbreiten und den Zustand von Ethereum zu verwalten. Sie führen die Berechnungen für jede Transaktion mit der Ethereum Virtual Machine durch, um sicherzustellen, dass die Regeln des Protokolls eingehalten werden.",
+ "execution-layer-term": "Ausführungsebene",
+ "execution-layer-definition": "Die Ausführungsebene von Ethereum ist das Netzwerk der Ausführungsclients.",
+ "finality-term": "Endgültigkeit",
+ "finality-definition": "Finalität ist die Garantie, dass eine Reihe von Transaktionen nicht geändert werden kann, ohne dass eine riesige Menge an ETH verloren geht.",
+ "fork-term": "Fork",
+ "fork-definition": "Eine Änderung im Protokoll, die die Erstellung einer alternativen Chain verursacht.",
+ "fraud-proof-term": "Betrugsbeweis",
+ "fraud-proof-definition": "Ein Sicherheitsmodell für bestimmte Layer-2-Lösungen, bei denen zur Beschleunigung Transaktionen in Batches gebündelt und in einer einzigen Transaktion an Ethereum übermittelt werden. Andere Netzwerkteilnehmer können die Transaktionen erneut ausführen, um zu überprüfen, ob sie ehrlich ausgeführt wurden. Wenn sie eine Diskrepanz zwischen den veröffentlichten Daten und ihrer eigenen Version aufdecken, können sie einen kryptographischen Beweis veröffentlichen, der zeigt, wo ein Betrug stattgefunden hat. Einige Rollups verwenden Gültigkeitsbeweise.",
+ "gas-term": "Ressourcen",
+ "gas-definition": "Gas ist die Gebühr, die für Transaktionen und Smart Contracts auf einer Blockchain wie Ethereum bezahlt wird. Mehr über Gas und Gebühren.",
+ "genesis-block-term": "Genesis-Block",
+ "genesis-block-definition": "Der allererste Block in einer Blockchain, der verwendet wird, um ein bestimmtes Netzwerk und seine Kryptowährung zu initialisieren.",
+ "gwei-term": "Gwei",
+ "gwei-definition": "Kurz für Gigawei, eine Denomination von Ether, die üblicherweise zur Preisgestaltung von Gas verwendet wird. 1 Gwei = 109 Wei. 109 Gwei = 1 Ether.",
+ "hash-term": "Hash",
+ "hash-definition": "Ein Fingerabdruck mit fester Länge einer Eingabe variabler Größe, der von einer Hash-Funktion erzeugt wird. (Siehe Keccak-256).",
+ "holographic-consensus-term": "Holographischer Konsens",
+ "holographic-consensus-definition": "Bezieht sich darauf, wie eine große Gruppenentscheidung getroffen wird, indem eine kleinere Gruppe von Vertretern abstimmt. Alle anderen akzeptieren diese Entscheidung, solange sie darauf vertrauen, dass die kleinere Gruppe gute Arbeit geleistet hat.",
+ "index-term": "Index",
+ "index-definition": "Eine Netzwerkstruktur, die die Abfrage von Informationen aus der gesamten Blockchain optimieren soll, indem sie einen effizienten Pfad zu ihrer Speicherquelle bereitstellt.",
+ "key-term": "Schlüssel",
+ "key-definition": "Im Kontext von Ethereum sind Schlüssel digitale Codes: ein öffentlicher Schlüssel zum Empfangen von Transaktionen und ein privater Schlüssel zum Zugriff auf und Versenden von Geldern.",
+ "layer-2-term": "Ebene 2",
+ "layer-2-definition": "Layer 2 sind weitere Netzwerke, die auf dem Ethereum-Hauptnetzwerk aufbauen, um Transaktionen schneller und günstiger zu machen. Mehr über Layer 2.",
+ "liquidity-tokens-term": "Liquiditäts-Token",
+ "liquidity-tokens-definition": "Liquiditätstoken (LT) sind digitale Token, die an Teilnehmer ausgegeben werden, die Vermögenswerte in einen Liquiditätspool einzahlen. Ein solcher Pool ist eine Sammlung von Geldern, die in einem Smart Contract hinterlegt sind und den Handel auf einer dezentralen Börse (DEX) ermöglichen.",
+ "mainnet-term": "Mainnet (Hauptnetz)",
+ "mainnet-definition": "Kurz für „Hauptnetzwerk\". Dies ist die öffentliche Ethereum-Blockchain.",
+ "mev-term": "MEV",
+ "mev-definition": "Ein Mechanismus, der bestimmte Aktionen auf einer Blockchain gegen eine Gebühr priorisiert und dadurch sowohl die Ergebnisse als auch die Reihenfolge von Transaktionen beeinflusst.",
+ "multisig-term": "Multisig",
+ "multisig-definition": "Multisig (Multi-Signature) bezeichnet eine digitale Wallet oder ein Konto, das mehrere Signaturen bzw. Freigaben benötigt, um Transaktionen auszuführen, und so die Sicherheit erhöht.",
+ "nft-term": "Non-fungible Token (NFT)",
+ "nft-definition": "Ein einzigartiger digitaler Gegenstand, den Sie besitzen können, wie Kunst oder Sammlerstücke, verifiziert durch Blockchain-Technologie. Mehr zu nicht-fungiblen Token (NFTs).",
+ "node-term": "Node",
+ "node-definition": "Ein Software-Client, der am Netzwerk teilnimmt. Mehr über Nodes und Clients.",
+ "ommer-term": "Ommer-(Onkel-)Block",
+ "ommer-definition": "Wenn ein Proof-of-Work-Miner einen gültigen Block findet, kann ein anderer Miner einen konkurrierenden Block veröffentlicht haben, der zuerst zur Spitze der Blockchain hinzugefügt wird. Dieser gültige, aber veraltete Block kann von neueren Blöcken als Ommers aufgenommen werden und eine teilweise Block-Belohnung erhalten. Der Begriff „Ommer“ ist die bevorzugte geschlechtsneutrale Bezeichnung für das Geschwister eines Elternblocks, wird aber manchmal auch als „Uncle“ bezeichnet. Dies war bei Ethereum üblich, als es noch ein Proof-of-Work-Netzwerk war. Da Ethereum nun Proof-of-Stake verwendet, wird pro Slot nur ein Block-Vorschlagender ausgewählt.",
+ "onchain-term": "Onchain",
+ "onchain-definition": "Bezieht sich auf Aktionen oder Transaktionen, die direkt auf der Blockchain stattfinden und öffentlich einsehbar sind.",
+ "optimistic-rollup-term": "Optimistische Rollups",
+ "optimistic-rollup-definition": "Optimistic Rollup ist eine Layer-2-Lösung, die Transaktionen auf Ethereum beschleunigt, indem sie standardmäßig als gültig angenommen werden, sofern sie nicht angefochten werden. Mehr über Optimistic Rollups.",
+ "peer-to-peer-network-term": "Peer-to-Peer-Netzwerk",
+ "peer-to-peer-network-definition": "Ein Netzwerk von Computern (Peers), die gemeinsam in der Lage sind, Funktionalitäten ohne zentrale serverbasierte Dienste auszuführen.",
+ "permissionless-term": "Genehmigungsfrei",
+ "permissionless-definition": "Es ist keine Erlaubnis oder Genehmigung erforderlich, um ein System wie Ethereum zu nutzen, und niemand kann dich daran hindern. Es ist rund um die Uhr für alle offen und zugänglich.",
+ "private-key-term": "Privater Schlüssel",
+ "private-key-definition": "Ein privater Schlüssel ist ein geheimer Code, der beweist, dass Sie Ihr digitales Geld besitzen und es Ihnen ermöglicht, es auszugeben, wie eine PIN für Ihr Konto. TEILEN SIE IHN NICHT.",
+ "poap-term": "POAP",
+ "poap-definition": "Das Proof of Attendance Protocol wird verwendet, um ein digitales Sammlerstück (NFT) zu erstellen, das beweist, dass Sie an einer bestimmten Veranstaltung oder Aktivität teilgenommen haben.",
+ "pos-term": "Proof-of-Stake (PoS)",
+ "pos-definition": "Eine Methode, mit der ein Kryptowährungs-Blockchain-Protokoll einen verteilten Konsens erreichen will. PoS fordert Benutzer auf, den Besitz einer bestimmten Menge an Kryptowährung (ihren „Stake“ im Netzwerk) nachzuweisen, um an der Validierung von Transaktionen teilnehmen zu können. Mehr über Proof-of-Stake.",
+ "pow-term": "Proof-of-Work (PoW)",
+ "pow-definition": "Ein Sicherheitsmechanismus für Blockchains, der von Nodes verlangt, Energie in Form von Rechenleistung aufzuwenden, um einen bestimmten Wert zu finden.",
+ "public-goods-term": "Öffentliche Güter",
+ "public-goods-definition": "Öffentliche Güter sind Dinge, die jeder kostenlos nutzen kann, wie Parks oder saubere Luft, und deren Nutzung andere nicht daran hindert, sie ebenfalls zu nutzen. Regierungen stellen diese oft zur Verfügung, weil Unternehmen dies in der Regel nicht tun, da sie die Menschen nicht einfach für deren Nutzung zur Kasse bitten können.",
+ "public-key-term": "Öffentlicher Schlüssel",
+ "public-key-definition": "Ein öffentlicher Schlüssel ist eine Zeichenfolge, die es anderen ermöglicht, Ihnen sicher digitale Währung zu senden, wie eine E-Mail-Adresse für Geld.",
+ "quadratic-voting-term": "Quadratische Abstimmung",
+ "quadratic-voting-definition": "Ist eine Abstimmungsmethode, bei der die Wähler ausdrücken, wie stark sie sich zu Themen fühlen. Es ermöglicht den Wählern, nicht nur ihre Präferenz, sondern auch die Intensität ihrer Präferenz zu zeigen.",
+ "recovery-phrase-term": "Seed-Phrase/Wiederherstellungsphrase",
+ "recovery-phrase-definition": "Eine Liste von Wörtern, die Sie bei der Erstellung einer digitalen Wallet erhalten. Sie dient als Passwort, mit dem Sie wieder auf Ihre Wallet zugreifen können, falls Sie den Zugriff darauf verlieren. So wird sichergestellt, dass Sie Ihr digitales Geld oder Ihre Token nicht verlieren.",
+ "rollups-term": "Gruppierungen (Rollups)",
+ "rollups-definition": "Eine Art von Layer-2-Skalierungslösung, die mehrere Transaktionen bündelt und sie in einer einzigen Transaktion an die Ethereum-Hauptkette übermittelt. Dies ermöglicht eine Reduzierung der Gaskosten und eine Erhöhung des Transaktionsdurchsatzes. Es gibt Optimistic- und Zero-Knowledge-Rollups, die unterschiedliche Sicherheitsmethoden verwenden, um diese Skalierbarkeitsgewinne zu bieten. Mehr über Rollups.",
+ "rpc-term": "Remote Procedure Call (RPC)",
+ "rpc-definition": "RPC ermöglicht es einem Computer, Daten oder Aktionen von einem anderen über ein Netzwerk anzufordern, wie das Abfragen von Informationen mit einer Fernbedienung.",
+ "sequencer-term": "Sequencer",
+ "sequencer-definition": "Ein Sequencer ist ein Programm, das in einem Blockchain-Netzwerk für die Reihenfolge der Transaktionen verantwortlich ist.",
+ "smart-contract-term": "Smart Contract",
+ "smart-contract-definition": "Ein Smart Contract ist ein Programm, das Vereinbarungen auf einer Blockchain automatisch ausführt, wie ein selbstausführender digitaler Vertrag. Einführung in Smart Contracts.",
+ "stablecoin-term": "Stablecoin",
+ "stablecoin-definition": "Ein Stablecoin ist eine Art von Kryptowährung, die so konzipiert ist, dass sie einen stabilen Wert hat, oft an eine Währung oder einen Rohstoff (wie den US-Dollar) gekoppelt, um Preisschwankungen zu minimieren. Mehr über Stablecoins.",
+ "staking-term": "Staking",
+ "staking-definition": "Einzahlung einer Menge Ether (Ihr Stake), um ein Validator zu werden und das Netzwerk zu sichern. Ein Validator überprüft Transaktionen und schlägt Blöcke in einem Proof-of-Stake-Konsensmodell vor. Das Staking gibt Ihnen einen wirtschaftlichen Anreiz, im besten Interesse des Netzwerks zu handeln. Sie erhalten Belohnungen für die Erfüllung Ihrer Validator-Pflichten, verlieren aber unterschiedliche Mengen an ETH, wenn Sie dies nicht tun. Mehr über Ethereum-Staking.",
+ "staking-pool-term": "Staking-Pool",
+ "staking-pool-definition": "Das kombinierte ETH von mehr als einem Ethereum-Staker, das verwendet wird, um die 32 ETH zu erreichen, die zur Aktivierung eines Satzes von Validator-Schlüsseln erforderlich sind. Ein Node-Betreiber verwendet diese Schlüssel, um am Konsens teilzunehmen, und die Block-Belohnungen werden unter den beitragenden Stakern aufgeteilt. Staking-Pools oder delegiertes Staking sind nicht nativ im Ethereum-Protokoll, aber viele Lösungen wurden von der Community entwickelt. Mehr über Pooled Staking.",
+ "sybil-attack-term": "Sybil Angriff",
+ "sybil-attack-definition": "Sybil-Angriffe beziehen sich auf einzelne Menschen, die das System glauben lassen wollen, sie seien mehrere Menschen, um ihren Einfluss zu erhöhen.",
+ "terminal-total-difficulty-term": "Terminale Gesamtschwierigkeit (Terminal Total Difficulty, TTD)",
+ "terminal-total-difficulty-definition": "Die Gesamtschwierigkeit ist die Summe der Ethash-Mining-Schwierigkeit für alle Blöcke bis zu einem bestimmten Punkt in der Blockchain. Die Terminal Total Difficulty (terminale Gesamtschwierigkeit) ist ein spezifischer Wert für die Gesamtschwierigkeit, der als Auslöser für Ausführungs-Clients diente, um ihre Mining- und Block-Gossip-Funktionen abzuschalten und dem Netzwerk den Übergang zu Proof-of-Stake zu ermöglichen. Sie ist nicht mehr relevant, da Ethereum zu Proof-of-Stake übergegangen ist.",
+ "transaction-fee-term": "Transaktionsgebühr",
+ "transaction-fee-definition": "Eine Gebühr, die Sie zahlen müssen, wann immer Sie das Ethereum-Netzwerk nutzen. Beispiele sind das Senden von Geldern aus Ihrer Wallet oder eine Dapp-Interaktion, wie das Tauschen von Token oder der Kauf eines Sammlerstücks. Sie können sich dies wie eine Servicegebühr vorstellen. Diese Gebühr ändert sich je nachdem, wie ausgelastet das Netzwerk ist. Das liegt daran, dass Validatoren, die für die Verarbeitung Ihrer Transaktion verantwortlich sind, wahrscheinlich Transaktionen mit höheren Gebühren priorisieren – so treibt die Überlastung den Preis in die Höhe.
Auf technischer Ebene bezieht sich Ihre Transaktionsgebühr darauf, wie viel Gas Ihre Transaktion benötigt.
Die Reduzierung der Transaktionsgebühren ist derzeit ein Thema von großem Interesse. Siehe Layer 2.",
+ "trust-assumptions-term": "Vertrauensannahme",
+ "trust-assumptions-definition": "Vertrauensannahmen sind grundlegende Überzeugungen über die Sicherheit und Zuverlässigkeit eines Systems, die leiten, worauf wir vertrauen, damit das System funktioniert.",
+ "validator-term": "Validator",
+ "validator-definition": "Ein Node in einem Proof-of-Stake-System, der für die Speicherung von Daten, die Verarbeitung von Transaktionen und das Hinzufügen neuer Blöcke zur Blockchain verantwortlich ist. Um die Validator-Software zu aktivieren, müssen Sie in der Lage sein, 32 ETH zu staken. Mehr über das Staking in Ethereum.",
+ "validity-proof-term": "Validitätsnachweis",
+ "validity-proof-definition": "Ein Sicherheitsmodell für bestimmte Layer-2-Lösungen, bei denen zur Beschleunigung Transaktionen in Batches gebündelt und in einer einzigen Transaktion an Ethereum übermittelt werden. Die Transaktionsberechnung erfolgt Offchain und wird dann mit einem Beweis ihrer Gültigkeit an die Hauptkette geliefert. Diese Methode erhöht die Anzahl der möglichen Transaktionen bei gleichbleibender Sicherheit. Einige Rollups verwenden Betrugsbeweise. Mehr über Zero-Knowledge-Rollups.",
+ "wallet-term": "Wallet",
+ "wallet-definition": "Eine Wallet ist ein digitales Werkzeug zum Speichern, Senden und Empfangen digitaler Währung, wie eine virtuelle Geldbörse für Ihr Online-Geld. Mehr über Ethereum-Wallets.",
+ "web2-term": "Web2",
+ "web2-definition": "Ist das aktuelle Internet, das sich auf benutzergenerierte Inhalte und soziale Medien konzentriert, die von wenigen Unternehmen kontrolliert werden. Web3 ist eine Krypto-Überzeugung, dass Benutzer ihre Daten und Transaktionen stattdessen kontrollieren sollten.",
+ "web3-term": "Web3",
+ "web3-definition": "Web3 ist das neue Internet mit Blockchain, bei dem Benutzer ihre Daten und Transaktionen kontrollieren, nicht Unternehmen. Es müssen keine persönlichen Informationen geteilt werden. Mehr über Web3.",
+ "wei-term": "Wei",
+ "wei-definition": "Die kleinste Denomination von Ether. 1018 Wei = 1 Ether.",
+ "zk-proof-term": "Zero-Knowledge-Nachweis",
+ "zk-proof-definition": "Ein Zero-Knowledge-Beweis ist eine kryptographische Methode, die es einer Person ermöglicht zu beweisen, dass eine Aussage wahr ist, ohne zusätzliche Informationen zu übermitteln. Mehr über Zero-Knowledge-Rollups."
+}
diff --git a/src/intl/de/glossary.json b/src/intl/de/glossary.json
new file mode 100644
index 00000000000..cd1ad83355c
--- /dev/null
+++ b/src/intl/de/glossary.json
@@ -0,0 +1,408 @@
+{
+ "51%-attack-term": "51 %-Angriff",
+ "51%-attack-definition": "Eine Art von Angriff, bei dem eine Gruppe die Kontrolle über die Mehrheit der Nodes erlangt. Dies würde es ihnen ermöglichen, die Blockchain zu betrügen, indem sie Transaktionen rückgängig machen und Ether und andere Token doppelt ausgeben.
In Ethereum Proof-of-Stake würde dies durch die Anhäufung von mehr als der Hälfte des gesamten gestaketen Ethers erreicht. Dies würde einem Angreifer ermöglichen, zu entscheiden, welche neuen Blöcke der Blockchain hinzugefügt werden. Um jedoch die Kette rückgängig zu machen oder doppelt auszugeben, würde ein Angreifer mindestens 66 % des gesamten gestaketen Ethers benötigen.",
+ "account-term": "Konto",
+ "account-definition": "Ein Ethereum-Konto ist eine digitale Identität auf der Ethereum-Blockchain, die es Benutzern ermöglicht, Ether zu senden, zu empfangen und mit Smart Contracts zu interagieren.
Technisch:
Es ist ein Objekt, das eine Adresse, ein Guthaben, eine Nonce und optionalen Speicher und Code enthält. Ein Konto kann ein Vertragskonto oder ein extern verwaltetes Konto (Externally Owned Account, EOA) sein.",
+ "address-term": "Adresse",
+ "address-definition": "Eine Ethereum-Adresse ist ein eindeutiger Identifikator zum Empfangen von Tokens, der ähnlich wie eine Bankkontonummer für Kryptowährungen funktioniert. Sie wird verwendet, um Ihr Ethereum-Konto zu identifizieren.
Sie besteht aus den rechtesten 160 Bits eines Keccak-Hashes eines öffentlichen ECDSA-Schlüssels.",
+ "anti-sybil-term": "Anti-Sybil",
+ "anti-sybil-definition": "Methoden, um zu verhindern, dass Personen im Internet vorgeben, gleichzeitig mehrere Benutzer zu sein, und um sicherzustellen, dass jeder Benutzer eine echte, separate Person ist. Dies trägt dazu bei, dass Online-Interaktionen fair und ehrlich bleiben.",
+ "abi-term": "Binäre Anwendungsschnittstelle (ABI)",
+ "abi-definition": "Eine JSON-Datei, die die in einem Smart Contract enthaltenen Funktionen und Variablen definiert. Die ABI ermöglicht es, Bytecode in für Menschen lesbare Formate abzubilden.",
+ "api-term": "Application Programming Interface (API)",
+ "api-definition": "Eine Application Programming Interface (API) ist eine Reihe von Definitionen für die Verwendung eines Softwareteils. Eine API befindet sich zwischen einer Anwendung und einem Webserver und erleichtert die Datenübertragung zwischen ihnen.",
+ "apr-term": "APR",
+ "apr-definition": "APR, oder Annual Percentage Rate (effektiver Jahreszins), spiegelt die jährlichen Kosten für das Leihen von Geld, einschließlich Zinsen und Gebühren, als Prozentsatz wider.",
+ "asic-term": "ASIC",
+ "asic-definition": "Anwendungsspezifische integrierte Schaltung. Dies bezieht sich in der Regel auf eine integrierte Schaltung, die speziell für das Mining von Kryptowährungen entwickelt wurde.",
+ "assert-term": "Beanspruchungen",
+ "assert-definition": "In Solidity kompiliert `assert(false)` zu `0xfe`, einem ungültigen Opcode, der das gesamte verbleibende Gas verbraucht und alle Änderungen rückgängig macht. Wenn eine `assert()`-Anweisung fehlschlägt, geschieht etwas sehr Falsches und Unerwartetes, und Sie müssen Ihren Code korrigieren. Sie sollten `assert()` verwenden, um Bedingungen zu vermeiden, die niemals auftreten sollten. Mehr zur Sicherheit von Smart Contracts.",
+ "attestation-term": "Attestierung",
+ "attestation-definition": "Eine Behauptung einer Entität, dass etwas wahr ist. Im Kontext von Ethereum müssen Konsens-Validatoren eine Behauptung darüber aufstellen, was sie für den Zustand der Chain halten. Zu bestimmten Zeiten ist jeder Validator dafür verantwortlich, verschiedene Attestierungen zu veröffentlichen, die die Ansicht dieses Validators über die Chain formell deklarieren, einschließlich des letzten finalisierten Checkpoints und des aktuellen Kopfes der Chain. Mehr über Attestierungen.",
+ "base-fee-term": "Grundgebühr",
+ "base-fee-definition": "Jeder Block hat einen als „Grundgebühr“ bekannten Mindestpreis. Es ist die minimale Gas-Gebühr, die ein Benutzer zahlen muss, um eine Transaktion in den nächsten Block aufzunehmen. Mehr zu Gas und Gebühren.",
+ "beacon-chain-term": "Beacon-Chain",
+ "beacon-chain-definition": "Die Beacon-Chain war die Blockchain, die Proof-of-Stake und Validatoren in Ethereum eingeführt hat. Sie lief von Dezember 2020 bis zur Zusammenführung der beiden Chains im September 2022 parallel zum Proof-of-Work Ethereum Mainnet, um das heutige Ethereum zu bilden. Mehr über die Beacon-Chain.",
+ "big-endian-term": "Big-Endian",
+ "big-endian-definition": "Eine Positionszahldarstellung, bei der die höchstwertige Ziffer zuerst im Speicher steht. Das Gegenteil von Little-Endian, bei dem die niedrigstwertige Ziffer zuerst steht.",
+ "block-term": "Block",
+ "block-definition": "Ein Block ist der Ort, an dem Transaktionen oder digitale Aktionen gespeichert werden. Sobald ein Block voll ist, wird er mit dem vorherigen verknüpft, wodurch eine Kette von Blöcken oder eine „Blockchain“ entsteht. Mehr über Blöcke.
Ein Block ist eine gebündelte Informationseinheit, die eine geordnete Liste von Transaktionen und konsensbezogene Informationen enthält. Blöcke werden von Proof-of-Stake-Validatoren vorgeschlagen und dann über das gesamte Peer-to-Peer-Netzwerk geteilt, wo sie von allen anderen Nodes einfach und unabhängig verifiziert werden können. Konsensregeln bestimmen, welche Inhalte eines Blocks als gültig gelten, und ungültige Blöcke werden vom Netzwerk ignoriert. Die Reihenfolge dieser Blöcke und der darin enthaltenen Transaktionen erzeugt eine deterministische Kette von Ereignissen, deren Ende den aktuellen Zustand des Netzwerks darstellt.",
+ "block-explorer-term": "Block Explorer",
+ "block-explorer-definition": "Eine Schnittstelle, die es einem Nutzer ermöglicht, Informationen von einer Blockchain und über sie zu suchen. Dies umfasst das Abrufen einzelner Transaktionen, der mit bestimmten Adressen verbundenen Aktivitäten sowie von Informationen über das Netzwerk.",
+ "block-header-term": "Block-Header",
+ "block-header-definition": "Der Block-Header ist eine Sammlung von Metadaten über einen Block und eine Zusammenfassung der Transaktionen, die im Ausführungs-Payload enthalten sind.",
+ "block-propagation-term": "Block-Verbreitung",
+ "block-propagation-definition": "Der Prozess der Übertragung eines bestätigten Blocks an alle anderen Nodes im Netzwerk.",
+ "block-proposer-term": "Block-Vorschlagender",
+ "block-proposer-definition": "Der spezifische Validator, der ausgewählt wurde, um einen Block in einem bestimmten Slot zu erstellen.",
+ "block-reward-term": "Block-Belohnung",
+ "block-reward-definition": "Der Betrag an Ether, der an den Antragsteller eines neuen gültigen Blocks ausgezahlt wird.",
+ "block-status-term": "Block-Status",
+ "block-status-definition": "Die Zustände, in denen ein Block existieren kann. Die möglichen Zustände umfassen:
- vorgeschlagen: Der Block wurde von einem Validator vorgeschlagen
- geplant: Validatoren übermitteln derzeit Daten
- verpasst/übersprungen: Der Vorschlagende hat innerhalb des zulässigen Zeitrahmens keinen Block vorgeschlagen
- verwaist: Der Block wurde durch den Fork-Choice-Algorithmus aus der Reorganisation entfernt
",
+ "block-time-term": "Blockzeit",
+ "block-time-definition": "Das Zeitintervall zwischen Blöcken, die zur Blockchain hinzugefügt werden.",
+ "block-validation-term": "Block-Validierung",
+ "block-validation-definition": "Der Prozess der Überprüfung, ob ein neuer Block gültige Transaktionen und Signaturen enthält, auf der schwersten historischen Kette aufbaut (d. h. derjenigen, die die meisten Attestierungen in ihrer Geschichte angesammelt hat) und alle anderen Konsensregeln befolgt. Gültige Blöcke werden an den Kopf der Kette angefügt und an andere im Netzwerk weitergegeben. Ungültige Blöcke werden ignoriert.",
+ "blockchain-term": "Blockchain",
+ "blockchain-definition": "Eine Blockchain ist eine Datenbank von Transaktionen, die auf allen Computern im Netzwerk dupliziert und geteilt wird, um sicherzustellen, dass Daten nicht rückwirkend geändert werden können.
Eine Folge von Blöcken, von denen jeder durch Referenzierung des Hashes des vorherigen Blocks mit seinem Vorgänger bis hin zum Genesis-Block verknüpft ist. Die Integrität der Blockchain wird kryptoökonomisch durch einen auf Proof-of-Stake basierenden Konsensmechanismus gesichert. Was ist eine Blockchain?",
+ "bootnode-term": "Bootnode",
+ "bootnode-definition": "Die Nodes, die verwendet werden können, um den Entdeckungsprozess beim Ausführen eines Nodes zu initiieren. Bootnodes „stellen“ neue Nodes anderen bestehenden Nodes vor, damit diese schnell Peers finden können, anstatt nach einem ersten Peer suchen zu müssen. Die Endpunkte dieser Nodes sind normalerweise im Quellcode des Ethereum-Clients enthalten, aber Benutzer können ihre eigene Liste von Bootnodes bereitstellen.",
+ "bridge-term": "Brücke",
+ "bridge-definition": "Eine kettenübergreifende Blockchain-Brücke wird verwendet, um Vermögenswerte von einem Blockchain-Netzwerk in ein anderes zu übertragen. Sie können beispielsweise eine Brücke verwenden, um ETH vom Hauptnetzwerk von Ethereum auf günstigere Layer-2-Skalierungslösungen zu übertragen.",
+ "bytecode-term": "Bytecode",
+ "bytecode-definition": "Code, der in einer kompakten, numerischen Form ausgedrückt wird, damit er von der EVM effizient ausgeführt werden kann.",
+ "byzantium-fork-term": "Byzantium Fork",
+ "byzantium-fork-definition": "Der erste von zwei Hard Forks für die Metropolis-Entwicklungsphase. Er umfasste die EIP-649-Metropolis-Schwierigkeitsbombe-Verzögerung und die Reduzierung der Block-Belohnung, wodurch die Ice Age um 1 Jahr verzögert und die Block-Belohnung von 5 auf 3 Ether reduziert wurde.",
+ "casper-ffg-term": "Casper FFG",
+ "casper-ffg-definition": "Caspar-FFG ist ein Proof-of-Stake Konsensprotokoll, das in Verbindung mit dem LMD-GHOST Fork-Choice-Algorithmus verwendet wird, um es Konsenskunden zu ermöglichen, sich auf den Kopf der Beacon Chain zu einigen.",
+ "checkpoint-term": "Checkpoint",
+ "checkpoint-definition": "Die Beacon-Chain hat ein Tempo, das in Slots (12 Sekunden) und Epochen (32 Slots) unterteilt ist. Der erste Slot in jeder Epoche ist ein Checkpoint. Wenn eine qualifizierte Mehrheit von Validatoren die Verbindung zwischen zwei Checkpoints attestiert, können diese gerechtfertigt werden, und wenn ein weiterer Checkpoint daraufhin gerechtfertigt wird, können sie finalisiert werden.",
+ "compiling-term": "Kompilieren",
+ "compiling-definition": "Umwandlung von Code, der in einer Hochsprache (z. B. Solidity) geschrieben wurde, in eine Sprache auf niedrigerer Ebene (z. B. EVM-Bytecode).Mehr über das Kompilieren von Smart Contracts.",
+ "committee-term": "Komitee",
+ "committee-definition": "Eine Gruppe von mindestens 128 Validatoren, die beauftragt sind, Blöcke in jedem Slot zu validieren. Einer der Validatoren im Komitee ist der Aggregator, der für die Zusammenfassung der Signaturen aller anderen Validatoren im Komitee verantwortlich ist, die einer Attestierung zustimmen. Nicht zu verwechseln mit dem Sync-Komitee.",
+ "computational-infeasibility-term": "Rechnerische Undurchführbarkeit",
+ "computational-infeasibility-definition": "Ein Prozess ist rechnerisch undurchführbar, wenn es eine undurchführbar lange Zeit dauern würde (z. B. Milliarden von Jahren), ihn für jeden durchzuführen, der möglicherweise ein Interesse daran haben könnte.",
+ "consensus-term": "Konsens",
+ "consensus-definition": "Wenn mehr als 2/3 der Computer in einem Netzwerk übereinstimmen, dass sie denselben Datensatz haben, wird sichergestellt, dass alle auf dem gleichen Stand sind. Hierbei geht es nicht um die Regeln, die sie befolgen, sondern darum sicherzustellen, dass sie alle dieselben Informationen haben.",
+ "consensus-client-term": "Konsens-Client",
+ "consensus-client-definition": "Konsens-Clients (wie Prysm, Teku, Nimbus, Lighthouse, Lodestar) führen den Proof-of-Stake-Konsensalgorithmus von Ethereum aus, der es dem Netzwerk ermöglicht, eine Einigung über den Kopf der Beacon-Chain zu erzielen. Konsens-Clients beteiligen sich nicht an der Validierung/Verbreitung von Transaktionen oder der Ausführung von Zustandsübergängen. Dies wird von Ausführungs-Clients übernommen. Konsens-Clients attestieren oder schlagen keine neuen Blöcke vor. Dies wird vom Validator-Client erledigt, der ein optionales Add-on für den Konsens-Client ist.",
+ "consensus-layer-term": "Konsensebene",
+ "consensus-layer-definition": "Die Konsens-Ebene von Ethereum ist das Netzwerk der Konsens-Clients.",
+ "consensus-rules-term": "Konsensregeln",
+ "consensus-rules-definition": "Die Blockvalidierungsregeln, denen vollständige Nodes folgen, um mit anderen Nodes im Konsens zu bleiben. Nicht zu verwechseln mit dem Konsens.",
+ "cfi-term": "Zur Aufnahme in Betracht gezogen (CFI)",
+ "cfi-definition": "Ein Core-EIP, das noch nicht im Mainnet aktiv ist und dessen Idee von den Client-Entwicklern allgemein positiv aufgenommen wird. Unter der Annahme, dass es alle Anforderungen für die Aufnahme ins Mainnet erfüllt, könnte es potenziell in ein Netzwerk-Upgrade aufgenommen werden (nicht unbedingt in das nächste).",
+ "constantinople-fork-term": "Constantinople-Fork",
+ "constantinople-fork-definition": "Der zweite Teil der Metropolis-Phase, ursprünglich für Mitte 2018 geplant. Es wird erwartet, dass er unter anderem einen Wechsel zu einem hybriden Proof-of-Work/Proof-of-Stake-Konsensalgorithmus beinhaltet.",
+ "contract-account-term": "Vertragskonto",
+ "contract-account-definition": "Ein Konto, das Code enthält, der ausgeführt wird, sobald es eine Transaktion von einem anderen Konto (EOA oder Vertrag) erhält.",
+ "contract-creation-transaction-term": "Vertragserstellungstransaktion",
+ "contract-creation-transaction-definition": "Eine spezielle Transaktion, die den Initialisierungscode eines Vertrags enthält und dazu dient, einen Vertrag zu registrieren und auf der Ethereum-Blockchain zu speichern. Der Empfänger wird auf `null` gesetzt und der Vertrag wird an einer Adresse bereitgestellt, die aus der Benutzeradresse und der `Nonce` generiert wird.",
+ "cryptoeconomics-term": "Cryptoeconomics",
+ "cryptoeconomics-definition": "Das Studium mathematischer und ökonomischer Prinzipien zum Entwurf sicherer und vertrauenswürdiger digitaler Plattformen. Ziel ist es, sicherzustellen, dass alle Teilnehmer die Regeln befolgen und für ihren Beitrag zur Sicherheit und zum Betrieb des Netzwerks belohnt werden.",
+ "cryptography-term": "Kryptographie",
+ "cryptography-definition": "Es ist die Praxis, Kommunikation und Daten durch die Verwendung von Codes zu sichern, sodass nur diejenigen, für die die Informationen bestimmt sind, sie lesen und verarbeiten können.
Es umfasst Techniken zur Verschlüsselung (Umwandlung lesbarer Informationen in ein unlesbares Format) und Entschlüsselung (Rückumwandlung in ein lesbares Format), um die Vertraulichkeit zu gewährleisten.",
+ "doge-d-term": "Đ",
+ "doge-d-definition": "Đ (D mit Strich) wird im Altenglischen, Mittelenglischen, Isländischen und Färöischen für den Großbuchstaben „Eth“ verwendet. Es wird in Wörtern wie ĐEV oder Đapp (dezentralisierte Anwendung) verwendet, wobei das Đ der nordische Buchstabe „eth“ ist. Das große Eth (Ð) wird auch zur Symbolisierung der Kryptowährung Dogecoin verwendet. Dies ist häufig in älterer Ethereum-Literatur zu sehen, wird aber heute seltener verwendet.",
+ "dag-term": "DAG",
+ "dag-definition": "DAG steht für Directed Acyclic Graph (gerichteter azyklischer Graph). Es ist eine Datenstruktur, die aus Nodes und Verbindungen zwischen ihnen besteht. Vor The Merge verwendete Ethereum einen DAG in seinem Proof-of-Work-Algorithmus, Ethash, der aber im Proof-of-Stake nicht mehr verwendet wird.",
+ "dapp-term": "DApp",
+ "dapp-definition": "Eine dApp ist eine dezentralisierte Anwendung, die in einem Blockchain-Netzwerk läuft und Dienste ohne eine zentrale Kontrollinstanz anbietet. Mehr über dezentralisierte Anwendungen.
Mindestens hat eine Dapp einen Smart Contract, der mit einer Weboberfläche verbunden ist. Darüber hinaus umfassen viele Dapps dezentralen Speicher und/oder ein Nachrichtenprotokoll und eine Plattform.",
+ "data-availability-term": "Datenverfügbarkeit",
+ "data-availability-definition": "Jeder Node kann Transaktionen auf einer Blockchain unabhängig verifizieren, um Transparenz und Vertrauen in das System zu wahren.",
+ "decentralization-term": "Dezentralisierung",
+ "decentralization-definition": "Das Konzept von der Verschiebung von Steuerung und Ausführung von Prozessen weg von einer zentralen Entität.",
+ "dao-term": "Dezentralisierte autonome Organisation (DAO)",
+ "dao-definition": "Eine DAO ist eine digitale Organisation, die nach Regeln geführt wird, die auf einer Blockchain kodiert sind, wobei Entscheidungen durch Abstimmungen der Mitglieder und nicht durch eine zentrale Autorität getroffen werden. Mehr über dezentralisierte autonome Organisationen (DAOs).
Die Stimmkraft jedes Mitglieds ist oft an die Anzahl der von ihm gehaltenen Token gebunden. DAOs zielen darauf ab, Entscheidungsfindung und Betrieb zu demokratisieren, wobei der Schwerpunkt auf Transparenz und Community-Governance liegt.",
+ "desci-term": "DeSci",
+ "desci-definition": "DeSci, oder Dezentralisierte Wissenschaft, ist eine Bewegung, die die Blockchain-Technologie auf die wissenschaftliche Forschung anwendet. Sie nutzt DAOs, Smart Contracts und tokenisierte Anreize, um transparentere, offenere und kollaborativere Finanzierungs- und Forschungsökosysteme zu schaffen.",
+ "dex-term": "Dezentralisierte Börse (DEX)",
+ "dex-definition": "Eine Art von Ethereum-App, mit der Sie Token mit Peers im Netzwerk tauschen können. DEXes unterliegen im Gegensatz zu zentralisierten Börsen keinen geografischen Beschränkungen – jeder kann teilnehmen.",
+ "deposit-contract-term": "Einzahlungsvertrag",
+ "deposit-contract-definition": "Das Tor zum Staking auf Ethereum. Der Einzahlungsvertrag ist ein Smart Contract auf Ethereum, der Einzahlungen von ETH annimmt und Validator-Guthaben verwaltet. Ein Validator kann nicht aktiviert werden, ohne ETH in diesen Vertrag einzuzahlen. Der Vertrag erfordert ETH und Eingabedaten. Diese Eingabedaten umfassen den öffentlichen Schlüssel des Validators und den öffentlichen Schlüssel für Abhebungen, signiert mit dem privaten Schlüssel des Validators. Diese Daten sind erforderlich, damit ein Validator vom Proof-of-Stake-Netzwerk identifiziert und genehmigt werden kann.",
+ "defi-term": "DeFi",
+ "defi-definition": "Eine breite Kategorie von Ethereum-Apps, die darauf abzielen, durch die Blockchain abgesicherte Finanzdienstleistungen ohne Zwischenhändler anzubieten. Mehr über dezentralisierte Finanzen (DeFi)",
+ "difficulty-term": "Schwierigkeit",
+ "difficulty-definition": "Eine netzwerkweite Einstellung in Proof-of-Work-Netzwerken, die steuert, wie viel durchschnittliche Rechenleistung erforderlich ist, um eine gültige Nonce zu finden. Die Schwierigkeit wird durch die Anzahl der führenden Nullen dargestellt, die im resultierenden Block-Hash erforderlich sind, damit er als gültig betrachtet wird. Dieses Konzept ist in Ethereum seit dem Übergang zu Proof-of-Stake veraltet.",
+ "difficulty-bomb-term": "Schwierigkeitsbombe",
+ "difficulty-bomb-definition": "Geplante exponentielle Erhöhung der Proof-of-Work-Schwierigkeitseinstellung, die den Übergang zu Proof-of-Stake motivieren und die Wahrscheinlichkeit eines Forks verringern sollte. Die Schwierigkeitsbombe wurde mit The Merge abgeschafft.",
+ "digital-signatures-term": "Digitale Signatur",
+ "digital-signatures-definition": "Eine kurze Zeichenkette von Daten, die ein Benutzer für ein Dokument mit einem privaten Schlüssel erzeugt, so dass jeder mit dem entsprechenden öffentlichen Schlüssel, der Unterschrift und dem Dokument überprüfen kann, ob (1) das Dokument vom Eigentümer dieses privaten Schlüssels „signiert\" wurde und (2) das Dokument nach seiner Unterschrift nicht geändert wurde.",
+ "discovery-term": "Entdeckung",
+ "discovery-definition": "Der Prozess, mit dem ein Ethereum-Node andere Nodes findet, mit denen eine Verbindung hergestellt werden soll.",
+ "distributed-hash-table-term": "Verteilte Hash-Tabelle (DHT)",
+ "distributed-hash-table-definition": "Eine Datenstruktur mit `(Schlüssel, Wert)`-Paaren, die von Ethereum-Nodes verwendet wird, um Peers zur Verbindung zu identifizieren und zu bestimmen, welche Protokolle zur Kommunikation verwendet werden sollen.",
+ "double-spend-term": "Doppelausgabe",
+ "double-spend-definition": "Ein absichtlicher Blockchain-Fork, bei dem ein Benutzer mit einer ausreichend großen Menge an Mining-Power/Stake eine Transaktion sendet, die eine Währung Offchain bewegt (z. B. in Fiat-Geld umwandelt oder einen Offchain-Kauf tätigt) und dann die Blockchain reorganisiert, um diese Transaktion zu entfernen. Eine erfolgreiche Doppelausgabe lässt den Angreifer mit seinen On- und Offchain-Vermögenswerten zurück.",
+ "ecdsa-term": "Algorithmus für digitale Signaturen mit elliptischen Kurven (ECDSA)",
+ "ecdsa-definition": "Ein kryptographischer Algorithmus, der von Ethereum verwendet wird, um sicherzustellen, dass Gelder nur von ihren Besitzern ausgegeben werden können. Er ist die bevorzugte Methode zur Erstellung von öffentlichen und privaten Schlüsseln. Relevant für die Generierung von Konto-Adressen und die Verifizierung von Transaktionen.",
+ "encryption-term": "Verschlüsselung",
+ "encryption-definition": "Verschlüsselung ist die Umwandlung elektronischer Daten in eine Form, die von niemandem außer dem Besitzer des korrekten Entschlüsselungsschlüssels lesbar ist.",
+ "entropy-term": "Entropie",
+ "entropy-definition": "Im Kontext der Kryptographie die mangelnde Vorhersagbarkeit oder der Grad der Zufälligkeit. Bei der Erzeugung geheimer Informationen, wie z. B. privater Schlüssel, stützen sich Algorithmen in der Regel auf eine Quelle mit hoher Entropie, um sicherzustellen, dass die Ausgabe unvorhersehbar ist.",
+ "epoch-term": "Epoche",
+ "epoch-definition": "Ein Zeitraum von 32 Slots, wobei jeder Slot 12 Sekunden dauert, also insgesamt 6,4 Minuten. Validator-Komitees werden aus Sicherheitsgründen jede Epoche neu gemischt. Jede Epoche bietet die Möglichkeit, dass die Chain finalisiert wird. Jedem Validator werden zu Beginn jeder Epoche neue Aufgaben zugewiesen. Mehr zu Proof-of-Stake",
+ "equivocation-term": "Äquivokation",
+ "equivocation-definition": "Ein Validator sendet zwei Nachrichten, die sich widersprechen. Ein einfaches Beispiel ist ein Transaktionssender, der zwei Transaktionen mit derselben Nonce sendet. Ein anderes ist ein Block-Vorschlagender, der zwei Blöcke auf derselben Blockhöhe (oder für denselben Slot) vorschlägt.",
+ "eth1-term": "Eth1",
+ "eth1-definition": "„Eth1“ ist ein Begriff, der sich auf das Mainnet Ethereum bezog, die bestehende Proof-of-Work-Blockchain. Dieser Begriff wurde inzwischen zugunsten der „Ausführungsebene“ veraltet. Erfahren Sie mehr über diese Namensänderung.",
+ "eth2-term": "Eth2",
+ "eth2-definition": "„Eth2“ ist ein Begriff, der sich auf eine Reihe von Ethereum-Protokoll-Upgrades bezog, einschließlich des Übergangs von Ethereum zu Proof-of-Stake. Dieser Begriff wurde inzwischen zugunsten der „Konsens-Ebene“ veraltet. Erfahren Sie mehr über diese Namensänderung.",
+ "eip-term": "Ethereum Verbesserungsvorschläge (EIP)",
+ "eip-definition": "Ein Designdokument, das der Ethereum-Community Informationen bereitstellt und eine vorgeschlagene neue Funktion oder deren Prozesse oder Umgebung beschreibt (siehe ERC). Einführung in EIPs",
+ "ens-term": "Ethereum Namensservice (Ethereum Name Service, ENS)",
+ "ens-definition": "Der Ethereum Name Service ist wie ein Internet-Telefonbuch für Ethereum-Adressen. Anstatt lange Wallet-Adressen zu verwenden, können Sie mit ENS einfache Namen wie „john.eth“ verwenden, um digitales Geld und Vermögenswerte zu senden und zu empfangen.
Technisch:
Die ENS-Registry ist ein einziger zentraler Vertrag, der eine Zuordnung von Domainnamen zu Eigentümern und Resolvern bereitstellt, wie in EIP-137 beschrieben. Lesen Sie mehr auf ens.domains.",
+ "erc-1155-term": "ERC-1155",
+ "erc-1155-definition": "ERC-1155 ist ein neuerer Typ von Ethereum-Token-Standard, der NFT (wie einzigartige Sammlerstücke) ähnelt, aber auch die Erstellung austauschbarer Gegenstände (wie Währung) innerhalb eines einzigen Smart Contracts ermöglicht.
Dies macht es einfacher und effizienter, verschiedene Arten von digitalen Vermögenswerten zu verwalten, insbesondere für Anwendungen wie Videospiele oder digitale Sammlungen.",
+ "erc-20-term": "ERC-20",
+ "erc-20-definition": "ERC-20 ist der Standard, den die meisten Token im Ethereum-Netzwerk für ihre Erstellung verwenden.
Beliebte Beispiele sind Stablecoins wie DAI und USDC oder Börsen-Token wie UNI von Uniswap. Ähnlich wie jede Form alternativer Gelder, die wir in traditionellen Systemen haben … d. h. Belohnungspunkte, Kreditsysteme oder sogar Aktien usw.",
+ "erc-721-term": "ERC-721",
+ "erc-721-definition": "NFTs (nicht-fungible Token) werden nach einem Standardregelwerk erstellt, das als ERC-721 bezeichnet wird.
NFT-Token können den Besitz von allem Einzigartigen repräsentieren, wie z. B. digitale Kunst oder Sammlerstücke, wobei jeder Token seine eigenen besonderen Eigenschaften und seinen eigenen Wert hat. Jedes NFT ist einzigartig und leicht von jedem anderen NFT zu unterscheiden.",
+ "execution-client-term": "Ausführungs-Client",
+ "execution-client-definition": "Ausführungs-Clients (früher als „Eth1-Clients“ bekannt), wie Besu, Erigon, Go-Ethereum (Geth), Nethermind, haben die Aufgabe, Transaktionen zu verarbeiten und zu verbreiten und den Zustand von Ethereum zu verwalten. Sie führen die Berechnungen für jede Transaktion mit der Ethereum Virtual Machine durch, um sicherzustellen, dass die Regeln des Protokolls eingehalten werden.",
+ "execution-layer-term": "Ausführungsebene",
+ "execution-layer-definition": "Die Ausführungsebene von Ethereum ist das Netzwerk der Ausführungsclients.",
+ "eoa-term": "Extern geführtes Konto (EOA)",
+ "eoa-definition": "Externally Owned Accounts (EOAs) sind der häufigste Typ von Ethereum-Konten. Sie werden von einer Person durch private Schlüssel/Wiederherstellungsphrase kontrolliert. Mehr über Ethereum-Wallets.",
+ "erc-term": "Ethereum-Anfrage zur Kommentierung (ERC)",
+ "erc-definition": "ERC (Ethereum Request for Comments) ist eine Art technischer Dokumentation, die in der Ethereum-Community verwendet wird, um neue Nutzungsstandards für das Ethereum-Netzwerk vorzuschlagen.
Diese Vorschläge können ein breites Themenspektrum abdecken, einschließlich neuer Token-Standards (wie ERC-20 für Token und ERC-721 für NFTs).",
+ "ethash-term": "Ethash",
+ "ethash-definition": "Ein Proof-of-Work-Algorithmus, der auf Ethereum verwendet wurde, bevor es auf Proof-of-Stake umgestellt wurde. Lesen Sie mehr",
+ "ether-term": "Ether",
+ "ether-definition": "Die native Kryptowährung von Ethereum, die üblicherweise als „ETH“ bezeichnet wird. Sie wird verwendet, um Transaktionsgebühren zu decken, wenn das Ethereum-Ökosystem und Anwendungen verwendet werden. Mehr über Ether.",
+ "events-term": "Ereignisse",
+ "events-definition": "Ermöglicht die Verwendung von EVM-Protokollierungseinrichtungen. Dapps können auf Ereignisse lauschen und sie verwenden, um JavaScript-Callbacks in der Benutzeroberfläche auszulösen. Mehr über Ereignisse und Protokolle",
+ "evm-term": "Ethereum Virtuelle Maschine (EVM)",
+ "evm-definition": "Eine stapelbasierte virtuelle Maschine, die Bytecode ausführt. In Ethereum gibt das Ausführungsmodell an, wie der Systemzustand angesichts einer Reihe von Bytecode-Anweisungen und eines kleinen Tupels von Umgebungsdaten geändert wird. Dies wird durch ein formales Modell einer virtuellen Zustandsmaschine spezifiziert. Mehr über die Ethereum Virtual Machine.",
+ "evm-assembly-language-term": "EVM-Assemblysprache",
+ "evm-assembly-language-definition": "Eine für Menschen lesbare Form von EVM Bytecode.",
+ "fallback-function-term": "Fallback-Funktion",
+ "fallback-function-definition": "Eine Standardfunktion, die aufgerufen wird, wenn keine Daten vorhanden sind oder ein deklarierter Funktionsname fehlt.",
+ "faucet-term": "Faucet",
+ "faucet-definition": "Ein Service, der über einen Smart Contract ausgeführt wird und Geldmittel in Form von kostenlosem Test-Ether, das in einem Testnetzwerk verwendet wird, bereitstellt.",
+ "finality-term": "Endgültigkeit",
+ "finality-definition": "Finalität ist die Garantie, dass eine Reihe von Transaktionen nicht geändert werden kann, ohne dass eine riesige Menge an ETH verloren geht.",
+ "finney-term": "Finney",
+ "finney-definition": "Eine Denomination von Ether. 1 Finney = 1015 Wei. 103 Finney = 1 Ether.",
+ "fork-term": "Fork",
+ "fork-definition": "Eine Änderung im Protokoll, die die Erstellung einer alternativen Chain verursacht.",
+ "fork-choice-algorithm-term": "Fork-Choice-Algorithmus",
+ "fork-choice-algorithm-definition": "Der Algorithmus, der verwendet wird, um den Kopf der Blockchain zu identifizieren. Auf Ethereum wird der Kopf der Kette als der Fork mit dem größten „Gewicht“ an Attestierungen identifiziert. Das Gewicht ist das Produkt aus der Anzahl der Attestierungen und dem effektiven Guthaben der attestierenden Validatoren. Dies bedeutet, dass der wahre Kopf der Kette derjenige ist, für den der meiste gestakte Ether gestimmt hat. Auf der Konsens-Ebene wird der Fork-Choice-Algorithmus LMD_GHOST genannt.",
+ "fraud-proof-term": "Betrugsbeweis",
+ "fraud-proof-definition": "Ein Sicherheitsmodell für bestimmte Layer-2-Lösungen, bei denen zur Beschleunigung Transaktionen in Batches gebündelt und in einer einzigen Transaktion an Ethereum übermittelt werden. Andere Netzwerkteilnehmer können die Transaktionen erneut ausführen, um zu überprüfen, ob sie ehrlich ausgeführt wurden. Wenn sie eine Diskrepanz zwischen den veröffentlichten Daten und ihrer eigenen Version aufdecken, können sie einen kryptographischen Beweis veröffentlichen, der zeigt, wo ein Betrug stattgefunden hat. Einige Rollups verwenden Gültigkeitsbeweise.",
+ "frontier-term": "Frontier",
+ "frontier-definition": "Die erste Phase der Testentwicklung von Ethereum, die von Juli 2015 bis März 2016 andauerte.",
+ "gas-term": "Gas",
+ "gas-definition": "Gas ist die Gebühr, die für Transaktionen und Smart Contracts auf einer Blockchain wie Ethereum bezahlt wird. Mehr über Gas und Gebühren.",
+ "gas-limit-term": "Gaslimit",
+ "gas-limit-definition": "Die maximale Menge an Gas, die eine Transaktion oder ein Block verbrauchen kann.",
+ "gas-price-term": "Gaspreis",
+ "gas-price-definition": "Preis in Ether von einer Einheit an Gas, der innerhalb einer Transaktion spezifiziert wurde.",
+ "genesis-block-term": "Genesis-Block",
+ "genesis-block-definition": "Der allererste Block in einer Blockchain, der verwendet wird, um ein bestimmtes Netzwerk und seine Kryptowährung zu initialisieren.",
+ "geth-term": "Geth",
+ "geth-definition": "Go Ethereum. Eine der bekanntesten Implementierungen des Ethereum-Protokolls, geschrieben in Go. Lesen Sie mehr auf geth.ethereum.org",
+ "gwei-term": "Gwei",
+ "gwei-definition": "Kurz für Gigawei, eine Denomination von Ether, die üblicherweise zur Preisgestaltung von Gas verwendet wird. 1 Gwei = 109 Wei. 109 Gwei = 1 Ether.",
+ "hard-fork-term": "Hard Fork",
+ "hard-fork-definition": "Eine permanente Abweichung in der Blockchain; auch als Hard-Fork-Änderung bekannt. Eine solche tritt häufig auf, wenn nicht aktualisierte Nodes keine Blöcke validieren können, die von aktualisierten Nodes erstellt wurden, die neueren Konsensregeln folgen. Nicht zu verwechseln mit einem Fork, Soft Fork, Software-Fork oder Git-Fork.",
+ "hash-term": "Hash",
+ "hash-definition": "Ein Fingerabdruck mit fester Länge einer Eingabe variabler Größe, der von einer Hash-Funktion erzeugt wird. (Siehe Keccak-256).",
+ "hash-rate-term": "Hashrate",
+ "hash-rate-definition": "Die Anzahl der Hashberechnungen pro Sekunde durch Computer mit Mining-Software.",
+ "homestead-term": "Homestead",
+ "holographic-consensus-term": "Holographischer Konsens",
+ "holographic-consensus-definition": "Bezieht sich darauf, wie eine große Gruppenentscheidung getroffen wird, indem eine kleinere Gruppe von repräsentativen Personen abstimmen darf. Alle anderen stimmen dann zu, dem zu folgen, solange sie darauf vertrauen, dass die kleine Gruppe gute Arbeit geleistet hat.
Es wird in einigen Online-Communitys verwendet, um Entscheidungen schnell zu treffen, ohne dass jeder über alles abstimmen muss, während gleichzeitig sichergestellt wird, dass die Entscheidungen fair sind und das repräsentieren, was die meisten Menschen wollen.",
+ "homestead-definition": "Die zweite Entwicklungsphase von Ethereum. Sie begann im März 2016 mit Block 1.150.000.",
+ "index-term": "Index",
+ "index-definition": "Eine Netzwerkstruktur, die die Abfrage von Informationen aus der gesamten Blockchain optimieren soll, indem sie einen effizienten Pfad zu ihrer Speicherquelle bereitstellt.",
+ "ide-term": "Integrierte Entwicklungsumgebung (IDE)",
+ "ide-definition": "Eine Benutzeroberfläche, die typischerweise einen Code-Editor, Compiler, eine Laufzeitumgebung und einen Debugger kombiniert. Mehr über integrierte Entwicklungsumgebungen.",
+ "immutable-deployed-code-problem-term": "Problem des unveränderlichen bereitgestellten Codes",
+ "immutable-deployed-code-problem-definition": "Sobald der Code eines Vertrags (oder einer Bibliothek) bereitgestellt ist, wird er unveränderlich. Standardmäßige Softwareentwicklungspraktiken beruhen darauf, mögliche Fehler beheben und neue Funktionen hinzufügen zu können, daher stellt dies eine Herausforderung für die Entwicklung von Smart Contracts dar. Mehr über die Bereitstellung von Smart Contracts.",
+ "internal-transaction-term": "Interne Transaktion",
+ "internal-transaction-definition": "Eine Transaktion wurde von einem Vertragskonto an ein anderes Vertragskonto oder eine EOA gesendet (siehe Nachricht).",
+ "issuance-term": "Ausgabe",
+ "issuance-definition": "Das Prägen von neuem Ether, um das Vorschlagen von Blöcken, deren Attestierung und Überprüfung zu belohnen.",
+ "kdf-term": "Schlüsselableitungsfunktion (Key Derivation Function, KDF)",
+ "kdf-definition": "Auch bekannt als „Passwort-Stretching-Algorithmus\", wird sie von Keystore-Formaten zum Schutz vor Brute-Force-, Wörterbuch- und Rainbow-Table-Angriffen auf Passphrasen-Verschlüsselung verwendet, indem wiederholt die Passphrase gehasht wird.",
+ "keystore-term": "Schlüsseldatei",
+ "keystore-definition": "Das Paar aus privatem Schlüssel und Adresse jedes Kontos existiert als einzelne Schlüsseldatei in einem Ethereum-Client. Dies sind JSON-Textdateien, die den verschlüsselten privaten Schlüssel des Kontos enthalten, der nur mit dem bei der Kontoerstellung eingegebenen Passwort entschlüsselt werden kann.",
+ "keccak-256-term": "Keccak-256",
+ "keccak-256-definition": "Kryptographische Hash-Funktion, die in Ethereum verwendet wird. Keccak-256 wurde als SHA-3 standardisiert.",
+ "key-term": "Schlüssel",
+ "key-definition": "Im Kontext von Ethereum sind Schlüssel digitale Codes: ein öffentlicher Schlüssel zum Empfangen von Transaktionen und ein privater Schlüssel zum Zugreifen auf und Senden von Geldern.
Öffentliche Schlüssel: Diese können offen geteilt werden.
Private Schlüssel: Diese werden vom Besitzer geheim gehalten.",
+ "layer-1-term": "Layer 1 (Ebene 2)",
+ "layer-1-definition": "Layer 1 bezieht sich auf die Haupt-Blockchain in einem mehrstufigen Blockchain-Netzwerk. Zum Beispiel sind Ethereum und Bitcoin Layer-1-Blockchains. Viele Layer-2-Blockchains lagern ressourcenintensive Transaktionen auf ihre separate Blockchain aus, während sie weiterhin die Layer-1-Blockchain von Ethereum oder Bitcoin für Sicherheitszwecke nutzen.",
+ "layer-2-term": "Ebene 2",
+ "layer-2-definition": "Layer 2 sind weitere Netzwerke, die auf dem Ethereum-Hauptnetzwerk aufbauen, um Transaktionen schneller und günstiger zu machen. Mehr über Layer 2.",
+ "library-term": "Bibliothek",
+ "library-definition": "Eine spezielle Art von Vertrag, der keine zahlbaren Funktionen, keine Fallback-Funktion und keinen Datenspeicher hat. Daher kann er weder Ether empfangen oder halten noch Daten speichern. Eine Bibliothek dient als zuvor bereitgestellter Code, den andere Verträge für schreibgeschützte Berechnungen aufrufen können. Mehr über Smart-Contract-Bibliotheken.",
+ "light-client-term": "Light-Client",
+ "light-client-definition": "Ein Ethereum-Client, der keine lokale Kopie der Blockchain speichert oder Blöcke und Transaktionen validiert. Er bietet die Funktionen einer Wallet und kann Transaktionen erstellen und senden.",
+ "liquidity-term": "Liquidität",
+ "liquidity-definition": "Liquidität ist, wie schnell und einfach ein Vermögenswert in Bargeld oder einen anderen Vermögenswert umgewandelt werden kann. Dezentralisierte Börsen wie Uniswap haben mehrere Liquiditätspools, in die Vermögensinhaber ihre Vermögenswerte einzahlen können, wo Händler sie auf dezentralisierte Weise gegen Belohnungen kaufen und verkaufen können.",
+ "liquidity-tokens-term": "Liquiditäts-Token",
+ "liquidity-tokens-definition": "Liquiditätstoken (LST) sind digitale Token, die an Teilnehmer ausgegeben werden, die Vermögenswerte in einen Liquiditätspool einzahlen, bei dem es sich um eine Sammlung von Geldern handelt, die in einem Smart Contract gesperrt sind und zur Erleichterung des Handels an einer dezentralisierten Börse (DEX) verwendet werden.
Diese Token repräsentieren den Anteil des Teilnehmers am Pool und können später gegen die ursprüngliche Einlage plus einen Teil der durch die Aktivität des Pools generierten Handelsgebühren eingelöst werden. Im Wesentlichen dienen Liquiditätstoken als Eigentums- oder Anteilsnachweis an einem Liquiditätspool, der es den Inhabern ermöglicht, Belohnungen zu verdienen, während sie die notwendige Liquidität für andere bereitstellen, um verschiedene Kryptowährungspaare effizient zu handeln.",
+ "liquid-staking-tokens-term": "Liquid Staking Tokens",
+ "liquid-staking-tokens-definition": "Ein Derivat-Token, der den Besitz der gesperrten Kryptowährung repräsentiert, die ein Benutzer stakt. Nach dem Staken eines Vermögenswerts ermöglichen einige Plattformen das Minten von Liquid Staking Tokens (LSTs), die einen entsprechenden Anteil an den gesperrten Token repräsentieren. Diese LSTs können dann gehandelt, verkauft oder in anderen DeFi-Protokollen verwendet werden, was die Kapitaleffizienz für den Staker verbessert, indem der Zugang zu Liquidität aus seinen Mitteln ermöglicht wird, auch während seine ursprünglichen Vermögenswerte gestakt bleiben.",
+ "lmd-ghost-term": "LMD-GHOST",
+ "lmd-ghost-definition": "Der Fork-Choice-Algorithmus, der von den Konsens-Clients von Ethereum verwendet wird, um den Kopf der Kette zu identifizieren. LMD-GHOST ist ein Akronym für „Latest Message Driven Greediest Heaviest Observed SubTree“, was bedeutet, dass der Kopf der Kette der Block mit der größten Anhäufung von Attestierungen in seiner Geschichte ist.",
+ "mainnet-term": "Mainnet (Hauptnetz)",
+ "mainnet-definition": "Kurz für „Hauptnetzwerk“, dies ist die öffentliche Haupt-Blockchain von Ethereum.",
+ "max-fee-per-gas-term": "Max Fee Per Gas",
+ "max-fee-per-gas-definition": "Die Max Fee ist der absolute Höchstbetrag, den ein Nutzer bereit ist, pro Gaseinheit (gwei) zu zahlen, um eine Transaktion in einen Block aufzunehmen.",
+ "merkle-patricia-tree-term": "Merkle-Patricia-Tree (MPT)",
+ "merkle-patricia-tree-definition": "Eine Datenstruktur, die in Ethereum verwendet wird, um Schlüssel-Wert-Paare effizient zu speichern.",
+ "merkle-root-term": "Merkle-Root",
+ "merkle-root-definition": "Ein Merkle-Root ist der einzelne oberste Hash eines Merkle-Trees. Er verifiziert alle Transaktionen innerhalb eines Blocks.",
+ "message-term": "Nachricht",
+ "message-definition": "Eine interne Transaktion, die niemals serialisiert und nur innerhalb der EVM gesendet wird.",
+ "message-call-term": "Nachrichtenaufruf",
+ "message-call-definition": "Der Akt der Übermittlung einer Nachricht von einem Konto an ein anderes. Wenn das Zielkonto mit EVM-Code verknüpft ist, wird die VM mit dem Zustand dieses Objekts gestartet und die Nachricht wird ausgeführt.",
+ "mev-term": "Maximal extrahierbarer Wert (MEV)",
+ "mev-definition": "Der maximale Wert, der aus der Blockproduktion über die Standard-Block-Belohnung und Gasgebühren hinaus extrahiert werden kann, indem Transaktionen in einem Block ein-, ausgeschlossen und deren Reihenfolge geändert wird. Mehr über den maximal extrahierbaren Wert (MEV).",
+ "mining-term": "Mining",
+ "mining-definition": "Der Prozess, bei dem ein Block-Header wiederholt gehasht wird, während eine Nonce inkrementiert wird, bis das Ergebnis eine beliebige Anzahl führender binärer Nullen enthält. Dies ist der Prozess, durch den neue Blöcke einer Proof-of-Work-Blockchain hinzugefügt werden. So wurde Ethereum gesichert, bevor es zu Proof-of-Stake wechselte.",
+ "miner-term": "Miner",
+ "miner-definition": "Ein Netzwerk-Node, der gültige Proof-of-Work für neue Blöcke findet, indem er wiederholt Hash-Vorgänge durchführt (siehe Ethash). Miner sind nicht mehr Teil von Ethereum - sie wurden durch Validatoren ersetzt, als Ethereum auf Proof-of-Stake umstellte.",
+ "mint-term": "Mint",
+ "mint-definition": "Minting ist der Prozess, neue Token zu erstellen und in Umlauf zu bringen, damit sie verwendet werden können. Es ist ein dezentraler Mechanismus, um einen neuen Token ohne die Beteiligung einer zentralen Autorität zu erstellen.",
+ "multisig-term": "Multisig",
+ "multisig-definition": "Multisig (Multi-Signatur) bezieht sich auf eine digitale Wallet oder ein Konto, das mehrere Signaturen oder Genehmigungen zur Ausführung von Transaktionen erfordert, was die Sicherheit erhöht.
Dies fügt zusätzliche Sicherheit im Vergleich zu traditionellen Einzelsignatur-Konten hinzu, bei denen nur die Genehmigung einer Person erforderlich ist.",
+ "network-term": "Netzwerk",
+ "network-definition": "Bezieht sich auf das Ethereum-Netzwerk, ein Peer-to-Peer-Netzwerk, das Transaktionen und Blöcke an jeden Ethereum-Node (Netzwerkteilnehmer) weiterleitet. Mehr zu Netzwerken.",
+ "network-hashrate-term": "Netzwerk-Hashrate",
+ "network-hashrate-definition": "Die kollektive Hashrate, die von einem gesamten Mining-Netzwerk erzeugt wird. Das Mining auf Ethereum wurde abgeschaltet, als Ethereum zu Proof-of-Stake wechselte.",
+ "nft-term": "Nicht-fungibler Token (NFT)",
+ "nft-definition": "Ein einzigartiger digitaler Gegenstand, den Sie besitzen können, wie Kunst oder Sammlerstücke, verifiziert durch Blockchain-Technologie. Mehr zu nicht-fungiblen Token (NFTs).",
+ "node-term": "Node",
+ "node-definition": "Ein Software-Client, der am Netzwerk teilnimmt. Mehr über Nodes und Clients.",
+ "nonce-term": "Nonce",
+ "nonce-definition": "In der Kryptographie ein Wert, der nur einmal verwendet werden kann. Eine Konto-Nonce ist ein Transaktionszähler in jedem Konto, der verwendet wird, um Replay-Angriffe zu verhindern.",
+ "offchain-term": "Off-Chain",
+ "offchain-definition": "Offchain bedeutet jede Transaktion oder Daten, die außerhalb der Blockchain existieren. Da die Durchführung jeder Transaktion Onchain teuer und ineffizient sein kann, übernehmen Drittanbieter-Tools wie Oracles, die Preisdaten verarbeiten, oder Layer-2-Lösungen, die einen höheren Transaktionsdurchsatz ausführen, einen Großteil der Verarbeitungsarbeit Offchain und übermitteln Informationen in weniger häufigen Intervallen Onchain.",
+ "ommer-term": "Ommer-(Onkel-)Block",
+ "ommer-definition": "Wenn ein Proof-of-Work-Miner einen gültigen Block findet, kann ein anderer Miner einen konkurrierenden Block veröffentlicht haben, der zuerst zur Spitze der Blockchain hinzugefügt wird. Dieser gültige, aber veraltete Block kann von neueren Blöcken als Ommers aufgenommen werden und eine teilweise Block-Belohnung erhalten. Der Begriff „Ommer“ ist die bevorzugte geschlechtsneutrale Bezeichnung für das Geschwister eines Elternblocks, wird aber manchmal auch als „Uncle“ bezeichnet. Dies war bei Ethereum üblich, als es noch ein Proof-of-Work-Netzwerk war. Da Ethereum nun Proof-of-Stake verwendet, wird pro Slot nur ein Block-Vorschlagender ausgewählt.",
+ "onchain-term": "Onchain",
+ "onchain-definition": "Bezieht sich auf Aktionen oder Transaktionen, die auf der Blockchain stattfinden und öffentlich zugänglich sind.
Man kann es sich wie das Schreiben in ein großes, gemeinsames Notizbuch vorstellen, das jeder einsehen und überprüfen kann. Dadurch wird sichergestellt, dass alles Geschriebene (wie das Senden von digitalem Geld oder das Erstellen eines Vertrags) dauerhaft ist und nicht geändert oder gelöscht werden kann.",
+ "optimistic-rollup-term": "Optimistische Rollups",
+ "optimistic-rollup-definition": "Optimistic Rollup ist eine Layer-2-Lösung, die Transaktionen auf Ethereum beschleunigt, indem sie standardmäßig als gültig angenommen werden, sofern sie nicht angefochten werden. Mehr über Optimistic Rollups.",
+ "oracle-term": "Orakel",
+ "oracle-definition": "Ein Oracle ist eine Brücke zwischen der Blockchain und der realen Welt. Sie fungieren als Onchain-APIs, die nach Informationen abgefragt und in Smart Contracts verwendet werden können. Mehr über Oracles.",
+ "peer-term": "Peer",
+ "peer-definition": "Verbundene Computer mit Ethereum Client-Software und identischen Kopien der Blockchain.",
+ "peer-to-peer-network-term": "Peer-to-Peer-Netzwerk",
+ "peer-to-peer-network-definition": "Ein Netzwerk von Computern (Peers), die gemeinsam in der Lage sind, Funktionalitäten ohne die Notwendigkeit zentralisierter, serverbasierter Dienste auszuführen.
Diese Einrichtung wird häufig zum Teilen von Dateien (z. B. BitTorrent), Informationen oder digitalen Währungen verwendet und ermöglicht einen direkteren und potenziell effizienteren Austausch zwischen Benutzern.",
+ "permissionless-term": "Genehmigungsfrei",
+ "permissionless-definition": "Permissionless bedeutet, dass jeder einem System wie Ethereum beitreten und es nutzen kann. Es ist offen für alle zur Teilnahme und erfordert keine Genehmigung.",
+ "plasma-term": "Plasma",
+ "plasma-definition": "Eine Offchain-Skalierungslösung, die Betrugsbeweise verwendet, wie Optimistic Rollups. Plasma ist auf einfache Transaktionen wie grundlegende Token-Übertragungen und Swaps beschränkt. Mehr über Plasma.",
+ "private-key-term": "Privater Schlüssel",
+ "private-key-definition": "Ein privater Schlüssel ist ein geheimer Code, der beweist, dass Sie Ihr digitales Geld besitzen und es Ihnen ermöglicht, es auszugeben, wie eine PIN für Ihr Konto. TEILEN SIE IHN NICHT.",
+ "public-goods-term": "Öffentliche Güter",
+ "public-goods-definition": "Öffentliche Güter sind Dinge, die jeder kostenlos nutzen kann, wie Parks oder saubere Luft, und deren Nutzung andere nicht daran hindert, sie ebenfalls zu nutzen. Regierungen stellen diese oft zur Verfügung, weil Unternehmen dies in der Regel nicht tun, da sie die Menschen nicht einfach für deren Nutzung zur Kasse bitten können.",
+ "private-chain-term": "Private Chain",
+ "private-chain-definition": "Eine vollständig private Blockchain ist eine Blockchain mit erlaubtem Zugriff, die nicht öffentlich für den Gebrauch zugänglich ist.",
+ "poap-term": "POAP",
+ "poap-definition": "Das Proof of Attendance Protocol wird verwendet, um ein digitales Sammlerstück (NFT) zu erstellen, das beweist, dass Sie an einer bestimmten Veranstaltung oder Aktivität teilgenommen haben.",
+ "pos-term": "Proof-of-Stake (PoS)",
+ "pos-definition": "Eine Methode, mit der ein Kryptowährungs-Blockchain-Protokoll einen verteilten Konsens erreichen will. PoS fordert Benutzer auf, den Besitz einer bestimmten Menge an Kryptowährung (ihren „Stake“ im Netzwerk) nachzuweisen, um an der Validierung von Transaktionen teilnehmen zu können. Mehr über Proof-of-Stake.",
+ "pow-term": "Proof-of-Work (PoW)",
+ "pow-definition": "Ein Sicherheitsmechanismus für Blockchains, der von Nodes verlangt, Energie in Form von Rechenleistung aufzuwenden, um einen bestimmten Wert zu finden.",
+ "proto-danksharding-term": "Proto-Danksharding",
+ "proto-danksharding-definition": "Ein neuer Transaktionstyp, der „Blobs“ von Daten für Ethereum akzeptiert. Diese „Blob“-Daten werden vorübergehend auf der Beacon-Chain für 4096 Epochen (~18,2 Tage) gespeichert und können optional danach beschnitten werden, um die Hardwareanforderungen für Node-Betreiber zu reduzieren.",
+ "public-key-term": "Öffentlicher Schlüssel",
+ "public-key-definition": "Ein öffentlicher Schlüssel ist eine Zeichenfolge, die es anderen ermöglicht, Ihnen sicher digitale Währung zu senden, wie eine E-Mail-Adresse für Geld.",
+ "quadratic-voting-term": "Quadratische Abstimmung",
+ "quadratic-voting-definition": "Ist eine Abstimmungsmethode, bei der die Wähler ausdrücken, wie stark sie sich zu Themen fühlen. Es ermöglicht den Wählern, nicht nur ihre Präferenz, sondern auch die Intensität ihrer Präferenz zu zeigen.",
+ "receipt-term": "Beleg",
+ "receipt-definition": "Von einem Ethereum-Client herausgegebene Daten, um das Ergebnis einer bestimmten Transaktion zu repräsentieren, mit einem Hash der Transaktion, deren Blocknummer, der verbrauchten Menge an Gas und, im Fall des Einsatzes eines Smart Contracts, der Adresse des Vertrags.",
+ "recovery-phrase-term": "Seed-Phrase/Wiederherstellungsphrase",
+ "recovery-phrase-definition": "Eine Liste von Wörtern, die Ihnen beim Erstellen einer digitalen Wallet gegeben wird. Sie fungiert wie ein Passwort, mit dem Sie wieder in Ihre Wallet gelangen können, wenn Sie den Zugriff verlieren, um sicherzustellen, dass Sie Ihr digitales Geld oder Ihre Token nicht verlieren.",
+ "re-entrancy-attack-term": "Wiedereintrittsangriff",
+ "re-entrancy-attack-definition": "Ein Angriff, bei dem ein Angreifervertrag eine Funktion eines Opfervertrags so aufruft, dass das Opfer während der Ausführung den Angreifervertrag erneut rekursiv aufruft. Dies kann zum Beispiel zum Diebstahl von Geldern führen, indem Teile des Opfervertrags übersprungen werden, die Guthaben aktualisieren oder Abhebungsbeträge zählen. Mehr über Wiedereintritt.",
+ "reward-term": "Belohnung",
+ "reward-definition": "Ein Betrag an Ether, der an Validatoren vergeben wird, die bestimmte Funktionen ausführen, einschließlich des Vorschlagens eines Blocks oder der Teilnahme an einem Sync-Komitee, in jedem Slot.",
+ "rlp-term": "Recursive Length Prefix (RLP)",
+ "rlp-definition": "Ein von den Ethereum-Entwicklern entworfener Kodierungsstandard zur Kodierung und Serialisierung von Objekten (Datenstrukturen) beliebiger Komplexität und Länge.",
+ "rollups-term": "Gruppierungen (Rollups)",
+ "rollups-definition": "Eine Art von Layer-2-Skalierungslösung, die mehrere Transaktionen bündelt und sie in einer einzigen Transaktion an die Ethereum-Hauptkette übermittelt. Dies ermöglicht eine Reduzierung der Gaskosten und eine Erhöhung des Transaktionsdurchsatzes. Es gibt Optimistic- und Zero-Knowledge-Rollups, die unterschiedliche Sicherheitsmethoden verwenden, um diese Skalierbarkeitsgewinne zu bieten. Mehr über Rollups.",
+ "rpc-term": "Remote Procedure Call (RPC)",
+ "rpc-definition": "RPC ermöglicht es einem Computer, Daten oder Aktionen von einem anderen über ein Netzwerk anzufordern, wie das Abfragen von Informationen mit einer Fernbedienung.",
+ "sha-term": "Sicherer Hash-Algorithmus (SHA)",
+ "sha-definition": "Eine Familie kryptografischer Hashfunktionen, die vom National Institute of Standards and Technologe (NIST) veröffentlicht wurde.",
+ "serialization-term": "Serialisierung",
+ "serialization-definition": "Der Prozess der Umwandlung einer Datenstruktur in eine Sequenz von Bytes.",
+ "sequencer-term": "Sequencer",
+ "sequencer-definition": "Ein Sequencer ist ein Programm, das für die Anordnung von Transaktionen in einem Blockchain-Netzwerk verantwortlich ist, insbesondere innerhalb von Layer-2-Skalierungslösungen.",
+ "shard-term": "Shard / Shard-Chain",
+ "shard-definition": "Shard-Chains sind diskrete Abschnitte der gesamten Blockchain, für die Untergruppen von Validatoren verantwortlich sein können. Dies war ursprünglich als der Weg gedacht, wie Ethereum auf Millionen von Transaktionen pro Sekunde skalieren sollte, wurde aber inzwischen durch die schnelle Entwicklung der Skalierung mit Rollups abgelöst.",
+ "sidechain-term": "Sidechain",
+ "sidechain-definition": "Eine Skalierungslösung, die eine separate Kette mit unterschiedlichen, oft schnelleren Konsensregeln verwendet. Eine Brücke wird benötigt, um diese Sidechains mit dem Mainnet zu verbinden. Rollups verwenden ebenfalls Sidechains, arbeiten aber im Gegensatz dazu in Zusammenarbeit mit dem Mainnet. Mehr über Sidechains.",
+ "signing-term": "Signieren",
+ "signing-definition": "Kryptografisch demonstrieren, dass eine Transaktion vom Inhaber eines bestimmten privaten Schlüssels genehmigt wurde.",
+ "singleton-term": "Singleton",
+ "singleton-definition": "Ein Programmierbegriff, der ein Objekt beschreibt, von dem nur eine Instanz existieren kann.",
+ "slasher-term": "Slasher",
+ "slasher-definition": "Ein Slasher ist eine Entität, die Attestierungen scannt und nach strafbaren Vergehen sucht. Slashings werden an das Netzwerk gesendet, und der nächste Block-Vorschlagende fügt den Beweis zum Block hinzu. Der Block-Vorschlagende erhält dann eine Belohnung für das Slashen des bösartigen Validators.",
+ "slot-term": "Slot",
+ "slot-definition": "Ein Zeitraum (12 Sekunden), in dem neue Blöcke von einem Validator im Proof-of-Stake-System vorgeschlagen werden können. Ein Slot kann leer sein. 32 Slots bilden eine Epoche. Mehr zu Proof-of-Stake.",
+ "smart-contract-term": "Smart Contract",
+ "smart-contract-definition": "Ein Smart Contract ist ein Programm, das Vereinbarungen auf einer Blockchain automatisch ausführt, wie ein selbstausführender digitaler Vertrag. Einführung in Smart Contracts.",
+ "snark-term": "SNARK",
+ "snark-definition": "Kurz für „succinct non-interactive argument of knowledge“, ein SNARK ist eine Art von Zero-Knowledge-Beweis. Mehr über Zero-Knowledge-Rollups.",
+ "soft-fork-term": "Soft Fork",
+ "soft-fork-definition": "Eine Abweichung in einer Blockchain, die auftritt, wenn sich die Konsensregeln ändern. Im Gegensatz zu einem Hard Fork ist ein Soft Fork abwärtskompatibel; aktualisierte Nodes können Blöcke validieren, die von nicht aktualisierten Nodes erstellt wurden, solange sie den neuen Konsensregeln folgen.",
+ "solidity-term": "Solidity",
+ "solidity-definition": "Eine prozedurale (imperative) Programmiersprache mit einer Syntax, die JavaScript, C++ oder Java ähnelt. Die beliebteste und am häufigsten verwendete Sprache für Ethereum-Smart Contracts. Erstellt von Dr. Gavin Wood. Mehr über Solidity.",
+ "solidity-inline-assembly-term": "Solidity Inline Assembly",
+ "solidity-inline-assembly-definition": "EVM-Assemblersprache in einem Solidity-Programm. Die Unterstützung von Inline-Assembly in Solidity erleichtert das Schreiben bestimmter Operationen.",
+ "stablecoin-term": "Stablecoin",
+ "stablecoin-definition": "Ein Stablecoin ist eine Art von Kryptowährung, die so konzipiert ist, dass sie einen stabilen Wert hat, oft an eine Währung oder einen Rohstoff (wie den US-Dollar) gekoppelt, um Preisschwankungen zu minimieren. Mehr über Stablecoins.",
+ "staking-term": "Staking",
+ "staking-definition": "Einzahlung einer Menge Ether (Ihr Stake), um ein Validator zu werden und das Netzwerk zu sichern. Ein Validator überprüft Transaktionen und schlägt Blöcke in einem Proof-of-Stake-Konsensmodell vor. Das Staking gibt Ihnen einen wirtschaftlichen Anreiz, im besten Interesse des Netzwerks zu handeln. Sie erhalten Belohnungen für die Erfüllung Ihrer Validator-Pflichten, verlieren aber unterschiedliche Mengen an ETH, wenn Sie dies nicht tun. Mehr über Ethereum-Staking.",
+ "staking-pool-term": "Staking-Pool",
+ "staking-pool-definition": "Das kombinierte ETH von mehr als einem Ethereum-Staker, das verwendet wird, um die 32 ETH zu erreichen, die zur Aktivierung eines Satzes von Validator-Schlüsseln erforderlich sind. Ein Node-Betreiber verwendet diese Schlüssel, um am Konsens teilzunehmen, und die Block-Belohnungen werden unter den beitragenden Stakern aufgeteilt. Staking-Pools oder delegiertes Staking sind nicht nativ im Ethereum-Protokoll, aber viele Lösungen wurden von der Community entwickelt. Mehr über Pooled Staking.",
+ "stark-term": "STARK",
+ "stark-definition": "Kurz für „scalable transparent argument of knowledge“, ein STARK ist eine Art von Zero-Knowledge-Beweis. Mehr über Zero-Knowledge-Rollups.",
+ "state-term": "Zustand",
+ "state-definition": "Eine Momentaufnahme aller Salden und Daten auf der Blockchain zu einem bestimmten Zeitpunkt. Er bezieht sich normalerweise auf die Bedingung in einem bestimmten Block.",
+ "state-channels-term": "Zustandskanäle",
+ "state-channels-definition": "Eine Layer-2-Lösung, bei der ein Kanal zwischen den Teilnehmern eingerichtet wird, über den sie frei und kostengünstig Transaktionen durchführen können. Nur eine Transaktion zum Einrichten des Kanals und zum Schließen des Kanals wird an das Mainnet gesendet. Dies ermöglicht einen sehr hohen Transaktionsdurchsatz, erfordert jedoch, die Anzahl der Teilnehmer im Voraus zu kennen und Gelder zu sperren. Mehr über State Channels.",
+ "supermajority-term": "Qualifizierte Mehrheit",
+ "supermajority-definition": "Qualifizierte Mehrheit ist der Begriff für einen Betrag, der 2/3 (66 %) des gesamten gestaketen Ethers übersteigt, der Ethereum sichert. Eine qualifizierte Mehrheitsabstimmung ist erforderlich, damit Blöcke auf der Beacon-Chain finalisiert werden können.",
+ "sybil-attack-term": "Sybil Angriff",
+ "sybil-attack-definition": "Sybil-Angriffe beziehen sich auf einzelne Menschen, die das System glauben lassen wollen, sie seien mehrere Menschen, um ihren Einfluss zu erhöhen.",
+ "syncing-term": "Synchronisierung",
+ "syncing-definition": "Der Prozess des Herunterladens der gesamten neuesten Version einer Blockchain auf einen Node.",
+ "sync-committee-term": "Sync-Komitee",
+ "sync-committee-definition": "Ein Sync-Komitee ist eine zufällig ausgewählte Gruppe von Validatoren, die sich alle ~27 Stunden erneuert. Ihr Zweck ist es, ihre Signaturen zu gültigen Block-Headern hinzuzufügen. Sync-Komitees ermöglichen es Light-Clients, den Kopf der Blockchain zu verfolgen, ohne auf den gesamten Validator-Satz zugreifen zu müssen.",
+ "szabo-term": "Szabo",
+ "szabo-definition": "Eine Denomination von Ether. 1 Szabo = 1012 Wei. 106 Szabo = 1 Ether.",
+ "terminal-total-difficulty-term": "Terminale Gesamtschwierigkeit (Terminal Total Difficulty, TTD)",
+ "terminal-total-difficulty-definition": "Die Gesamtschwierigkeit ist die Summe der Ethash-Mining-Schwierigkeit für alle Blöcke bis zu einem bestimmten Punkt in der Blockchain. Die Terminal Total Difficulty (terminale Gesamtschwierigkeit) ist ein spezifischer Wert für die Gesamtschwierigkeit, der als Auslöser für Ausführungs-Clients diente, um ihre Mining- und Block-Gossip-Funktionen abzuschalten und dem Netzwerk den Übergang zu Proof-of-Stake zu ermöglichen. Sie ist nicht mehr relevant, da Ethereum zu Proof-of-Stake übergegangen ist.",
+ "testnet-term": "Testnet",
+ "testnet-definition": "Kurz für „Testnetzwerk“, ein Netzwerk, das verwendet wird, um das Verhalten des Hauptnetzwerks von Ethereum zu simulieren.",
+ "token-term": "Token",
+ "token-definition": "Ein handelbares virtuelles Gut, das in Smart Contracts auf der Ethereum-Blockchain definiert ist.",
+ "token-factory-term": "Token-Fabrik",
+ "token-factory-definition": "Eine Token-Fabrik ist ein Smart Contract, der die Erstellung von Token nach einem bestimmten Standard, wie ERC-20, ERC-721 oder ERC-1155, erleichtert. Der Smart Contract fungiert als Vorlage und ermöglicht es Benutzern, neue Token mit benutzerdefinierten Parametern wie Name, Symbol, Vorrat und zusätzlicher Funktionalität bereitzustellen, ohne einen neuen Smart Contract von Grund auf neu erstellen zu müssen.",
+ "transaction-term": "Transaktion",
+ "transaction-definition": "Daten, die der Ethereum-Blockchain übermittelt und von einem ursprünglichen Konto signiert wurden und auf eine bestimmte Adresse abzielen. Die Transaktion enthält Metadaten wie das Gaslimit für diese Transaktion. Mehr über Transaktionen.",
+ "transaction-fee-term": "Transaktionsgebühr",
+ "transaction-fee-definition": "Eine Gebühr, die Sie zahlen müssen, wann immer Sie das Ethereum-Netzwerk nutzen. Beispiele sind das Senden von Geldern aus Ihrer Wallet oder eine Dapp-Interaktion, wie das Tauschen von Token oder der Kauf eines Sammlerstücks. Sie können sich dies wie eine Servicegebühr vorstellen. Diese Gebühr ändert sich je nachdem, wie ausgelastet das Netzwerk ist. Das liegt daran, dass Validatoren, die für die Verarbeitung Ihrer Transaktion verantwortlich sind, wahrscheinlich Transaktionen mit höheren Gebühren priorisieren – so treibt die Überlastung den Preis in die Höhe.
Auf technischer Ebene bezieht sich Ihre Transaktionsgebühr darauf, wie viel Gas Ihre Transaktion benötigt.
Die Reduzierung der Transaktionsgebühren ist derzeit ein Thema von großem Interesse. Siehe Layer 2.",
+ "trust-assumptions-term": "Vertrauensannahme",
+ "trust-assumptions-definition": "Vertrauensannahmen sind grundlegende Überzeugungen über die Sicherheit und Zuverlässigkeit eines Systems, die leiten, worauf wir vertrauen, damit das System funktioniert.",
+ "trustlessness-term": "Vertrauenslosigkeit",
+ "trustlessness-definition": "Die Fähigkeit eines Netzwerkes, Transaktionen zu vermitteln, ohne dass eine der beteiligten Parteien einem Dritten vertrauen muss.",
+ "turing-complete-term": "Turing vollständig",
+ "turing-complete-definition": "Ein nach dem englischen Mathematiker und Informatiker Alan Turing benanntes Konzept: Ein System von Datenmanipulationsregeln (z. B. der Befehlssatz eines Computers, eine Programmiersprache oder ein Zellularautomat) gilt als „Turing complete“ oder „computationally universal“, wenn es zur Simulation einer beliebigen Turing-Maschine verwendet werden kann.",
+ "validator-term": "Validator",
+ "validator-definition": "Ein Node in einem Proof-of-Stake-System, der für die Speicherung von Daten, die Verarbeitung von Transaktionen und das Hinzufügen neuer Blöcke zur Blockchain verantwortlich ist. Um die Validator-Software zu aktivieren, müssen Sie in der Lage sein, 32 ETH zu staken. Mehr über das Staking in Ethereum.",
+ "validator-lifecycle-term": "Validator-Lebenszyklus",
+ "validator-lifecycle-definition": "Die Abfolge von Zuständen, in denen ein Validator existieren kann. Dazu gehören:
- eingezahlt: Mindestens 32 ETH wurden vom Validator in den Einzahlungsvertrag eingezahlt
- ausstehend: Der Validator befindet sich in der Aktivierungswarteschlange und wartet darauf, von bestehenden Validatoren ins Netzwerk gewählt zu werden
- aktiv: attestiert und schlägt derzeit Blöcke vor
- slashing: Der Validator hat sich fehlverhalten und wird geslasht
- verlassend: Der Validator wurde zum Verlassen des Netzwerks markiert, entweder freiwillig oder weil er ausgeworfen wurde.
",
+ "validity-proof-term": "Validitätsnachweis",
+ "validity-proof-definition": "Ein Sicherheitsmodell für bestimmte Layer-2-Lösungen, bei denen zur Beschleunigung Transaktionen in Batches gebündelt und in einer einzigen Transaktion an Ethereum übermittelt werden. Die Transaktionsberechnung erfolgt Offchain und wird dann mit einem Beweis ihrer Gültigkeit an die Hauptkette geliefert. Diese Methode erhöht die Anzahl der möglichen Transaktionen bei gleichbleibender Sicherheit. Einige Rollups verwenden Betrugsbeweise. Mehr über Zero-Knowledge-Rollups.",
+ "validium-term": "Validium",
+ "validium-definition": "Eine Offchain-Lösung, die Gültigkeitsbeweise verwendet, um den Transaktionsdurchsatz zu verbessern. Im Gegensatz zu Zero-Knowledge-Rollups werden Validium-Daten nicht auf dem Layer-1-Mainnet gespeichert. Mehr über Validium.",
+ "vyper-term": "Vyper",
+ "vyper-definition": "Eine Hochsprache mit Python-ähnlicher Syntax. Soll einer reinen funktionalen Sprache näher kommen. Erstellt von Vitalik Buterin. Mehr über Vyper.",
+ "wallet-term": "Wallet",
+ "wallet-definition": "Eine Wallet ist ein digitales Werkzeug zum Speichern, Senden und Empfangen digitaler Währung, wie eine virtuelle Geldbörse für Ihr Online-Geld. Mehr über Ethereum-Wallets.",
+ "web2-term": "Web2",
+ "web2-definition": "Ist das aktuelle Internet, das sich auf benutzergenerierte Inhalte und soziale Medien konzentriert, die von wenigen Unternehmen kontrolliert werden. Web3 ist eine Krypto-Überzeugung, dass Benutzer ihre Daten und Transaktionen stattdessen kontrollieren sollten.",
+ "web3-term": "Web3",
+ "web3-definition": "Web3 ist das neue Internet mit Blockchain, bei dem Benutzer ihre Daten und Transaktionen kontrollieren, nicht Unternehmen. Es müssen keine persönlichen Informationen geteilt werden. Mehr über Web3.",
+ "wei-term": "Wei",
+ "wei-definition": "Die kleinste Denomination von Ether. 1018 Wei = 1 Ether.",
+ "wrapped-token-term": "Wrapped Token",
+ "wrapped-token-definition": "Ein Blockchain-basierter Token, der eine andere Kryptowährung oder einen Vermögenswert in einem anderen Netzwerk darstellt. Zum Beispiel repräsentiert Wrapped Ether (WETH) Ether (ETH) in einem Format, das dem ERC-20-Token-Standard von Ethereum entspricht. Der ursprüngliche Vermögenswert wird sicher durch einen Smart Contract gesperrt, und ein entsprechender Wrapped Token wird gemintet. Dieser Mechanismus ermöglicht die Interoperabilität innerhalb und zwischen Blockchains, sodass Vermögenswerte wie ETH nahtlos in dezentralisierten Anwendungen verwendet werden können, während sie ihren Wert behalten.",
+ "zero-address-term": "Nulladresse",
+ "zero-address-definition": "Eine Ethereum-Adresse, die vollständig aus Nullen besteht und häufig als Adresse verwendet wird, um Token aus dem eigenen Umlauf zu entfernen. Es wird zwischen Token unterschieden, die formal über die burn()-Methode aus dem Index eines Smart Contracts entfernt werden, und denen, die an diese Adresse gesendet werden.",
+ "zk-proof-term": "Zero-Knowledge-Nachweis",
+ "zk-proof-definition": "Ein Zero-Knowledge-Beweis ist eine kryptographische Methode, die es einer Person ermöglicht zu beweisen, dass eine Aussage wahr ist, ohne zusätzliche Informationen zu übermitteln. Mehr über Zero-Knowledge-Rollups.",
+ "zk-rollup-term": "Zero-Knowledge Rollup",
+ "zk-rollup-definition": "Ein Rollup von Transaktionen, das Gültigkeitsbeweise verwendet, um einen erhöhten Layer-2-Transaktionsdurchsatz zu bieten, während die Sicherheit des Mainnets (Layer 1) genutzt wird. Obwohl sie keine komplexen Transaktionstypen wie Optimistic Rollups verarbeiten können, haben sie keine Latenzprobleme, da Transaktionen bei der Übermittlung nachweislich gültig sind. Mehr über Zero-Knowledge-Rollups."
+}
diff --git a/src/intl/de/learn-quizzes.json b/src/intl/de/learn-quizzes.json
index a4e597abef8..4982054b3a2 100644
--- a/src/intl/de/learn-quizzes.json
+++ b/src/intl/de/learn-quizzes.json
@@ -50,7 +50,7 @@
"what-is-ethereum-3-prompt": "Wer betreibt Ethereum?",
"what-is-ethereum-3-a-label": "Entwickler:innen",
"what-is-ethereum-3-a-explanation": "Entwickler sind entscheidend für den Aufbau und die Verbesserung von Ethereum. Sie sind aber nicht diejenigen, die Ethereum am Laufen halten.",
- "what-is-ethereum-3-b-label": "Miners",
+ "what-is-ethereum-3-b-label": "Miner",
"what-is-ethereum-3-b-explanation": "Seit dem \"Merge\" ist Mining nicht mehr möglich, auf Ethereum gibt es nun keine „Miner“ mehr.",
"what-is-ethereum-3-c-label": "Die Ethereum Foundation",
"what-is-ethereum-3-c-explanation": "Die Ethereum-Stiftung hat keine nennenswerte Rolle im Betrieb der Ethereum-Nodes.",
@@ -58,19 +58,19 @@
"what-is-ethereum-3-d-explanation": "Wer eine Node betreibt, ist ein entscheidender Teil von Ethereums Infrastruktur. Überlege dir den Betrieb einer Ethereum-Node, wenn du hier noch nicht aktiv bist.",
"what-is-ethereum-4-prompt": "Wie oft war das Netzwerk seit dem Start von Ethereum offline?",
"what-is-ethereum-4-a-label": "Nie",
+ "what-is-ethereum-4-a-explanation": "Ethereum ist seit seiner Einführung noch nie vollständig offline gegangen (hat also nie aufgehört, Blöcke zu produzieren).",
"what-is-ethereum-4-b-label": "Einmal",
"what-is-ethereum-4-c-label": "Vier Mal",
"what-is-ethereum-4-d-label": "Mehr als zehn Mal",
- "what-is-ethereum-4-explanation": "Ethereum ist seit seiner Einführung noch nie vollständig offline gegangen (hat also nie aufgehört, Blöcke zu produzieren).",
"what-is-ethereum-5-prompt": "Ethereum verbraucht mehr Strom als:",
"what-is-ethereum-5-a-label": "Goldabbau",
- "what-is-ethereum-5-a-explanation": "Der Goldbergbau verbraucht ca. 131 Terawatt pro Jahr. Ethereum verbraucht etwa 0,0026 Terawattt pro Jahr.",
+ "what-is-ethereum-5-a-explanation": "Der Goldbergbau verbraucht ca. 131 Terawattstunden pro Jahr. Ethereum verbraucht etwa 0,0026 Terawattstunden pro Jahr.",
"what-is-ethereum-5-b-label": "Netflix",
- "what-is-ethereum-5-b-explanation": "Netflix verbraucht ca. 0,451 Terawatt pro Jahr. Ethereum verbraucht 0,0026 Terawatt pro Jahr.",
+ "what-is-ethereum-5-b-explanation": "Netflix verbraucht ca. 0,451 Terawattstunden pro Jahr. Ethereum verbraucht etwa 0,0026 Terawattstunden pro Jahr.",
"what-is-ethereum-5-c-label": "PayPal",
- "what-is-ethereum-5-c-explanation": "PayPal verbraucht ca. 0,26 Terawatt pro Jahr. Ethereum verbraucht 0,0026 Terawatt pro Jahr.",
+ "what-is-ethereum-5-c-explanation": "PayPal verbraucht ca. 0,26 Terawattstunden pro Jahr. Ethereum verbraucht etwa 0,0026 Terawattstunden pro Jahr.",
"what-is-ethereum-5-d-label": "Keines der genannten",
- "what-is-ethereum-5-d-explanation": "Ethereum verbraucht etwa 0,0026 Terawatt pro Jahr. Das ist weniger als Goldbergbau (~131 TWh/Jahr), Netflix (~0,451 TWh/Jahr) und Paypal (~0,26 TWh/Jahr).",
+ "what-is-ethereum-5-d-explanation": "Ethereum verbraucht etwa 0,0026 Terawattstunden pro Jahr. Das ist weniger als der Goldbergbau (~131 TWh/Jahr), Netflix (~0,451 TWh/Jahr) und PayPal (~0,26 TWh/Jahr).",
"what-is-ether-1-prompt": "Ether ist auch bekannt als:",
"what-is-ether-1-a-label": "ETC",
"what-is-ether-1-a-explanation": "ETC ist das Kürzel für Ethereum Classic.",
@@ -103,10 +103,10 @@
"what-is-ether-4-a-explanation": "Diese Antwort ist teilweise richtig, aber es ist nur eine der vielen Sachen, für die ETH verwendet werden kann.",
"what-is-ether-4-b-label": "Unzensierbare Peer-to-Peer-Zahlungen",
"what-is-ether-4-b-explanation": "Diese Antwort ist teilweise richtig, aber es ist nur eine der vielen Sachen, für die ETH verwendet werden kann.",
- "what-is-ether-4-c-label": "Sicherheit für Krypto-Kredite",
+ "what-is-ether-4-c-label": "Sicherheiten für Krypto-Kredite",
"what-is-ether-4-c-explanation": "Diese Antwort ist teilweise richtig, aber es ist nur eine der vielen Sachen, für die ETH verwendet werden kann.",
"what-is-ether-4-d-label": "Alle oben Genannte",
- "what-is-ether-4-d-explanation": "what-is-ethereum-Transaktionen können nicht zensiert werden. Für jede Transaktion auf Ethereum wird ETH benötigt, und es ist auch für die Stabilität des DeFi-Ökosystems von entscheidender Bedeutung.",
+ "what-is-ether-4-d-explanation": "Ethereum-Transaktionen können nicht zensiert werden. Für jede Transaktion auf Ethereum wird ETH benötigt, und es ist auch für die Stabilität des DeFi-Ökosystems von entscheidender Bedeutung.",
"web3-1-prompt": "Web3 ermöglicht Nutzern, digitale Assets zu besitzen durch:",
"web3-1-a-label": "Token",
"web3-1-a-explanation": "Token bieten einen Möglichkeit, Werteinheiten zu verkörpern, die untereinander austauschbar sind und einem Ethereum-Account gehören. Obwohl sie Eigentum repräsentieren, gibt es noch mehr Wege, digitale Assets auf Ethereum zu besitzen.",
@@ -207,11 +207,11 @@
"security-3-c-explanation": "Bekannte Community Mitglieder machen keine ETH-Giveaways. Allerdings geben Betrüger vor, dass bekannte Persönlichkeiten, wie z. B. Elon Musk, Giveaways durchführen, um dem Betrug mehr Legitimität zu verleihen.",
"security-3-d-label": "Sind sehr wahrscheinlich Betrug",
"security-3-d-explanation": "ETH-Giveaways sind immer Betrug. Es ist am besten, die Betrüger zu melden und zu ignorieren.",
- "security-4-prompt": "what-is-ethereum-Transaktionen sind umkehrbar.",
+ "security-4-prompt": "Ethereum Zahlungen lassen sich rückgängig machen.",
"security-4-a-label": "Richtig",
- "security-4-a-explanation": "what-is-ethereum-Transaktionen können nicht rückgängig gemacht werden. Jeder, der das Gegenteil behauptet, könnte versuchen, Sie zu betrügen.",
+ "security-4-a-explanation": "Ethereum-Transaktionen können nicht rückgängig gemacht werden. Jeder, der das Gegenteil behauptet, könnte versuchen, Sie zu betrügen.",
"security-4-b-label": "Falsch",
- "security-4-b-explanation": "what-is-ethereum-Transaktionen können nicht rückgängig gemacht werden. Jeder, der das Gegenteil behauptet, könnte versuchen, Sie zu betrügen.",
+ "security-4-b-explanation": "Ethereum-Transaktionen können nicht rückgängig gemacht werden. Jeder, der das Gegenteil behauptet, könnte versuchen, Sie zu betrügen.",
"nfts-1-prompt": "NFTs lassen sich am besten definieren als:",
"nfts-1-a-label": "einzigartige digitale Assets",
"nfts-1-a-explanation": "NFTs repräsentieren einzigartige digitale Assets.",
@@ -270,7 +270,7 @@
"rollups-3-prompt": "Welche der folgenden Technologien werden nicht als Layer-2 betrachtet?",
"rollups-3-a-label": "Validiums",
"rollups-3-a-explanation": "Validiums werden nicht als Layer-2-Lösungen gesehen, weil sie keine Sicherheit oder Datenverfügbarkeit von Ethereum ableiten. Dies ist nicht die einzige richtige Antwort.",
- "rollups-3-b-label": "Sidechains",
+ "rollups-3-b-label": "Seitenketten",
"rollups-3-b-explanation": "Sidechains werden nicht als Layer-2-Lösungen gesehen, weil sie keine Sicherheit oder Datenverfügbarkeit von Ethereum ableiten. Dies ist nicht die einzige richtige Antwort.",
"rollups-3-c-label": "Alternative Layer-1 Blockchains",
"rollups-3-c-explanation": "Alternative Layer-1-Blockchains werden nicht als Layer-2-Lösungen gesehen. Dies ist nicht die einzige richtige Antwort.",
@@ -290,6 +290,7 @@
"merge-1-a-explanation": "Proof-of-Work war der Konsensmechanismus, der vor dem Merge verwendet wurde.",
"merge-1-b-label": "Proof-of-Stake (Einsatznachweis)",
"merge-1-b-explanation": "Richtig! Mit dem Merge hat Ethereum auf Proof-of-Stake gewechselt.",
+ "merge-1-c-label": "Proof-of-Authority",
"merge-1-c-explanation": "Ethereum hat auf dem Ethereum-Mainnet noch nie Proof-of-Authority verwendet.",
"merge-1-d-label": "Alle oben Genannte",
"merge-1-d-explanation": "Es wäre nicht möglich, dass Ethereum alle diese Konsensmechanismen gleichzeitig verwendet.",
@@ -325,8 +326,53 @@
"merge-5-c-explanation": "Eth1 war der ursprüngliche Name für die Ausführungsebene, nicht die Konsensschicht.",
"merge-5-d-label": "Staking",
"merge-5-d-explanation": "Staking bedeutet, dass ETH in einen intelligenten Vertrag eingezahlt wird, um die Sicherheit der Chain zu unterstützen.",
+ "gas-1-prompt": "Was sind Spritgebühren?",
+ "gas-1-a-label": "Eine Gebühr, die bei Transaktionen und Smart-Contract-Operationen anfällt",
+ "gas-1-a-explanation": "Das stimmt zum Teil. Genauer gesagt sind Gas-Gebühren die Kosten, die für Transaktionen und Smart-Contract-Operationen anfallen.",
+ "gas-1-b-label": "Man nimmt die Gasmenge für eine Operation und multipliziert sie mit den Kosten pro Gaseinheit",
+ "gas-1-b-explanation": "Teilweise korrekt. Die Antwort ist zwar nicht falsch, aber es gibt eine passendere unter den vorgegebenen Optionen.",
+ "gas-1-c-label": "Eine Zahlung, bei der eine Priority Fee gezahlt wird, um die Transaktionsverarbeitung zu beschleunigen",
+ "gas-1-c-explanation": "Teilweise richtig. Die Gas-Gesamtgebühr setzt sich aus einer Base Fee und einer Priority Fee zusammen, wobei letztere die Geschwindigkeit der Transaktionsverarbeitung beeinflussen kann",
+ "gas-1-d-label": "Alle oben Genannte",
+ "gas-1-d-explanation": "Gas-Gebühren sind eine umfassende Abgabe, denn sie kompensieren den Rechenaufwand, gelten für Transaktionen sowie Smart Contracts und können für eine schnellere Aufnahme eine Prioritätsgebühr enthalten.",
+ "gas-2-prompt": "Welche der folgenden Methoden zur Senkung der Gaskosten ist am wenigsten wirksam?",
+ "gas-2-a-label": "Transaktionen in Zeiten geringer Netzwerkauslastung ausführen",
+ "gas-2-a-explanation": "Die Ausführung von Transaktionen außerhalb der Stoßzeiten kann die Gaskosten reduzieren.",
+ "gas-2-b-label": "Abwarten, bis die Gaspreise fallen",
+ "gas-2-b-explanation": "Da die Gaspreise je nach Netzwerkauslastung schwanken, ist das Warten auf günstigere Preise eine valide Strategie.",
+ "gas-2-c-label": "Gebührensenkung durch den Einsatz von Layer-2-Chains",
+ "gas-2-c-explanation": "Layer-2-Lösungen sind eine effektive Möglichkeit, Gaskosten zu sparen, denn sie reduzieren die allgemeinen Transaktionsgebühren.",
+ "gas-2-d-label": "Erhöhung des Rechenaufwands durch den Einsatz komplexer Smart-Contract-Logik",
+ "gas-2-d-explanation": "Da komplexe Smart-Contract-Logik mehr Rechenaufwand erfordert, erhöht sie die Gaskosten. Im Umkehrschluss reduziert ein effizientes Design die Gebühren, indem es Schritte, Speicherbedarf und redundante Operationen minimiert.",
+ "gas-3-prompt": "Wodurch entstehen hohe Gas-Gebühren?",
+ "gas-3-a-label": "Eine Netzwerkauslastung, die einen bestimmten Grenzwert übersteigt",
+ "gas-3-a-explanation": "Die Gas-Gebühren steigen, wenn der Rechenaufwand auf Ethereum einen Schwellenwert überschreitet. Das passiert vor allem in Zeiten hoher Aktivität, beispielsweise bei gehypten dApps oder NFT-Drops.",
+ "gas-3-b-label": "Validatoren, die die Base Fee manuell erhöhen",
+ "gas-3-b-explanation": "Nicht die Validatoren legen die Base Fee manuell fest, sondern das Protokoll passt sie automatisch an, abhängig von der Nachfrage im vorherigen Block.",
+ "gas-3-c-label": "Sauber geschriebener und optimierter Smart-Contract-Code",
+ "gas-3-c-explanation": "Gut geschriebene Smart-Contract-Logik, wie zum Beispiel die effiziente Nutzung von Storage und Loops, kann zu einem geringeren Gasverbrauch führen.",
+ "gas-3-d-label": "Eine geringe Verfügbarkeit von ETH im Netzwerk",
+ "gas-3-d-explanation": "Die Höhe der Gas-Gebühren ist nicht von der Menge an verfügbarem ETH im Netzwerk abhängig.",
+ "gas-4-prompt": "Inwiefern tragen Gas-Gebühren zur Sicherheit von Ethereum bei?",
+ "gas-4-a-label": "Schaffung von Anreizen für ehrliches Verhalten der Validatoren",
+ "gas-4-a-explanation": "Validatoren erhalten auf verschiedene Weisen eine Vergütung. Der primäre Zweck von Gas-Gebühren ist jedoch, Spam und eine übermäßige Ressourcennutzung zu verhindern.",
+ "gas-4-b-label": "Indem Spam und bösartige Aktivitäten durch finanzielle Kosten unattraktiv gemacht werden",
+ "gas-4-b-explanation": "Indem Gas-Gebühren Spam und bösartige Aktivitäten verteuern, beugen sie Missbrauch vor und tragen zur Stabilität des Netzwerks bei.",
+ "gas-4-c-label": "Indem sichergestellt wird, dass Transaktionen in der Reihenfolge ihrer Priorität verarbeitet werden",
+ "gas-4-c-explanation": "Nicht die Gas-Gebühren selbst, sondern die Priority Fee legt die Priorität fest.",
+ "gas-4-d-label": "Was die Gesamtmenge an ETH im Umlauf erhöht",
+ "gas-4-d-explanation": "Das Verbrennen der Base Fee (ein Teil der Gas-Gesamtgebühr) führt zu einer Reduzierung der ETH-Umlaufmenge – und nicht zu einer Erhöhung",
+ "gas-5-prompt": "Wie werden die Gasgebühren berechnet?",
+ "gas-5-a-label": "Gaspreis × Transaktionsgröße",
+ "gas-5-a-explanation": "Die Höhe der Gas-Gebühren hängt vom Rechenaufwand ab, nicht von der Transaktionsgröße.",
+ "gas-5-b-label": "Gasverbrauch × (Base Fee + Priority Fee)",
+ "gas-5-b-explanation": "Um die Gas-Gebühren zu bestimmen, multipliziert man die verbrauchten Gaseinheiten mit der Summe aus Basisgebühr und Prioritätsgebühr.",
+ "gas-5-c-label": "Blockgröße × Validator-Tip-Obergrenze",
+ "gas-5-c-explanation": "Die Blockgröße ist kein direkter Bestandteil dieser Formel.",
+ "gas-5-d-label": "Base Fee + Priority Fee + Trinkgeld",
+ "gas-5-d-explanation": "Die Formel beinhaltet die Base Fee und die Priority Fee. Wichtig zu wissen ist hierbei, dass das Trinkgeld nur eine andere Bezeichnung für die Priority Fee ist.",
"daos-1-prompt": "Was trifft auf DAOs zu?",
- "daos-1-a-label": "DAOs befinden sich über Governance-Token in kollektivem Besitz",
+ "daos-1-a-label": "DAOs befinden sich über Verwaltungs-Token in kollektivem Besitz",
"daos-1-a-explanation": "DAOs sind kollektives Eigentum, aber das ist nicht die einzige richtige Aussage.",
"daos-1-b-label": "Sie werden von ihren Mitgliedern regiert",
"daos-1-b-explanation": "DAOs werden von ihren Mitgliedern reguliert, aber das ist nicht die einzige richtige Aussage.",
@@ -347,7 +393,7 @@
"daos-3-a-label": "normalerweise hierarchisch strukturiert",
"daos-3-a-explanation": "DAOs haben normalerweise eine flache Hierarchie und sind voll demokratisiert.",
"daos-3-b-label": "in Bezug auf ihre Aktivitäten transparent und bieten vollständige Öffentlichkeit",
- "daos-3-b-explanation": "Dank On-Chain-Abstimmungen sind Entscheidungen auf der Blockchain transparent. Diskussionen und andere Bestandteile der Entscheidungsfindung stehen allen Mitgliedern offen.",
+ "daos-3-b-explanation": "On-Chain-Votings sorgen für Transparenz bei den Entscheidungen auf der Blockchain. Darüber hinaus sind auch Diskussionen und andere Teile des Entscheidungsprozesses für alle Mitglieder offen einsehbar.",
"daos-3-c-label": "von einer zentralen Partei kontrolliert",
"daos-3-c-explanation": "Veränderungen erfordern eine Abstimmung durch die Mitglieder. Die angebotenen Dienste werden automatisch auf dezentralisierte Weise geregelt.",
"daos-3-d-label": "eingeschränkt in Bezug darauf, wer Veränderungen vorschlagen kann",
@@ -368,8 +414,8 @@
"daos-5-b-explanation": "Die Berechtigungen für anteilsbasierte DAOs sind beschränkter, aber immer noch relativ offen. Jedes potentielle Mitglied kann einen Antrag auf Beitritt in die DAO einreichen, normalerweise zusammen mit einem Gegenleistungsangebot in Form von Token oder Arbeit.",
"daos-5-c-label": "Reputationsbasierte Mitgliedschaft",
"daos-5-c-explanation": "Anders als bei Token- oder anteilsbasierten Mitgliedschaften wird bei reputationsbasierten DAOs das Eigentum nicht auf die Mitwirkenden übertragen. Die DAO-Mitglieder müssen sich ihre Reputation durch ihre Teilnahme erarbeiten.",
- "daos-5-d-label": "Vorstand und Off-Chain-Finanzverwaltung",
- "daos-5-d-explanation": "Bei diesem Ansatz komen stark zentralisierte und undurchsichtige Verwaltungsmechanismen zum Einsatz. Im Gegensatz dazu verwenden DAOs verifizierbare Abstimmungsmechanismen und eine On-Chain-Finanzverwaltung, um Transparenz und Rechenschaftspflicht zu gewährleisten.",
+ "daos-5-d-label": "Vorstand und Off-Chain-Vermögensverwaltung",
+ "daos-5-d-explanation": "Dieser Ansatz verwendet stark zentralisierte und intransparente Steuerungsmechanismen. DAOs hingegen setzen auf nachweisbare Abstimmungsmechanismen und eine On-Chain-Vermögensverwaltung, um Transparenz und Verantwortlichkeit zu gewährleisten.",
"staking-solo-1-prompt": "Was trifft über das Slashing zu?",
"staking-solo-1-a-label": "Strafe dafür, offline zu sein, Belohnungen werden wieder ausgegeben, wenn wieder online",
"staking-solo-1-a-explanation": "Offline zu sein führt NICHT zu Slashing. Wenn Sie offline sind, fallen geringe Strafen an, und die Belohnungen werden wieder ausgegeben, wenn der Validator erneut online ist und wieder Attestierungen ausstellt.",
@@ -394,13 +440,14 @@
"staking-solo-3-b-label": "32",
"staking-solo-3-b-explanation": "32 ETH ist sowohl der minimale ETH-Betrag, der zur Aktivierung eines neuen Validators erforderlich ist, als auch das maximale „effektive Guthaben“ (Stimmengewicht) für diesen Validator. Es können zwar Belohnungen über 32 ETH angesammelt werden, aber dieses Guthaben trägt nicht zum Stimmgewicht dieses Validators im Netzwerk bei und die Belohnungen erhöhen sich nicht.",
"staking-solo-3-c-label": "Variabel je nach Operator",
- "staking-solo-3-c-explanation": "Die Konsensregeln gelten für jedes Validatorenkonto gleichermaßen und sind nicht von der Person abhängig, die den Knoten betreibt. Das maximale effektive Guthaben aller Validatoren beträgt 32 ETH.",
+ "staking-solo-3-c-explanation": "Die Konsensregeln gelten für jedes Validatorenkonto gleichermaßen und sind nicht von der Person abhängig, die den Node betreibt. Das maximale effektive Guthaben aller Validatoren beträgt 32 ETH.",
"staking-solo-3-d-label": "Keine Begrenzung",
"staking-solo-3-d-explanation": "Jedes Validatorenkonto ist auf ein effektives Guthaben von 32 ETH begrenzt. Dadurch wird der Gesamteinfluss jedes einzelnen Validators im Netzwerk begrenzt. Auf diese Weise lässt sich außerdem einschänken, wie viel Staking oder Un-Staking in einem bestimmten Zeitraum für ETH durchgeführt werden kann, da Validatoraktivierungen und -Austritte über eine Warteschlange mit begrenzter Rate verarbeitet werden.",
"staking-solo-4-prompt": "Was ist KEINE Belohnung, die ein Validator erhält?",
+ "staking-solo-4-a-label": "Block-Belohnung",
"staking-solo-4-a-explanation": "Validatoren erhalten Belohnungen in Form einer neuen ETH-Ausgabe für das Vorschlagen eines gültigen Blocks, wenn dieser vom Protokoll zufällig ausgewählt wird. Diese Belohnungen sind getrennt von den Gebühren und MEV, die auch beim Vorschlagen von Blöcken verdient werden.",
"staking-solo-4-b-label": "Gebührentrinkgelder/MEV",
- "staking-solo-4-b-explanation": "Gebührentrinkgelder (nicht verbrauchter Anteil der Gebühren) und MEV-Einnahmen werden über die von diesem Validator angegebene Gebührenempfängeradresse an den Blockantragsteller (Staker/Validator) verteilt. Diese Belohnungen sind unabhängig von der Blockbelohnung, die auch beim Vorschlagen von Blöcken ausgegeben wird.",
+ "staking-solo-4-b-explanation": "Gebührentrinkgelder (nicht verbrauchter Anteil der Gebühren) und MEV-Einnahmen werden über die von diesem Validator angegebene Gebührenempfängeradresse an den Block-Proposer (Staker/Validator) verteilt. Diese Belohnungen sind unabhängig von der Blockbelohnung, die auch beim Vorschlagen von Blöcken ausgegeben wird.",
"staking-solo-4-c-label": "Attestierungsbelohnung vom Leiter der Chain",
"staking-solo-4-c-explanation": "Validatoren erhalten Belohnungen in Form einer neuen ETH-Ausgabe für die korrekte und rechtzeitige Attestierung an den Leiter der Chain, den aktuell berechtigten Epochenleiter und den aktuell finalisierten Epochenleiter.",
"staking-solo-4-d-label": "Uniswap-Handelsgebühren",
@@ -429,10 +476,10 @@
"staking-solo-7-c-label": "Das Ausführen eines Clients, der von der Mehrheit der anderen Validatoren verwendet wird",
"staking-solo-7-c-explanation": "Bei Verwendung desselben Clients wie die Mehrheit des restlichen Netzes besteht die Gefahr, dass Sie im Falle eines Softwarefehlers in diesem Client mit Slashing bestraft werden. Die Verwendung eines Minderheiten-Clients schützt davor.",
"staking-solo-7-d-label": "Das Deaktivieren eines Validators für 2–4 Epochen, bevor die Schlüssel auf eine neue Maschine migriert werden",
- "staking-solo-7-d-explanation": "So ist genug Zeit verfügbar, um die Chain zu finalisieren, während Ihr Knoten offline ist, um das Risiko jeglicher versehentlicher Doppelabstimmungen und eines Slashings während der Schlüsselmigration zu minimieren.",
+ "staking-solo-7-d-explanation": "So ist genug Zeit verfügbar, um die Chain zu finalisieren, während Ihr Node offline ist, um das Risiko jeglicher versehentlicher Doppelabstimmungen und eines Slashings während der Schlüsselmigration zu minimieren.",
"staking-solo-8-prompt": "Was ist NICHT erforderlich, um Belohnungszahlungen/Teilabhebungen zu erhalten?",
"staking-solo-8-a-label": "Die einmalige Angabe einer Auszahlungsadresse für die Ausführung",
- "staking-solo-8-a-explanation": "Das ist einmal notwendig, damit der Auszahlungsprozess weiß, wohin die Geldmittel aus der Konsens-Layer überwiesen werden sollen",
+ "staking-solo-8-a-explanation": "Das ist einmal notwendig, damit der Auszahlungsprozess weiß, wohin die Geldmittel aus der Konsensebene überwiesen werden sollen",
"staking-solo-8-b-label": "Das Halten eines effektiven Guthabens von 32 ETH",
"staking-solo-8-b-explanation": "Ihr effektives Guthaben darf maximal 32 ETH betragen, bevor Teilabhebungen ausgelöst werden können.",
"staking-solo-8-c-label": "Das Halten eines Gesamtguthabens von mehr als 32 ETH",
@@ -445,25 +492,25 @@
"scaling-1-b-label": "Proto-Danksharding",
"scaling-1-b-explanation": "Dies ist eine temporäre und kostengünstige Möglichkeit, Rollup-Daten im Mainnet zu speichern, das derzeit für etwa 90 % der Kosten verantwortlich ist, die einem Nutzer bei einem Rollup entstehen. Das ist nicht die einzige Möglichkeit, wie Ethereum skaliert.",
"scaling-1-c-label": "Danksharding",
- "scaling-1-c-explanation": "Dadurch muss nicht mehr jeder Validator und jeder Knoten im Netzwerk 100 % der Daten für alle Rollups speichern, was die Hardwareanforderungen für die Knotenbetreiber reduziert. Das ist nicht die einzige Möglichkeit, wie Ethereum skaliert.",
+ "scaling-1-c-explanation": "Dadurch muss nicht mehr jeder Validator und jeder Node im Netzwerk 100 % der Daten für alle Rollups speichern, was die Hardwareanforderungen für die Node-Betreiber reduziert. Das ist nicht die einzige Möglichkeit, wie Ethereum skaliert.",
"scaling-1-d-label": "Alle oben Genannte",
"scaling-1-d-explanation": "Die Layer-2-Rollups bündeln Transaktionen, Proto-Danksharding schafft billigen Zwischenspeicher für diese Daten und Danksharding verteilt die Speicherlast auf alle Validatoren – was alles zur Skalierung von Ethereum beiträgt.",
"scaling-2-prompt": "Was tun Layer-2-Rollups nach der Bündelung von Transaktionen und deren Ausführung als Nächstes?",
"scaling-2-a-label": "Speicherung der Daten auf einem privaten Server",
- "scaling-2-a-explanation": "Die Ergebnisse werden im Mainnet veröffentlicht, um Transparenz und öffentliche Verfügbarkeit zu gewährleisten. Sie sind nicht auf private Server angewiesen.",
+ "scaling-2-a-explanation": "Die Ergebnisse werden im Mainnet gepostet, um Transparenz und öffentliche Verfügbarkeit zu gewährleisten. Sie sind nicht auf private Server angewiesen.",
"scaling-2-b-label": "Versenden des Nachweises an den Benutzer, damit dieser ihn speichern kann",
- "scaling-2-b-explanation": "Von den Nutzern wird nicht erwartet, dass sie die Ergebnisse ihrer Transaktion abspeichern. Diese Informationen werden im Mainnet veröffentlicht.",
+ "scaling-2-b-explanation": "Von den Nutzern wird nicht erwartet, dass sie die Ergebnisse ihrer Transaktion abspeichern. Diese Informationen werden im Mainnet gepostet.",
"scaling-2-c-label": "Übermittlung der Ergebnisse an Ethereum",
- "scaling-2-c-explanation": "Layer-2-Rollups senden die Ergebnisse ihrer Transaktionsausführung an das Mainnet und sichern sie in der Ethereum-Historie",
+ "scaling-2-c-explanation": "Layer-2-Rollups posten die Ergebnisse ihrer Transaktionsausführung im Mainnet und sichern sie in der Ethereum-Historie",
"scaling-2-d-label": "Löschen des Ergebnisses zur Reduzierung der Kosten",
- "scaling-2-d-explanation": "Layer-2-Rollups senden die Ergebnisse ihrer Transaktionsausführung an das Mainnet. Die Kosteneinsparungen, die mit diesem Ansatz erzielt werden, liegen in der Bündelung und Komprimierung der Transaktionsdaten und schließlich in der Sicherung auf billigem Speicher, der verfällt, sobald er denjenigen zur Verfügung gestellt wird, die ihn benötigen.",
+ "scaling-2-d-explanation": "Layer-2-Rollups posten die Ergebnisse ihrer Transaktionsausführung im Mainnet. Die Kosteneinsparungen, die mit diesem Ansatz erzielt werden, liegen in der Bündelung und Komprimierung der Transaktionsdaten und schließlich in der Sicherung auf billigem Speicher, der verfällt, sobald er denjenigen zur Verfügung gestellt wird, die ihn benötigen.",
"scaling-3-prompt": "Wie reduziert Proto-Danksharding die Transaktionskosten bei Rollups?",
"scaling-3-a-label": "Direkte Erhöhung der Blockgröße",
"scaling-3-a-explanation": "Proto-Danksharding erhöht das Gaslimit nicht direkt, sondern reduziert durch die Bereitstellung von Zwischenspeichern die Kosten für die Speicherung von Rollup-Daten",
"scaling-3-b-label": "Aufteilung, welche Validatoren zur Speicherung der Daten verpflichtet sind",
"scaling-3-b-explanation": "Here is the translated sentence:\n\nEs wird erwartet, dass vollständiges Danksharding die Notwendigkeit reduziert, dass alle Validatoren alle Daten speichern. Dem geht jedoch Proto-Danksharding voraus, das eine weniger kostspielige, vorübergehende Speichermöglichkeit für die durch Rollups erzeugten Daten darstellt.",
- "scaling-3-c-label": "Erhebliche Steigerung der Hardware-Anforderungen für Knotenbetreiber",
- "scaling-3-c-explanation": "Dies wird im Allgemeinen als keine akzeptable Option für die Skalierung von Ethereum angesehen. Es werden große Anstrengungen unternommen, die Hardware-Anforderungen für den Betrieb von Knoten zu minimieren, um dafür zu sorgen, dass sie so zugänglich wie möglich bleiben.",
+ "scaling-3-c-label": "Erhebliche Steigerung der Hardware-Anforderungen für Node-Betreiber",
+ "scaling-3-c-explanation": "Dies wird im Allgemeinen als keine akzeptable Option für die Skalierung von Ethereum angesehen. Es werden große Anstrengungen unternommen, die Hardware-Anforderungen für den Betrieb von Nodes zu minimieren, um dafür zu sorgen, dass sie so zugänglich wie möglich bleiben.",
"scaling-3-d-label": "Speichern der Daten in einem billigeren, temporären „Blob“-Speicher",
"scaling-3-d-explanation": "Proto-Danksharding führt eine Option zur temporären Datenspeicherung für Rollups ein, damit diese ihre Ergebnisse kostengünstiger im Mainnet posten können",
"scaling-4-prompt": "Was ist ein wichtiger nächster Schritt für Rollups in Bezug auf die Skalierung von Ethereum?",
@@ -475,51 +522,177 @@
"scaling-4-c-explanation": "Ethereum profitiert davon, dass es innerhalb seines Rollup-Ökosystems zur Förderung der Widerstandsfähigkeit ein breites Spektrum an Sicherheitsansätzen gibt.",
"scaling-4-d-label": "Datenorakel zur Bestätigung der Speicherung von Transaktionsdaten auf privaten Servern",
"scaling-4-d-explanation": "Die Rollup-Daten werden auf Ethereum gespeichert und sind nicht auf private Server oder Datenbanken angewiesen.",
- "scaling-1-prompt": "Was ist für den Betrieb eines Knotens erforderlich?",
- "scaling-1-a-label": "Ausführen von Client-Software mit bescheidener Hardware und einer stetigen Internetverbindung.",
- "scaling-1-a-explanation": "Der Betrieb eines Knotens setzt sich daraus zusammen, Software auszuführen, die die Sprache des Ethereum-Protokolls verwendet und dabei mit anderen Computern kommuniziert, die dasselbe tun. Diese Software lädt eine Kopie der Ethereum-Blockchain herunter, verifiziert die Gültigkeit jedes Blocks und hält sie dann mit neuen Blöcken und Transaktionen auf dem neuesten Stand. Gleichzeitig hilft sie anderen dabei, ihre eigenen Kopien herunterzuladen und zu aktualisieren.",
- "scaling-1-b-label": "32 ETH einzahlen, um Belohnungen zu verdienen",
- "scaling-1-b-explanation": "Dies ist eine Voraussetzung für das Staking, d. h. den Prozess, ein aktiver Teilnehmer am Netzwerkkonsens zu werden. Dies ist nicht erforderlich, um lediglich eine souveräne Kopie der Blockchain auszuführen, wofür KEINE ETH benötigt werden.",
- "scaling-1-c-label": "Betrieb leistungsstarker ASIC-Mining-Computer, um Netzwerkkonsens zu erreichen",
- "scaling-1-c-explanation": "Obwohl Ethereum früher das Mining mit leistungsstarken Computern nutzte, um einen Konsens zu erreichen, wurde dieser Prozess vollständig durch das Staking ersetzt. Weder das Mining in der Vergangenheit noch das Staking in der Gegenwart waren bzw. sind erforderlich, um einfach eine souveräne Kopie der Blockchain auszuführen.",
- "scaling-1-d-label": "Vollzeit-Anstellung in der Blockchain-Infrastruktur",
- "scaling-1-d-explanation": "Das Software-Tooling hat sich im Laufe der Zeit immer weiter verbessert, sodass der Betrieb eines Knotens von zu Hause aus auch für unerfahrene Nutzer viel einfacher geworden ist. Eine Vollzeitbeschäftigung in der Blockchain-Infrastruktur ist keineswegs eine Voraussetzung für eine Teilnahme.",
- "scaling-2-prompt": "Wie viele ETH müssen Sie staken, um einen Knoten zu betreiben?",
- "scaling-2-a-label": "0",
- "scaling-2-a-explanation": "Für den Betrieb eines Ethereum-Knotens sind keine ETH erforderlich. Im Gegensatz zum Betrieb eines Staking-Validators als Teil eines Knoten-Setups steht es jedem frei, Client-Software zu betreiben und eigene souveräne Kopien der Blockchain zu synchronisieren – hierfür werden keine ETH benötigt.",
- "scaling-2-b-label": "8",
- "scaling-2-c-label": "16",
- "scaling-2-d-label": "32",
- "scaling-2-d-explanation": "Der Betrieb eines Ethereum-Knotens erfordert keine ETH. Für die Aktivierung eines Staking-Validators, der direkt am Netzwerkkonsens teilnimmt, sind zwar 32 ETH erforderlich. Es steht aber jedem frei, Client-Software auszuführen und eigene souveräne Kopien der Blockchain zu synchronisieren – hierfür werden keine ETH benötigt.",
- "scaling-3-prompt": "Welche Vorteile haben Sie, wenn Sie Ihren eigenen Knoten betreiben?",
- "scaling-3-a-label": "Resistent gegenüber Zensur",
- "scaling-3-a-explanation": "Dies ist ein Vorteil für die Nutzer, aber nicht der einzige. Durch das Ausführen von Knotensoftware, die direkt mit anderen Peers im Netzwerk kommuniziert, werden Ihre Transaktionen mit jeder anderen Transaktion vermischt, die Ihr Knoten verbreitet. Auf diese Weise ist es annähernd unmöglich, eine gültige Transaktion, die Ihr Knoten geteilt hat, zu identifizieren und zu zensieren.",
- "scaling-3-b-label": "Souveränität",
- "scaling-3-b-explanation": "Dies ist ein Vorteil für die Nutzer, aber nicht der einzige. Wenn Sie Ihre eigene Kopie der Ethereum-Blockchain besitzen, sind Sie bei der Interaktion mit dem Netzwerk nicht mehr von einer einzigen externen Partei abhängig. Sie müssen nie um Erlaubnis bitten, um Ihr Guthaben abzurufen oder eine Transaktion auszuführen. Darüber hinaus werden alle Transaktionen mit einer Software überprüft, die Sie selbst ausführen. Wenn das Netzwerk aktualisiert wird, entscheiden Sie selbst, ob Sie das Upgrade unterstützen wollen oder nicht.",
- "scaling-3-c-label": "Privatsphäre",
- "scaling-3-c-explanation": "Dies ist ein Vorteil für die Nutzer, aber nicht der einzige. Ohne einen eigenen Knoten sind in der Regel einige Schritte erforderlich, um nur das eigene Guthaben abzufragen. So müssen Sie eine Liste Ihrer Konten von der Wallet, die mit Ihrer IP-Adresse verknüpft ist, an einen Drittanbieter senden, der Ihnen dann die richtigen Informationen liefert.",
- "scaling-3-d-label": "Alle oben Genannte",
- "scaling-3-d-explanation": "Das Betreiben eines Knotens gibt Ihnen die volle Kontrolle und Souveränität über die Daten, auf die Sie sich stützen. Es ermöglicht es Ihnen, den Inhalt der Chain privat einzusehen und zu überprüfen und praktisch zu garantieren, dass alle gültigen Transaktionen unzensiert dargestellt werden.",
- "scaling-4-prompt": "Welche Art von Festplattenspeicher ist für einen Ethereum-Knoten erforderlich?",
- "scaling-4-a-label": "512 GB SSD",
- "scaling-4-a-explanation": "Derzeit ist keine Client-Software in der Lage, die Chain mit nur 512 GB zu speichern",
- "scaling-4-b-label": "2 TB, rotierend",
- "scaling-4-b-explanation": "Im Allgemeinen unterstützen rotierende Festplatten nicht die erforderlichen Lese- und Schreibgeschwindigkeiten, um mit den Verarbeitungsanforderungen für einen Ethereum-Knoten Schritt zu halten. Empfohlen wird ein SSD-Laufwerk.",
- "scaling-4-c-label": "2 TB SSD Festplatte",
- "scaling-4-c-explanation": "Zum Zeitpunkt der Erstellung dieses Artikels sollte ein SSD-Laufwerk mit 2 TB die Anforderungen an die für einen vollständigen Ethereum-Knoten erforderlichen Speicher-, Lese- und Schreibgeschwindigkeiten erfüllen.",
- "scaling-4-d-label": "SSD-Festplatte mit 8 TB",
- "scaling-4-d-explanation": "Zum Zeitpunkt der Erstellung dieses Artikels sollte ein SSD-Laufwerk mit 2 TB die Anforderungen an die für einen vollständigen Ethereum-Knoten erforderlichen Speicher-, Lese- und Schreibgeschwindigkeiten erfüllen. Eine SSD mit 8 TB würde zusätzliche Zukunftssicherheit und die Möglichkeit bieten, auch Layer-2-Ketten zu synchronisieren. Dies sind aber derzeit keine Voraussetzungen für das Mainnet.",
- "scaling-5-prompt": "Was passiert, wenn Ihr Knoten offline geht?",
- "scaling-5-a-label": "Ihr Knoten wird dann nicht mehr mit dem aktuellen Zustand des Netzes synchronisiert",
- "scaling-5-a-explanation": "Wenn Ihr Knoten online nicht verfügbar ist, kann er keine neuen Transaktionen und Blöcke von Peers empfangen. Folglich wird er nicht mehr mit dem aktuellen Zustand der Chain synchronisiert. Sobald die Online-Verbindung für den Knoten wiederhergestellt wird, lässt sich die entsprechende Software wieder synchronisieren und ist wieder voll funktionsfähig.",
- "scaling-5-b-label": "Die ETH in Ihrer Cold Storage werden geslasht",
- "scaling-5-b-explanation": "ETH, die Sie in Ihrer Cold Storage aufbewahren, haben nichts damit zu tun, ob Ihr Knoten online ist oder nicht. Wenn Ihr Knoten offline ist, können Sie ihn nicht verwenden, um das aktuelle Guthaben Ihrer Konten abzurufen. Der Offline-Zustand bedeutet jedoch keine Risiken für Ihre gesicherten Geldmittel. Wenn Sie zusätzlich Validator-Software mit Ihrem Knoten als Staker ausführen, werden kleine Strafen auf das Validator-Guthaben für die Dauer erhoben, die er nicht im Netzwerk verfügbar ist.",
- "scaling-5-c-label": "Die für die Suche nach Proof-of-Work eingesetzte Energie wird verschwendet",
- "scaling-5-c-explanation": "Ethereum setzt kein Proof-of-Work mehr ein. Dies war aber auch nie eine Anforderung an alle Knotenbetreiber. Wenn Sie offline sind, bedeutet dies lediglich, dass Ihr Knoten nicht mehr mit den neuesten Änderungen im Netzwerk synchronisiert wird. Durch eine Rückkehr ins Netz kann er wieder synchronisiert werden.",
- "scaling-5-d-label": "Die Chain-Daten werden entfernt und eine erneute Synchronisierung von Grund auf ist erforderlich",
- "scaling-5-d-explanation": "Wenn Sie einfach offline gehen, werden normalerweise keine gespeicherten Chain-Daten gelöscht. Wenn Sie sich wieder mit dem Internet verbinden, kann die Software dort weitermachen, wo sie aufgehört hat, und wird wieder mit den neuesten Transaktionen synchronisiert.",
- "scaling-6-prompt": "Durch das Betreiben eines Knotens erhalten Sie Netzwerkbelohnungen",
- "scaling-6-a-label": "Richtig",
- "scaling-6-a-explanation": "Wenn Sie die Client-Software nur ausführen, erhalten Sie noch keine Prämien. Um Belohnungen zu erhalten, müssen Sie auch Staking betreiben.",
- "scaling-6-b-label": "Falsch"
+ "run-a-node-1-prompt": "Was ist für den Betrieb eines Nodes erforderlich?",
+ "run-a-node-1-a-label": "Ausführen von Client-Software mit bescheidener Hardware und einer stetigen Internetverbindung.",
+ "run-a-node-1-a-explanation": "Der Betrieb eines Nodes setzt sich daraus zusammen, Software auszuführen, die die Sprache des Ethereum-Protokolls verwendet und dabei mit anderen Computern kommuniziert, die dasselbe tun. Diese Software lädt eine Kopie der Ethereum-Blockchain herunter, verifiziert die Gültigkeit jedes Blocks und hält sie dann mit neuen Blöcken und Transaktionen auf dem neuesten Stand. Gleichzeitig hilft sie anderen dabei, ihre eigenen Kopien herunterzuladen und zu aktualisieren.",
+ "run-a-node-1-b-label": "32 ETH einzahlen, um Belohnungen zu verdienen",
+ "run-a-node-1-b-explanation": "Dies ist eine Voraussetzung für das Staking, d. h. den Prozess, ein aktiver Teilnehmer am Netzwerkkonsens zu werden. Dies ist nicht erforderlich, um lediglich eine souveräne Kopie der Blockchain auszuführen, wofür KEINE ETH benötigt werden.",
+ "run-a-node-1-c-label": "Betrieb leistungsstarker ASIC-Mining-Computer, um Netzwerkkonsens zu erreichen",
+ "run-a-node-1-c-explanation": "Obwohl Ethereum früher das Mining mit leistungsstarken Computern nutzte, um einen Konsens zu erreichen, wurde dieser Prozess vollständig durch das Staking ersetzt. Weder das Mining in der Vergangenheit noch das Staking in der Gegenwart waren bzw. sind erforderlich, um einfach eine souveräne Kopie der Blockchain auszuführen.",
+ "run-a-node-1-d-label": "Vollzeit-Anstellung in der Blockchain-Infrastruktur",
+ "run-a-node-1-d-explanation": "Das Software-Tooling hat sich im Laufe der Zeit immer weiter verbessert, sodass der Betrieb eines Nodes von zu Hause aus auch für unerfahrene Nutzer viel einfacher geworden ist. Eine Vollzeitbeschäftigung in der Blockchain-Infrastruktur ist keineswegs eine Voraussetzung für eine Teilnahme.",
+ "run-a-node-2-prompt": "Wie viele ETH müssen Sie staken, um einen Node zu betreiben?",
+ "run-a-node-2-a-label": "0",
+ "run-a-node-2-a-explanation": "Für den Betrieb eines Ethereum-Nodes sind keine ETH erforderlich. Im Gegensatz zum Betrieb eines Staking-Validators als Teil eines Node-Setups steht es jedem frei, Client-Software zu betreiben und eigene souveräne Kopien der Blockchain zu synchronisieren – hierfür werden keine ETH benötigt.",
+ "run-a-node-2-b-label": "8",
+ "run-a-node-2-c-label": "16",
+ "run-a-node-2-d-label": "32",
+ "run-a-node-2-d-explanation": "Der Betrieb eines Ethereum-Nodes erfordert keine ETH. Für die Aktivierung eines Staking-Validators, der direkt am Netzwerkkonsens teilnimmt, sind zwar 32 ETH erforderlich. Es steht aber jedem frei, Client-Software auszuführen und eigene souveräne Kopien der Blockchain zu synchronisieren – hierfür werden keine ETH benötigt.",
+ "run-a-node-3-prompt": "Welche Vorteile haben Sie, wenn Sie Ihren eigenen Node betreiben?",
+ "run-a-node-3-a-label": "Resistent gegenüber Zensur",
+ "run-a-node-3-a-explanation": "Dies ist ein Vorteil für die Nutzer, aber nicht der einzige. Durch das Ausführen von Node-Software, die direkt mit anderen Peers im Netzwerk kommuniziert, werden Ihre Transaktionen mit jeder anderen Transaktion vermischt, die Ihr Node verbreitet. Auf diese Weise ist es annähernd unmöglich, eine gültige Transaktion, die Ihr Node geteilt hat, zu identifizieren und zu zensieren.",
+ "run-a-node-3-b-label": "Souveränität",
+ "run-a-node-3-b-explanation": "Dies ist ein Vorteil für die Nutzer, aber nicht der einzige. Wenn Sie Ihre eigene Kopie der Ethereum-Blockchain besitzen, sind Sie bei der Interaktion mit dem Netzwerk nicht mehr von einer einzigen externen Partei abhängig. Sie müssen nie um Erlaubnis bitten, um Ihr Guthaben abzurufen oder eine Transaktion auszuführen. Darüber hinaus werden alle Transaktionen mit einer Software überprüft, die Sie selbst ausführen. Wenn das Netzwerk aktualisiert wird, entscheiden Sie selbst, ob Sie das Upgrade unterstützen wollen oder nicht.",
+ "run-a-node-3-c-label": "Privatsphäre",
+ "run-a-node-3-c-explanation": "Dies ist ein Vorteil für die Nutzer, aber nicht der einzige. Ohne einen eigenen Knoten sind in der Regel einige Schritte erforderlich, um nur das eigene Guthaben abzufragen. So müssen Sie eine Liste Ihrer Nodes von der Wallet, die mit Ihrer IP-Adresse verknüpft ist, an einen Drittanbieter senden, der Ihnen dann die richtigen Informationen liefert.",
+ "run-a-node-3-d-label": "Alle oben Genannte",
+ "run-a-node-3-d-explanation": "Das Betreiben eines Nodes gibt Ihnen die volle Kontrolle und Souveränität über die Daten, auf die Sie sich stützen. Es ermöglicht es Ihnen, den Inhalt der Chain privat einzusehen und zu überprüfen und praktisch zu garantieren, dass alle gültigen Transaktionen unzensiert dargestellt werden.",
+ "run-a-node-4-prompt": "Welche Art von Festplattenspeicher ist für einen Ethereum-Node erforderlich?",
+ "run-a-node-4-a-label": "512 GB SSD",
+ "run-a-node-4-a-explanation": "Derzeit ist keine Client-Software in der Lage, die Chain mit nur 512 GB zu speichern",
+ "run-a-node-4-b-label": "2 TB, rotierend",
+ "run-a-node-4-b-explanation": "Im Allgemeinen unterstützen rotierende Festplatten nicht die erforderlichen Lese- und Schreibgeschwindigkeiten, um mit den Verarbeitungsanforderungen für einen Ethereum-Node Schritt zu halten. Empfohlen wird ein SSD-Laufwerk.",
+ "run-a-node-4-c-label": "2 TB SSD Festplatte",
+ "run-a-node-4-c-explanation": "Zum Zeitpunkt der Erstellung dieses Artikels sollte ein SSD-Laufwerk mit 2 TB die Anforderungen an die für einen vollständigen Ethereum-Node erforderlichen Speicher-, Lese- und Schreibgeschwindigkeiten erfüllen.",
+ "run-a-node-4-d-label": "SSD-Festplatte mit 8 TB",
+ "run-a-node-4-d-explanation": "Zum Zeitpunkt der Erstellung dieses Artikels sollte ein SSD-Laufwerk mit 2 TB die Anforderungen an die für einen vollständigen Ethereum-Node erforderlichen Speicher-, Lese- und Schreibgeschwindigkeiten erfüllen. Eine SSD mit 8 TB würde zusätzliche Zukunftssicherheit und die Möglichkeit bieten, auch Layer-2-Ketten zu synchronisieren. Dies sind aber derzeit keine Voraussetzungen für das Mainnet.",
+ "run-a-node-5-prompt": "Was passiert, wenn Ihr Node offline geht?",
+ "run-a-node-5-a-label": "Ihr Node wird dann nicht mehr mit dem aktuellen Zustand des Netzes synchronisiert",
+ "run-a-node-5-a-explanation": "Wenn Ihr Node online nicht verfügbar ist, kann er keine neuen Transaktionen und Blöcke von Peers empfangen. Folglich wird er nicht mehr mit dem aktuellen Zustand der Chain synchronisiert. Sobald die Online-Verbindung für den Node wiederhergestellt wird, lässt sich die entsprechende Software wieder synchronisieren und ist wieder voll funktionsfähig.",
+ "run-a-node-5-b-label": "Die ETH in Ihrer Cold Storage werden geslasht",
+ "run-a-node-5-b-explanation": "ETH, die Sie in Ihrer Cold Storage aufbewahren, haben nichts damit zu tun, ob Ihr Node online ist oder nicht. Wenn Ihr Node offline ist, können Sie ihn nicht verwenden, um das aktuelle Guthaben Ihrer Konten abzurufen. Der Offline-Zustand bedeutet jedoch keine Risiken für Ihre gesicherten Geldmittel. Wenn Sie zusätzlich Validator-Software mit Ihrem Node als Staker ausführen, werden kleine Strafen auf das Validator-Guthaben für die Dauer erhoben, die er nicht im Netzwerk verfügbar ist.",
+ "run-a-node-5-c-label": "Die für die Suche nach Proof-of-Work eingesetzte Energie wird verschwendet",
+ "run-a-node-5-c-explanation": "Ethereum setzt kein Proof-of-Work mehr ein. Dies war aber auch nie eine Anforderung an alle Node-Betreiber. Wenn Sie offline sind, bedeutet dies lediglich, dass Ihr Node nicht mehr mit den neuesten Änderungen im Netzwerk synchronisiert wird. Durch eine Rückkehr ins Netz kann er wieder synchronisiert werden.",
+ "run-a-node-5-d-label": "Die Chain-Daten werden entfernt und eine erneute Synchronisierung von Grund auf ist erforderlich",
+ "run-a-node-5-d-explanation": "Wenn Sie einfach offline gehen, werden normalerweise keine gespeicherten Chain-Daten gelöscht. Wenn Sie sich wieder mit dem Internet verbinden, kann die Software dort weitermachen, wo sie aufgehört hat, und wird wieder mit den neuesten Transaktionen synchronisiert.",
+ "run-a-node-6-prompt": "Durch das Betreiben eines Nodes erhalten Sie Netzwerkbelohnungen",
+ "run-a-node-6-a-label": "Richtig",
+ "run-a-node-6-a-explanation": "Wenn Sie die Client-Software nur ausführen, erhalten Sie noch keine Prämien. Um Belohnungen zu erhalten, müssen Sie auch Staking betreiben.",
+ "run-a-node-6-b-label": "Falsch",
+ "stablecoins-1-prompt": "Was sind Stablecoins?",
+ "stablecoins-1-a-label": "Kryptowährungen mit geringen Kursschwankungen; ihr Wert ist stabil und mit traditionellen Währungen vergleichbar",
+ "stablecoins-1-a-explanation": "Stimmt! Stablecoins sind die Antwort auf das Volatilitätsproblem, das man von vielen anderen Kryptowährungen kennt.",
+ "stablecoins-1-b-label": "Digitale Abbilder von Gold",
+ "stablecoins-1-b-explanation": "Das stimmt so nicht. Es stimmt zwar, dass einige Stablecoins durch Edelmetalle gedeckt sind, aber die Deckung kann genauso gut durch Fiat-Währungen oder andere Kryptowährungen erfolgen.",
+ "stablecoins-1-c-label": "Eine neue Art der Kreditkarte",
+ "stablecoins-1-c-explanation": "Das ist falsch. Stablecoins sind eine Art der Kryptowährung, keine Kreditkarte.",
+ "stablecoins-1-d-label": "Ein Ersatz für Ether",
+ "stablecoins-1-d-explanation": "Das ist nicht korrekt. Stablecoins sind nicht dazu gedacht, Ether (ETH) zu ersetzen. Es handelt sich vielmehr um einen weiteren Token-Typ im Ethereum-Netzwerk, der darauf ausgelegt ist, einen stabilen Wert zu halten.",
+ "stablecoins-2-prompt": "Welcher der folgenden ist ein Stablecoin?",
+ "stablecoins-2-a-label": "US-Dollar",
+ "stablecoins-2-a-explanation": "Das ist falsch. Stablecoins können den US-Dollar repräsentieren, dennoch ist der US-Dollar keine Kryptowährung.",
+ "stablecoins-2-b-label": "Der AAVE Token",
+ "stablecoins-2-b-explanation": "Das stimmt so nicht. AAVE ist der Governance-Token für das Aave-Protokoll. Dieses Protokoll stellt zwar Marktplätze für Stablecoins bereit, aber AAVE selbst ist kein Stablecoin.",
+ "stablecoins-2-c-label": "Dai",
+ "stablecoins-2-c-explanation": "Stimmt! Dai ist wohl der berühmteste dezentrale Stablecoin, und sein Wert entspricht ziemlich genau 1 US-Dollar.",
+ "stablecoins-2-d-label": "Ether",
+ "stablecoins-2-d-explanation": "Das ist falsch. Ether ist die native Währung des Ethereum Netzwerks aber es ist nicht dazu gedacht, stabil zu sein.",
+ "stablecoins-3-prompt": "Wofür können Stablecoins benutzt werden?",
+ "stablecoins-3-a-label": "Um ihre Nutzer vor sprunghaften Änderungen des Preises zu schützen",
+ "stablecoins-3-a-explanation": "Nicht ganz. Diese Antwort ist teilweise richtig, aber es ist nur eine der vielen Sachen, für die Stablecoins verwendet werden können.",
+ "stablecoins-3-b-label": "Um Dinge im Internet von überall auf der Welt zu kaufen",
+ "stablecoins-3-b-explanation": "Nicht ganz. Diese Antwort ist teilweise richtig, aber es ist nur eine der vielen Sachen, für die Stablecoins verwendet werden können.",
+ "stablecoins-3-c-label": "Um Geld zu verdienen, indem man es verleiht",
+ "stablecoins-3-c-explanation": "Nicht ganz. Diese Antwort ist teilweise richtig, aber es ist nur eine der vielen Sachen, für die Stablecoins verwendet werden können.",
+ "stablecoins-3-d-label": "Alle oben Genannte",
+ "stablecoins-3-d-explanation": "Richtig! Stablecoins können dazu genutzt werden, Kryptowährungen mit weniger Unbeständigkeit zu halten, von überall Dinge im Internet zu kaufen und Zinsen beim Verleihen zu erhalten.",
+ "stablecoins-4-prompt": "Was macht Stablecoins einzigartig?",
+ "stablecoins-4-a-label": "Es handelt sich um einen Token, der an einen realen Vermögenswert (einen „Asset“) gebunden ist",
+ "stablecoins-4-a-explanation": "Das stimmt so nicht. Obwohl viele Stablecoins an reale Vermögenswerte gebunden sind, ist dieses Merkmal nicht nur bei Stablecoins zu finden (Beispiel: ETH-besicherte Token).",
+ "stablecoins-4-b-label": "Es ist ein Krypto-Token, der speziell darauf ausgelegt ist, preisstabil zu bleiben",
+ "stablecoins-4-b-explanation": "Stimmt! Stablecoins sind zwar darauf ausgelegt, ihren Wert relativ stabil zu halten – meist durch die Kopplung an Vermögenswerte wie Währungen (z. B. 1 USDC = 1 US-Dollar) –, aber nicht alle Stablecoins nutzen dieses Modell (siehe RAI).",
+ "stablecoins-4-c-label": "Es kann über das Internet gesendet werden",
+ "stablecoins-4-c-explanation": "Das ist falsch. Obwohl dies möglich ist, ist es nicht nur bei Stablecoins der Fall.",
+ "stablecoins-4-d-label": "Es kann im Ethereum Netzwerk genutzt werden.",
+ "stablecoins-4-d-explanation": "Das stimmt so nicht. Es gibt noch viele andere Krypto-Token, die auf dem Ethereum-Netzwerk genutzt werden können.",
+ "stablecoins-5-prompt": "Was ist KEIN Weg Stablecoins zu bekommen?",
+ "stablecoins-5-a-label": "Mit anderen Tokens tauschen",
+ "stablecoins-5-a-explanation": "Falsch, dies ist ein Weg Stablecoins zu bekommen. Einer der gewöhnlichsten Wege, Stablecoins zu bekommen ist es, vorher erhaltene Kryptowährungen gegen Stablecoins zu tauschen.",
+ "stablecoins-5-b-label": "Leihen",
+ "stablecoins-5-b-explanation": "Falsch, dies ist ein Weg Stablecoins zu bekommen. Sie können Stablecoins leihen, indem sie andere Kryptowährungen, wie zum Beispiel Ether, als Sicherheiten anbieten. Sie müssen die geliehenen Stablecoins wieder zurückzahlen, um ihre Sicherheiten zurückgezahlt zu bekommen.",
+ "stablecoins-5-c-label": "Du kannst sie über eine Börse kaufen",
+ "stablecoins-5-c-explanation": "Das stimmt nicht, denn das ist durchaus eine Methode, um an Stablecoins zu kommen. Viele Börsen und Wallets bieten den direkten Kauf von Stablecoins an. Für zentralisierte Börsen können jedoch geografische Beschränkungen gelten.",
+ "stablecoins-5-d-label": "Minen",
+ "stablecoins-5-d-explanation": "Richtig! Anders als Bitcoin kann man Stablecoins nicht minen.",
+ "defi-1-prompt": "Wofür steht DeFi?",
+ "defi-1-a-label": "Dezentrale Finanzen",
+ "defi-1-a-explanation": "Richtig! DeFi steht für dezentrale Finanzen, ein finanzielles System gebaut auf Ethereum, das ohne Vermittler wie Banken oder finanzielle Institutionen arbeitet.",
+ "defi-1-b-label": "Digital Finance",
+ "defi-1-b-explanation": "Das ist nicht ganz richtig. Der Begriff „Digital Finance“ beschreibt Finanzdienstleistungen, die digital bereitgestellt werden. Das hat aber nicht zwangsläufig etwas mit Dezentralisierung zu tun.",
+ "defi-1-c-label": "Distributed Finance",
+ "defi-1-c-explanation": "Das ist nicht richtig. \"Distributed\" (verteilt) kann zwar Dezentralisierung andeuten, in der Branche spricht man aber nicht von \"Distributed Finance\", sondern von \"Decentralized Finance\".",
+ "defi-1-d-label": "Development Finance",
+ "defi-1-d-explanation": "Das ist nicht korrekt. Bei „Development Finance“ (Entwicklungsfinanzierung) geht es um die Finanzierung von Projekten zur Wirtschaftsförderung, meist in Entwicklungsländern. Mit Blockchain oder DeFi hat dieser Begriff nichts zu tun.",
+ "defi-2-prompt": "Was lässt sich mit DeFi NICHT machen?",
+ "defi-2-a-label": "Geld rund um die Welt senden.",
+ "defi-2-a-explanation": "Das ist nicht korrekt. DeFi ermöglicht es dir, Geldbeträge ohne jegliche Begrenzung an jeden beliebigen Ort der Welt zu senden.",
+ "defi-2-b-label": "Wende dich an den Kundensupport, um deine Fehler korrigieren zu lassen.",
+ "defi-2-b-explanation": "Stimmt! In der DeFi-Welt sind Transaktionen unumkehrbar und werden durch Code kontrolliert, nicht durch eine Firma. Passiert dir ein Fehler – sendest du zum Beispiel Geld an die falsche Adresse – gibt es keinen Kundensupport, der das Problem beheben kann. Du musst also extrem aufpassen.",
+ "defi-2-c-label": "Kredite mit hinterlegten Sicherheiten aufnehmen.",
+ "defi-2-c-explanation": "Das ist nicht richtig. Im Gegensatz zu traditionellen Banken, bei denen Genehmigungsprozesse Tage dauern, kannst du dir mit DeFi sofort Geld leihen.",
+ "defi-2-d-label": "Trade deine Tokens 24/7.",
+ "defi-2-d-explanation": "Das ist nicht richtig. DeFi erlaubt dir den 24/7-Handel mit Tokens. Die Märkte schlafen nie, und du kannst deine ETH zu jeder Zeit gegen USDT oder eine beliebige andere Währung tauschen.",
+ "defi-3-prompt": "Welche DeFi-Plattform ist für den direkten Tausch (Swap) von Tokens zwischen Nutzern bekannt?",
+ "defi-3-a-label": "Uniswap",
+ "defi-3-a-explanation": "Stimmt! Uniswap ist eine dezentrale Börse, auf der Nutzer Tokens mittels automatisierter Market-Making-Mechanismen direkt miteinander tauschen (swappen) können.",
+ "defi-3-b-label": "Aave",
+ "defi-3-b-explanation": "Das stimmt so nicht. Bei Aave geht es um das Leihen und Verleihen (Lending & Borrowing), nicht um den Tausch von Tokens.",
+ "defi-3-c-label": "PoolTogether",
+ "defi-3-c-explanation": "Das ist nicht richtig. PoolTogether ist für seine verlustfreien Lotterien bekannt, die eine innovative neue Sparmethode darstellen.",
+ "defi-3-d-label": "MakerDao",
+ "defi-3-d-explanation": "Das stimmt so nicht. Mit MakerDAO kannst du zwar den DAI-Stablecoin ausgeben und verwalten, der Fokus der Plattform liegt aber nicht auf dem Tausch von Tokens.",
+ "defi-4-prompt": "Wo werden eigentlich die Informationen deiner Transaktion gespeichert, wenn du eine DeFi-App benutzt?",
+ "defi-4-a-label": "ETH",
+ "defi-4-a-explanation": "Das ist nicht richtig. Daten werden nicht in Ether (ETH) gespeichert, sondern ETH ist der native Vermögenswert der Ethereum-Blockchain.",
+ "defi-4-b-label": "Meine Wallet",
+ "defi-4-b-explanation": "as ist nicht korrekt. Eine Wallet verwaltet deinen Ethereum-Account über eine Verbindung zur Blockchain. Dein Transaktionsverlauf wird jedoch nicht in der Wallet gespeichert, sondern auf der Blockchain selbst.",
+ "defi-4-c-label": "DeFi-Apps",
+ "defi-4-c-explanation": "Das stimmt so nicht. DeFi-Apps selbst speichern deinen Transaktionsverlauf nicht. Stattdessen werden alle deine Transaktionsdetails auf der Ethereum-Blockchain erfasst.",
+ "defi-4-d-label": "Ethereum Blockchain",
+ "defi-4-d-explanation": "Stimmt! Ethereum speichert in seiner Funktion als Blockchain alle Daten, die von Nutzern und Apps erzeugt werden. Auf diese Weise können Validatoren im gesamten P2P-Netzwerk einen einheitlichen State aufrechterhalten.",
+ "defi-5-prompt": "Was ist die technische Grundlage für Dezentrale Finanzen (DeFi) auf Ethereum?",
+ "defi-5-a-label": "Smart Contracts",
+ "defi-5-a-explanation": "Stimmt! Smart Contracts kannst du dir wie digitale „Wenn-dann“-Bedingungen vorstellen, die auf Ethereum geschrieben sind. Sie ersetzen herkömmliche Verträge sowie Mittelsmänner, indem sie Transaktionen automatisch ausführen, sobald bestimmte Bedingungen erfüllt werden.",
+ "defi-5-b-label": "Mittelsmänner",
+ "defi-5-b-explanation": "Das stimmt so nicht. Ethereum benötigt für die Ausführung von Transaktionen keine Mittelsmänner, sondern alles läuft über Smart Contracts direkt auf der Chain.",
+ "defi-5-c-label": "Bitcoin",
+ "defi-5-c-explanation": "Das ist nicht richtig. Bitcoin ist ein einfaches Netzwerk zur Wertaufbewahrung und kann keine fortgeschrittenen Programme ausführen. DeFi ist darauf jedoch angewiesen, denn es braucht ein flexibleres System wie Ethereum, das komplexe Programme zur automatischen Handhabung von Krediten und Trades ausführen kann.",
+ "defi-5-d-label": "Das traditionelle Finanzsystem",
+ "defi-5-d-explanation": "Das ist nicht korrekt. DeFi-Apps sind nicht auf traditionelle Finanzinstitute angewiesen. Stattdessen verwenden sie Smart Contracts – spezielle Blockchain-Programme –, um Transaktionen automatisch abzuwickeln.",
+ "smart-contracts-1-prompt": "Was zeichnet Smart Contracts aus?",
+ "smart-contracts-1-a-label": "Smart Contracts sind im Prinzip wie rechtliche Verträge, nur mit dem Unterschied, dass sie digital auf der Blockchain gespeichert werden, um den Inhalt sicher aufzubewahren.",
+ "smart-contracts-1-a-explanation": "Abgesehen von einer ähnlichen Logik wie bei traditionellen Verträgen haben Smart Contracts ansonsten wenig mit ihnen gemeinsam.",
+ "smart-contracts-1-b-label": "Gekoppelt an autonome KI-Systeme, welche Transaktionen ausführen",
+ "smart-contracts-1-b-explanation": "Smart Contracts funktionieren nach einer vorhersagbaren „Wenn-dies-dann-das“-Logik, die im Code definiert ist, und führen Transaktionen entsprechend aus – sie nutzen keinerlei KI",
+ "smart-contracts-1-c-label": "On-Chain-Programme, die auf einer „Wenn-dies-dann-das“-Logik basieren und die nachweislich immer genau nach ihren eigenen Regeln ausgeführt werden",
+ "smart-contracts-1-c-explanation": "Ein Smart Contract ist ein Ethereum-Account, dessen Funktionalität durch seinen unveränderlichen, bereitgestellten Code definiert wird.",
+ "smart-contracts-1-d-label": "Sie stellen das Regelwerk der Ethereum-Blockchain dar, das in Zusammenarbeit mit Anwälten entwickelt wurde, um die Einhaltung von Gesetzen zu garantieren.",
+ "smart-contracts-1-d-explanation": "Smart Contracts sind Code-Abschnitte, die du als Entwickler erstellen und auf einer Blockchain veröffentlichen kannst.",
+ "smart-contracts-2-prompt": "Welche Metapher charakterisiert die Funktionsweise von Smart Contracts am ehesten?",
+ "smart-contracts-2-a-label": "Eine Bank",
+ "smart-contracts-2-a-explanation": "Banken benötigen eine manuelle Ausführung und sind hierarchisch aufgebaut. Im Gegensatz dazu werden Smart Contracts von Computern ausgeführt – und zwar vorhersagbar und nach unveränderlichen Regeln.",
+ "smart-contracts-2-b-label": "Ein digitaler Verkaufsautomat",
+ "smart-contracts-2-b-explanation": "Ein Verkaufsautomat gibt das gewünschte Produkt erst dann aus, wenn alle Bedingungen erfüllt sind. Spezifische Eingaben führen also zu garantierten, deterministischen Ergebnissen. Das ist der Logik von Smart Contracts sehr ähnlich.",
+ "smart-contracts-2-c-label": "Ein Taschenrechner",
+ "smart-contracts-2-c-explanation": "Smart-Contract-Code kann zwar für Berechnungen genutzt werden, ist aber nicht darauf limitiert. Es handelt sich vielmehr um Blockchain-basierte Programme, die einer „Wenn-dies-dann-das“-Logik folgen.",
+ "smart-contracts-2-d-label": "Eine Webseite",
+ "smart-contracts-2-d-explanation": "an kann sich eine Webseite als das Frontend vorstellen, das die Anweisungen des Nutzers aufnimmt. Der Smart Contract ist im Vergleich dazu die Backend-Logik, die diese Anweisungen verarbeitet und ein Ergebnis zurückliefern kann.",
+ "smart-contracts-3-prompt": "Welche der folgenden Eigenschaften ist KEIN Hauptmerkmal von Smart Contracts?",
+ "smart-contracts-3-a-label": "Deterministisches Ausführungsverhalten",
+ "smart-contracts-3-a-explanation": "Der entscheidende Vorteil eines Smart Contracts ist, dass er eindeutigen Code vorhersagbar (deterministisch) ausführt und dabei menschliche Interpretation oder Voreingenommenheit ausschließt.",
+ "smart-contracts-3-b-label": "Öffentliche Aufzeichnung",
+ "smart-contracts-3-b-explanation": "Dank Smart Contracts auf einer öffentlichen Blockchain sind Asset-Transfers und andere zugehörige Informationen für jeden sofort nachverfolgbar.",
+ "smart-contracts-3-c-label": "Schutz der Privatsphäre",
+ "smart-contracts-3-c-explanation": "Blockchains sind pseudonyme Netzwerke. Das bedeutet, dass Transaktionen öffentlich einer eindeutigen kryptografischen Adresse zugeordnet werden, und nicht einer Identität.",
+ "smart-contracts-3-d-label": "Veränderbarkeit",
+ "smart-contracts-3-d-explanation": "Ein einmal erstellter Smart Contract kann nicht mehr geändert werden. Dies garantiert, dass er immer genau nach den Regeln ausgeführt wird, die sein Code vorschreibt.",
+ "smart-contracts-4-prompt": "Wofür werden Smart Contracts NICHT verwendet?",
+ "smart-contracts-4-a-label": "Stablecoins",
+ "smart-contracts-4-a-explanation": "Stablecoins sind Token, deren Definition und Nachverfolgung durch Smart Contracts erfolgt.",
+ "smart-contracts-4-b-label": "Änderungen am Protokoll",
+ "smart-contracts-4-b-explanation": "Obwohl Protokolländerungen teils Smart Contracts nutzen, ist der Prozess für ihre Erstellung und Definition ein anderer: Sie werden in transparenten Online-Foren vorgeschlagen und anschließend in der Client-Software umgesetzt.",
+ "smart-contracts-4-c-label": "Non-fungible Token (NFT)",
+ "smart-contracts-4-c-explanation": "Smart Contracts werden genutzt, um ein breites Spektrum an NFTs zu definieren, angefangen bei digitaler Kunst bis hin zu Besitzurkunden.",
+ "smart-contracts-4-d-label": "Freier Devisenhandel",
+ "smart-contracts-4-d-explanation": "Dezentrale Börsen (DEXs) basieren auf Smart Contracts und funktionieren dadurch ohne eine zentrale Kontrollinstanz."
}
diff --git a/src/intl/de/page-10-year-anniversary.json b/src/intl/de/page-10-year-anniversary.json
new file mode 100644
index 00000000000..f0fb65e5df5
--- /dev/null
+++ b/src/intl/de/page-10-year-anniversary.json
@@ -0,0 +1,131 @@
+{
+ "page-10-year-anniversary-meta-title": "10-jähriges Jubiläum",
+ "page-10-year-anniversary-meta-description": "Wir feiern 10 Jahre Zensurresistenz, 100 % Verfügbarkeit, Dezentralisierung, Community-Aufbau, Entwicklerwachstum, globale Zusammenarbeit, Cypherpunk-Werte, Hackathons, Zensurresistenz, genehmigungsfreie Finanzen, glaubwürdige Neutralität, den unendlichen Garten, Client-Vielfalt und mehr.",
+ "page-10-year-censorship-resistance": "resistent gegenüber Zensur",
+ "page-10-year-uptime": "100 % Betriebszeit",
+ "page-10-year-decentralization": "Dezentralisierung",
+ "page-10-year-community-building": "Gemeinschaftsbildung",
+ "page-10-year-developer-growth": "Entwicklerwachstum",
+ "page-10-year-global-collaboration": "Globale Zusammenarbeit",
+ "page-10-year-cypherpunk-values": "Cyberpunk-Werte",
+ "page-10-year-hackathons": "Hackathon",
+ "page-10-year-permissionless-finance": "Genehmigungsfreie Finanzierung",
+ "page-10-year-credible-neutrality": "Lesbare Neutralität",
+ "page-10-year-infinite-garden": "Der unendliche Garten",
+ "page-10-year-client-diversity": "client-Diversität",
+ "page-10-year-celebrating": "Wir feiern 10 Jahre",
+ "page-10-year-hero-title": "Ein Jahrzehnt, in dem die Welt Block für Block verändert wurde",
+ "page-10-year-hero-description": "Am 30. Juli 2015 wurde die Ethereum-Blockchain geboren. Der Moment, in dem der Genesis-Block geschürft wurde, eröffnete dem Internet neue Möglichkeiten und brachte grundlegende Veränderungen in den Bereichen Finanzen, Eigentum und Programmierbarkeit mit sich.",
+ "page-10-year-hero-tagline": "Zehn Jahre geschafft, die Ewigkeit liegt vor uns.",
+ "page-10-year-join-party-title": "Machen Sie mit bei der Party",
+ "page-10-year-join-party-description": "Feiern Sie 10 Jahre Ethereum mit der globalen Community. Finden Sie ein lokales Event oder starten Sie Ihre eigene Feier.",
+ "page-10-year-events-description-1": "Schließen Sie sich Menschen auf der ganzen Welt an, um an Vorträgen, Networking und Feierlichkeiten teilzunehmen, während wir den zehnten Geburtstag von Ethereum begehen.",
+ "page-10-year-events-description-2": "Sie können nicht persönlich dabei sein? Sehen Sie sich unseren Livestream an und verfolgen Sie die Updates von Events weltweit, damit wir alle diesen Meilenstein gemeinsam feiern können.",
+ "page-10-year-host-event-title": "Teilen Sie Ihr Event",
+ "page-10-year-host-event-description": "Veranstalten Sie ein Event? Geben Sie unten die Event-Details ein, um es auf der Karte eintragen zu lassen.",
+ "page-10-year-host-event-cta": "Event teilen",
+ "page-10-year-innovation-title": "10 Jahre",
+ "page-10-year-innovation-subtitle": "Innovation",
+ "page-10-year-innovation-description-1": "Ethereum hat die Blockchain durch die Einführung von Smart Contracts transformiert.",
+ "page-10-year-innovation-description-2": "Mit Ethereum verwandelten sich Blockchains von einem digitalen Hauptbuch in eine programmierbare Plattform, auf der Code automatisch ausgeführt wird, wenn Bedingungen erfüllt sind.",
+ "page-10-year-innovation-description-3": "Die Innovation von Ethereum ermöglichte völlig neue Branchen wie DeFi, NFTs und DAOs. Sie erweiterte die Blockchain über die digitale Währung hinaus zu einer Plattform, die neu definierte, wie wir Werte schaffen und austauschen.",
+ "page-10-year-adoption-title": "10 Jahre",
+ "page-10-year-adoption-subtitle": "Verbreitung",
+ "page-10-year-adoption-description-1": "Von einem Whitepaper zu über 24 Mio. täglichen Transaktionen innerhalb des Ethereum-Ökosystems",
+ "page-10-year-adoption-description-2": "Ethereum hat sich zu einer globalen Computerplattform entwickelt, die Tausende von Anwendungen antreibt, die täglich von Millionen genutzt werden. Sie überspannt Branchen und Grenzen und erweitert kontinuierlich ihre Anwendungsfälle.",
+ "page-10-year-stories-title": "10 Jahre",
+ "page-10-year-stories-subtitle": "Geschichten",
+ "page-10-year-stories-description-1": "Ein Überblick darüber, wie Ethereum im täglichen Leben verwendet wird",
+ "page-10-year-stories-description-2": "Von Millionen von Wallets bis in jeden Winkel der Welt nutzen Menschen Ethereum auf inspirierende Weise. Diese wahren Geschichten zeigen Kreativität, Freiheit und Verbindung, die durch Ethereum ermöglicht werden.",
+ "page-10-year-stories-cta": "Teilen Sie Ihre Geschichte",
+ "page-10-year-ideas-title": "Haben Sie eine Idee, wie die Community feiern kann?",
+ "page-10-year-ideas-description": "Onchain-Artefakte, ein weltweites Ethereum-Quizspiel, die Möglichkeiten sind grenzenlos! Teilen Sie uns unten Ihre Idee mit.",
+ "page-10-year-ideas-cta": "Ihre Idee einreichen",
+ "page-10-year-event-link": "Zum Event gehen",
+ "page-10-year-countdown-expired": "Ethereum ist 10 Jahre alt! 🚀",
+ "page-10-year-countdown-day": "Tag",
+ "page-10-year-countdown-days": "Tage",
+ "page-10-year-countdown-hour": "Stunde",
+ "page-10-year-countdown-hours": "Stunden",
+ "page-10-year-countdown-minute": "Minute",
+ "page-10-year-countdown-minutes": "Minuten",
+ "page-10-year-countdown-second": "Sekunde",
+ "page-10-year-countdown-seconds": "Sekunden",
+ "page-10-year-banner-header": "10 Jahre Ethereum",
+ "page-10-year-banner-launch-text": "Am 30. Juli 2015 um 15:44 Uhr UTC wurde der erste Block der Ethereum-Blockchain zum Leben erweckt.",
+ "page-10-year-banner-tagline": "Zehn Jahre geschafft, die Unendlichkeit liegt vor uns! 🚀",
+ "page-10-year-banner-cta": "Machen Sie mit bei der Party",
+ "page-10-year-stories-read-more": "Weiterlesen",
+ "page-10-year-stories-show-original": "Original anzeigen",
+ "page-10-year-stories-show-english": "Englisch anzeigen",
+ "page-10-year-stories-original-language": "Originalsprache",
+ "page-10-year-stories-english-translation": "Englische Übersetzung",
+ "page-10-year-stories-show-more": "Mehr anzeigen",
+ "page-10-year-globe-go-to-event": "Zum Event gehen",
+ "page-10-year-innovation-card-1-title": "Ethereum-Start",
+ "page-10-year-innovation-card-1-date": "30. Juli 2015",
+ "page-10-year-innovation-card-1-description-1": "Der Genesis-Block von Ethereum ging live und startete damit das \"Frontier\"-Netzwerk. Diese minimalistische Version gab Entwicklern ihre erste Chance, dezentralisierte Anwendungen zu erstellen und mit Smart Contracts zu experimentieren.",
+ "page-10-year-innovation-card-1-description-2": "Die Mission von Ethereum: ein offenes Internet, in dem Benutzer die Kontrolle über ihre Daten haben, Anwendungen ohne Gatekeeper laufen und Werte frei zwischen Menschen fließen.",
+ "page-10-year-innovation-card-2-title": "DAI: Der Pionier unter den Stablecoins",
+ "page-10-year-innovation-card-2-date": "Dezember 2015",
+ "page-10-year-innovation-card-2-description-1": "Der erste dezentralisierte Stablecoin wurde eingeführt. DAI hält eine weiche Bindung an den US-Dollar durch Kryptowährungs-Sicherheiten, die in Smart Contracts gesperrt sind.",
+ "page-10-year-innovation-card-2-description-2": "Im Gegensatz zu zentralisierten Stablecoins, die von Unternehmen kontrolliert werden, wird DAI von einer dezentralisierten autonomen Organisation (DAO) verwaltet, was es vertrauenslos und von der Community gesteuert macht.",
+ "page-10-year-innovation-card-3-title": "CryptoKitties und die NFT-Frontier",
+ "page-10-year-innovation-card-3-date": "November 2017",
+ "page-10-year-innovation-card-3-description-1": "CryptoKitties hat digitalen Besitz zum Leben erweckt. Dieses frühe NFT-Spiel zeigte, wie die Blockchain neue Formen des Ausdrucks, der Sammelbarkeit und der Online-Kultur ermöglichen kann.",
+ "page-10-year-innovation-card-3-description-2": "Es bewies, dass Ethereum über das Finanzwesen hinaus in die Bereiche Gaming, Kunst und digitale Identität skalieren und so völlig neue kreative Möglichkeiten eröffnen kann.",
+ "page-10-year-innovation-card-4-title": "DeFi-Sommer",
+ "page-10-year-innovation-card-4-date": "Juni 2020",
+ "page-10-year-innovation-card-4-description-1": "Das explosive Wachstum von DeFi hat die Art und Weise, wie die Welt über Finanzen denkt, neu definiert. Protokolle für Kreditvergabe, Handel und Renditegenerierung gewannen massiv an Dynamik und zeigten die Stärke einer offenen, zusammensetzbaren Finanzinfrastruktur.",
+ "page-10-year-innovation-card-4-description-2": "In dieser Zeit wurden Milliardenwerte on-chain gebracht und Ethereum als das Zuhause der dezentralen Finanzen etabliert.",
+ "page-10-year-innovation-card-5-title": "Kommendes Update – die Zusammenführung („The Merge“)",
+ "page-10-year-innovation-card-5-date": "15. September 2022",
+ "page-10-year-innovation-card-5-description-1": "Die bisher größte Transformation von Ethereum. Das Netzwerk ist nahtlos vom energieintensiven Proof-of-Work zum Proof-of-Stake übergegangen. Bei Milliardenwerten auf Ethereum wurde der Wechsel als das Austauschen eines Flugzeugtriebwerks während des Fluges beschrieben.",
+ "page-10-year-innovation-card-5-description-2": "Der Merge reduzierte den Energieverbrauch von Ethereum um 99,95 %, stärkte die Netzwerksicherheit und legte den Grundstein für zukünftige Skalierungs-Upgrades.",
+ "page-10-year-innovation-card-6-title": "Spot-ETH-ETFs",
+ "page-10-year-innovation-card-6-date": "23. Mai 2024",
+ "page-10-year-innovation-card-6-description-1": "Die Wall Street nimmt Ethereum an. Spot-ETH-ETFs wurden eingeführt und brachten institutionelles Kapital und regulatorische Legitimität auf die weltweit führende Smart-Contract-Plattform.",
+ "page-10-year-innovation-card-6-description-2": "Die Genehmigung signalisierte eine breitere Akzeptanz von tokenisierten realen Vermögenswerten, wobei große Finanzinstitute nun auf Ethereum aufbauen, um alles von Immobilien bis hin zu Staatsanleihen on-chain zu bringen.",
+ "page-10-year-adoption-card-1-title": "Jahrzehnt der Dezentralisierung",
+ "page-10-year-adoption-card-1-description": "Was als spezialisiertes Ökosystem begann, erstreckt sich heute über 80+ Länder mit 870.000 Validatoren, 13.600 physischen Nodes und Millionen von Benutzern auf allen Kontinenten.",
+ "page-10-year-adoption-card-1-link-text": "Ethereum-Statistiken prüfen",
+ "page-10-year-adoption-card-2-title": "10 Jahre, 16 Upgrades, 0 Ausfallzeit",
+ "page-10-year-adoption-card-2-description": "Ethereum hat eine perfekte Verfügbarkeit aufrechterhalten und sich dabei kontinuierlich weiterentwickelt. Die Blockchain war noch nie offline.",
+ "page-10-year-adoption-card-2-link-text": "Roadmap ansehen",
+ "page-10-year-adoption-card-3-title": "123 Mrd. $ Marktkapitalisierung bei Stablecoins",
+ "page-10-year-adoption-card-3-description": "Stand Q2 2025 sichert Ethereum L1 über 123 Mrd. $ in Stablecoins ab und erfasst damit über 50 % des globalen Stablecoin-Marktes.",
+ "page-10-year-adoption-card-3-link-text": "Mehr zu Stablecoins",
+ "page-10-year-adoption-card-4-title": "75 Mrd. $ in Ethereum DeFi gesichert",
+ "page-10-year-adoption-card-4-description": "Stand Q2 2025, sichert Ethereum über 75 Mrd. $ in DeFi in seinem gesamten Ökosystem ab.",
+ "page-10-year-adoption-card-4-link-text": "Mehr zu DeFi",
+ "page-10-year-adoption-card-5-title": "0,01 TWh pro Jahr",
+ "page-10-year-adoption-card-5-description": "Nach dem Merge sank der Energieverbrauch von Ethereum drastisch auf nur 0,01 TWh pro Jahr, von einem Höchstwert von 93,95 TWh.",
+ "page-10-year-adoption-card-5-link-text": "Mehr über den Energieverbrauch von Ethereum",
+ "page-10-year-adoption-card-6-title": "Über 250 TPS",
+ "page-10-year-adoption-card-6-description": "Der Durchsatz von Ethereum hat sich seit dem Start drastisch erhöht. Das Ethereum-Ökosystem verarbeitet mittlerweile über 250 Transaktionen pro Sekunde.",
+ "page-10-year-adoption-card-6-link-text": "Mehr über Layer 2s",
+ "page-10-year-torch-title": "Die Ethereum Torch",
+ "page-10-year-torch-description": "Ein einzigartiger NFT, der den 10. Jahrestag von Ethereum feiert. Die Torch wird zwischen Community-Mitgliedern weitergegeben und repräsentiert den Geist der Zusammenarbeit und Dezentralisierung, der Ethereum ausmacht.",
+ "page-10-year-torch-current-holder": "Aktueller Torch-Inhaber",
+ "page-10-year-torch-no-holder": "Kein aktueller Inhaber",
+ "page-10-year-torch-history-title": "Verlauf der Torch-Inhaber",
+ "page-10-year-torch-no-history": "Kein Übertragungsverlauf verfügbar",
+ "page-10-year-torch-from": "Aus",
+ "page-10-year-torch-to": "Zu",
+ "page-10-year-torch-view-tx": "Transaktion ansehen",
+ "page-10-year-livestream-title": "Am Livestream teilnehmen",
+ "page-10-year-livestream-video-title": "Livestream 10 Jahre Ethereum",
+ "page-10-year-torch-nft-intro": "Um diesen historischen Meilenstein zu würdigen, führen wir das Ethereum Torch NFT ein, ein NFT, das den Geist der Dezentralisierung und Gemeinschaft verkörpert, der das erste Jahrzehnt von Ethereum geprägt hat.",
+ "page-10-year-torch-nft-description": "Wie eine zeremonielle Flamme, die von Community zu Community wandert, wird die Ethereum Torch durch das globale Ethereum-Ökosystem reisen. Dieses besondere NFT wird von Wallet zu Wallet unter sorgfältig ausgewählten Community-Mitgliedern, Entwicklern und Buildern weitergegeben, die die Geschichte von Ethereum in den letzten 10 Jahren geprägt haben.",
+ "page-10-year-torch-one-of-kind-title": "Einzigartig:",
+ "page-10-year-torch-one-of-kind-description": "Es existiert nur ein Ethereum Torch NFT, was jeden Inhaber zu einem vorübergehenden Hüter des Erbes von Ethereum macht.",
+ "page-10-year-torch-time-limited-title": "Zeitlich begrenzte Verwahrung:",
+ "page-10-year-torch-time-limited-description": "Jeder Inhaber behält die Torch für 24 Stunden, bevor er sie an den nächsten Hüter weitergibt. Am 30. Juli wird dieses NFT zur Feier des Jubiläums verbrannt.",
+ "page-10-year-mint-card-title": "Prägen Sie den Moment",
+ "page-10-year-mint-card-description": "Feiern Sie ein Jahrzehnt der Dezentralisierung mit einem kostenlosen, zeitlich begrenzten NFT zum 10-jährigen Jubiläum. Prägen Sie Ihres, bevor die Zeit abläuft.",
+ "page-10-year-mint-card-ended-title": "Der Anspruchszeitraum ist abgelaufen",
+ "page-10-year-mint-card-ended-description": "Vielen Dank an alle, die an der Feier teilgenommen haben",
+ "page-10-year-video-aria-label": "Video zum 10-jährigen Jubiläum",
+ "page-10-year-nft-link-label": "Zehn Jahre Ethereum NFT auf OpenSea ansehen",
+ "page-10-year-terms-and-conditions": "Allgemeine Geschäftsbedingungen"
+}
diff --git a/src/intl/de/page-about.json b/src/intl/de/page-about.json
index 6f5ea411f1b..e128f9adbbe 100644
--- a/src/intl/de/page-about.json
+++ b/src/intl/de/page-about.json
@@ -1,5 +1,5 @@
{
- "page-about-h2": "Schlagen Sie eine Funktion vor",
+ "page-about-h2": "Funktion vorschlagen",
"page-about-h3": "In Arbeit",
"page-about-h3-1": "Implementierte Funktionen",
"page-about-h3-2": "Geplante Funktionen",
@@ -7,26 +7,25 @@
"page-about-li-2": "geplant",
"page-about-li-3": "implementiert",
"page-about-li-4": "implementiert",
- "page-about-link-1": "Der Quellcode dieses Repositorys ist mit MIT License lizenziert",
+ "page-about-link-1": "Der Quellcode dieses Repositorys ist unter der MIT License lizenziert.",
"page-about-link-2": "GitHub",
- "page-about-link-3": "Zeigen Sie die vollständige Liste der laufenden Aufgaben auf GitHub",
+ "page-about-link-3": "Sehen Sie sich die vollständige Liste der laufenden Aufgaben auf GitHub an.",
"page-about-link-4": "Treten Sie unserem Discord-Server bei",
- "page-about-link-5": "Erreichen Sie uns auf Twitter",
- "page-about-link-6": "Zeigen Sie die vollständige Liste der implementierten Aufgaben auf GitHub",
- "page-about-link-7": "Erstelle ein Ticket auf GitHub",
- "page-about-p-1": "Seit dem Start von ethereum.org bemühen wir uns, transparent darüber zu sein, wie wir arbeiten. Dies ist einer unserer Grundwerte, weil wir glauben, dass Transparenz entscheidend für den Erfolg von Ethereum ist.",
+ "page-about-link-5": "Kontaktieren Sie uns auf Twitter",
+ "page-about-link-6": "Sehen Sie sich die vollständige Liste der implementierten Aufgaben auf GitHub an.",
+ "page-about-link-7": "Erstellen Sie ein Issue auf GitHub",
+ "page-about-p-1": "Seit dem Start von ethereum.org bemühen wir uns, transparent darüber zu sein, wie wir arbeiten. Dies ist einer unserer Grundwerte, weil wir glauben, dass Transparenz für den Erfolg von Ethereum entscheidend ist.",
"page-about-p-2": "Wir nutzen",
- "page-about-p-3": "als unser primäres Projektmanagementwerkzeug. Wir organisieren unsere Aufgaben in 3 Kategorien:",
- "page-about-p-4": " Wir tun unser Bestes, um die Community über den Status bestimmter Aufgaben informiert zu halten.",
- "page-about-p-5": "Aufgaben, die wir implementieren.",
- "page-about-p-6": "Aufgaben, die wir in der Wartscheschlange haben, um sie als nächstes zu implementieren.",
+ "page-about-p-3": "als unser primäres Projektmanagement-Tool. Wir organisieren unsere Aufgaben in 3 Kategorien:",
+ "page-about-p-4": "Wir tun unser Bestes, um die Community über den Status einer bestimmten Aufgabe informiert zu halten.",
+ "page-about-p-5": "Aufgaben, die wir gerade implementieren.",
+ "page-about-p-6": "Aufgaben, die als Nächstes zur Implementierung anstehen.",
"page-about-p-7": "Kürzlich abgeschlossene Aufgaben.",
- "page-about-p-8": "Haben Sie eine Idee wie man ethereum.org verbessern kann? Wir würden uns freuen, mit dir zusammenzuarbeiten!",
+ "page-about-p-8": "Haben Sie eine Idee, wie man ethereum.org verbessern kann? Wir würden uns freuen, mit Ihnen zusammenzuarbeiten!",
"page-what-is-ethereum-energy-consumption-chart-legend": "Jährlicher Energieverbrauch in TWh/Jahr",
- "energy-consumption-chart-youtube-label": "YouTube",
- "energy-consumption-chart-gold-mining-galaxy-label": "Goldförderung (Galaxy Digital)",
"energy-consumption-chart-global-data-centers-label": "Globale Rechenzentren",
- "energy-consumption-chart-gold-mining-cbeci-label": "Goldabbau (CBECI)",
+ "energy-consumption-chart-airbnb-label": "AirBnB",
+ "energy-consumption-gold-mining-cbeci-label": "Goldabbau",
"energy-consumption-chart-btc-pow-label": "BTC PoW",
"energy-consumption-chart-netflix-label": "Netflix",
"energy-consumption-chart-eth-pow-label": "ETH PoW",
diff --git a/src/intl/de/page-apps.json b/src/intl/de/page-apps.json
index 99d5fe9724d..c179339a78e 100644
--- a/src/intl/de/page-apps.json
+++ b/src/intl/de/page-apps.json
@@ -1,292 +1,72 @@
{
- "page-apps-1inch-logo-alt": "1inch-Logo",
- "page-apps-aave-logo-alt": "Aave-Logo",
- "page-apps-add-button": "DApp vorschlagen",
- "page-apps-add-title": "DApp hinzufügen",
- "page-apps-ankr-logo-alt": "Ankr Logo",
- "page-apps-api3-logo-alt": "API3 Logo",
- "page-apps-arweave-logo-alt": "ARweave Logo",
- "page-apps-audius-logo-alt": "Audius-Logo",
- "page-apps-augur-logo-alt": "Augur-Logo",
- "page-apps-axie-infinity-logo-alt": "Axie-Infinity-Logo",
- "page-apps-balancer-logo-alt": "Balancer-Logo",
- "page-apps-brave-logo-alt": "Brave-Logo",
- "page-apps-beginner-friendly-description": "Einige dApps, die sich gut für Anfänger eignen. Weiter unten können Sie weitere Dapps entdecken.",
- "page-apps-beginner-friendly-header": "Anfängerfreundlich",
- "page-apps-category-arts": "Kunst und Mode",
- "page-apps-category-browsers": "Browser",
- "page-apps-category-code-marketplaces": "Code-Marktplätze",
- "page-apps-category-collectibles": "Digitale Sammlerstücke",
- "page-apps-category-competitive": "Web3-Spiele",
- "page-apps-category-computing": "Entwicklertools",
- "page-apps-category-dex": "Börsen",
- "page-apps-category-investments": "Investmentfonds",
- "page-apps-category-lending": "Kreditvergabe und Kreditaufnahme",
- "page-apps-category-lottery": "Crowdfunding",
- "page-apps-category-marketplaces": "Marktplätze",
- "page-apps-category-music": "Musik",
- "page-apps-category-payments": "Zahlungen",
- "page-apps-category-insurance": "Versicherungen",
- "page-apps-category-portfolios": "Portfoliomanagement",
- "page-apps-category-trading": "Prognosemärkte",
- "page-apps-category-utilities": "Nützliches",
- "page-apps-category-worlds": "Virtuelle Welten",
- "page-apps-category-demand-aggregator": "Nachfrage-Aggregatoren",
- "page-apps-category-derivatives": "Derivate",
- "page-apps-category-liquid-staking": "Liquides Staking",
- "page-apps-category-bridges": "Bridges",
- "page-apps-category-experiences": "Geteilte Erfahrungen",
- "page-apps-category-guilds": "Ertragsgilden",
- "page-apps-category-avatar": "Avatare",
- "page-apps-choose-category": "Kategorie wählen",
- "page-apps-category-social": "Soziale Medien",
- "page-apps-category-content": "Inhalt",
- "page-apps-category-community": "Community",
- "page-apps-category-messaging": "Messaging",
- "page-apps-category-identity": "Identität",
- "page-apps-collectibles-benefits-1-description": "Wenn Kunst auf Ethereum tokenisiert wird, kann Eigentum für alle sichtbar nachweisbar sein. Sie können die Reise des Kunstwerks von der Erstellung bis zum aktuellen Inhaber verfolgen. Dies verhindert Fälschungen.",
- "page-apps-collectibles-benefits-1-title": "Eigentum ist nachweisbar",
- "page-apps-collectibles-benefits-2-description": "Das Bezahlen für das Streamen von Musik oder den Kauf von Kunstwerken ist für die Künstler viel fairer. Mit Ethereum gibt es weniger Bedarf an Zwischenhändlern. Und wenn Zwischenhändler benötigt werden, sind ihre Kosten nicht so hoch, weil die Plattformen nicht für die Infrastruktur des Netzwerks bezahlen müssen.",
- "page-apps-collectibles-benefits-2-title": "Fairer für die Ersteller",
- "page-apps-collectibles-benefits-3-description": "Tokenisierte Sammlerstücke sind an Ihre Ethereum-Adresse gebunden, nicht an die Plattform. So können Sie Dinge wie In-Game-Gegenstände auf jedem Ethereum-Markt verkaufen, nicht nur im Spiel selbst.",
- "page-apps-collectibles-benefits-3-title": "Sammlerstücke gehen mit Ihnen",
- "page-apps-collectibles-benefits-4-description": "Die Werkzeuge und Produkte, um Ihre Kunst zu tokenisieren und zu verkaufen, existieren bereits. Ihre Token können auf allen einlösbaren Ethereum-Plattformen verkauft werden.",
- "page-apps-collectibles-benefits-4-title": "Infrastruktur bereits vorhanden",
- "page-apps-collectibles-benefits-description": "Dies sind Applikationen, die sich auf digitales Eigentum fokussieren, Verdienstmöglichkeiten für Ersteller verbessern und neue Wege erfinden, um in Ihre bevorzugten Künstler und deren Arbeit zu investieren.",
- "page-apps-collectibles-benefits-title": "dezentrale Sammelobjekte und Streaming",
- "page-apps-collectibles-button": "Kunst und Sammlerstücke",
- "page-apps-collectibles-description": "Dies sind Applikationen, die sich auf digitales Eigentum fokussieren, Verdienstmöglichkeiten für Ersteller verbessern und neue Wege erfinden, um in Ihre bevorzugten Künstler und deren Arbeit zu investieren.",
- "page-apps-collectibles-title": "Dezentralisierte Kunst und Sammlerstücke",
- "page-apps-compound-logo-alt": "Compound-Logo",
- "page-apps-convex-logo-alt": "Convex-Logo",
- "page-apps-cryptopunks-logo-alt": "KryptoPunks-Logo",
- "page-apps-cryptovoxels-logo-alt": "Kryptovoxels-Logo",
- "page-apps-cyberconnect-logo-alt": "CyberConnect-Logo",
- "page-apps-dapp-description-1inch": "Hilft dabei, hohe Preisabweichungen zu vermeiden, indem die besten Preise zusammengefasst werden.",
- "page-apps-dapp-description-aave": "Verleihen Sie Ihre Token, um Zinsen zu erhalten, und heben Sie sie jederzeit wieder ab.",
- "page-apps-dapp-description-ankr": "Satz verschiedener Web3-Infrastrukturprodukte zum Aufbauen, Verdienen, Spielen und mehr – alles auf der Blockchain.",
- "page-apps-dapp-description-api3": "Erstanbieter-Preisreferenzdatenfeeds, die es dApps in 10 Netzwerken (und es werden immer mehr) ermöglichen, sich mit Echtzeit-Asset-Preisdaten zu verbinden, einschließlich Krypto- und Devisenpreisen.",
- "page-apps-dapp-description-arweave": "Daten dauerhaft und nachhaltig speichern, mit einer einmaligen Vorabgebühr.",
- "page-apps-dapp-description-async-art": "Erschaffen, sammeln und handeln Sie mit #ProgrammableArt – digitale Gemälde, die in „Layers\" aufgespaltet sind und mit denen Sie das Gesamtbild gestalten können. Jeder Master und jede Layer ist ein ERC721-Token.",
- "page-apps-dapp-description-audius": "Dezentralisierte Streaming-Plattform. Hört zu = Geld für Ersteller, nicht Marken.",
- "page-apps-dapp-description-augur": "Wetten Sie auf die Ergebnisse in Sport, Wirtschaft und weiteren weltweiten Events.",
- "page-apps-dapp-description-axie-infinity": "Handeln Sie mit und kämpfen Sie gegen Kreaturen namens Axies. Und verdienen Sie dabei etwas, während Sie spielen – verfügbar auf Ihrem Mobiltelefon",
- "page-apps-dapp-description-balancer": "Balancer ist ein automatisierter Portfoliomanager und eine Handelsplattform.",
- "page-apps-dapp-description-brave": "Verdienen Sie Token während des Browsens und unterstützen Sie Ihre Lieblingskünstler mit ihnen.",
+ "page-apps-all-apps": "Alle Apps",
"page-apps-dapp-description-cent": "Ein soziales Netzwerk, in dem Sie durch das Posten von NFT Geld verdienen.",
- "page-apps-dapp-description-compound": "Verleihen Sie Ihre Token, um Zinsen zu erhalten, und ziehen Sie sich jederzeit wieder davon zurück.",
- "page-apps-dapp-description-convex": "Convex ermöglicht es Curve-Liquiditätsanbietern, Handelsgebühren zu verdienen und gesteigertes CRV einzufordern, ohne CRV zu sperren.",
- "page-apps-dapp-description-cryptopunks": "Kaufen und bieten Sie auf Punks und bieten Sie diese wiederum zum Verkauf an – eine der ersten Token-Sammlungen auf Ethereum.",
- "page-apps-dapp-description-cryptovoxels": "Erschaffen Sie Kunstgalerien, bauen Sie Geschäfte und kaufen Sie Land – eine virtuelle Ethereum-Welt.",
- "page-apps-dapp-description-cyberconnect": "Dezentralisiertes Social-Graph-Protokoll, das dApps dabei hilft, Netzwerkeffekte zu initiieren und personalisierte soziale Erlebnisse zu schaffen",
- "page-apps-dapp-description-dark-forest": "Erobern Sie Welten in einem unendlichen, prozedural generierten, kryptographisch spezifizierten Universum.",
"page-apps-dapp-description-decentraland": "Sammeln und handeln Sie virtuelles Land in einer virtuellen Welt, die Sie entdecken können.",
"page-apps-dapp-description-ens": "Benutzerfreundliche Namen für Ethereum-Adressen und dezentrale Seiten.",
- "page-apps-dapp-description-foundation": "Investieren Sie in eine einzigartige Ausgabe von digitaler Kunst und handeln Sie Kunstwerke mit anderen Käufern.",
"page-apps-dapp-description-gitcoin": "Verdienen Sie Kryptowährung, indem Sie an Open-Source-Software arbeiten.",
- "page-apps-dapp-description-gitcoin-grants": "Crowdfunding für Ethereum-Gemeinschaftsprojekte mit umfangreicheren Beiträgen",
- "page-apps-dapp-description-gm": "All-in-one-Plattform für Chat, Foren und Sprache, die tatsächlich Einnahmen mit ihren Erstellern teilt",
"page-apps-dapp-description-gods-unchained": "Strategisches Handeln mit Kartenspielen. Verdienen Sie sich durch das Spielen Spielkarten, die Sie im realen Leben verkaufen können.",
- "page-apps-dapp-description-golem": "Erhalten Sie Zugriff auf Rechenleistung oder mieten Sie Ihre eigenen Ressourcen an.",
- "page-apps-dapp-description-graph": "Ein Indexierungsprotokoll zum Abfragen von Netzwerken wie Ethereum und IPFS.",
- "page-apps-dapp-description-ipfs": "Ein Peer-to-Peer-Hypermedia-Protokoll, das darauf abzielt, das Wissen der Menschheit zu bewahren und zu vermehren, indem es das Web aufrüstbar, widerstandsfähig und offener gestaltet.",
- "page-apps-dapp-description-radicle": "Sichere Peer-to-Peer-Code-Zusammenarbeit ohne Vermittler.",
- "page-apps-dapp-description-kyberswap": "Tauschen und verdienen Sie zu den besten Konditionen.",
- "page-apps-dapp-description-lido": "Vereinfachtes und sicheres Staking für digitale Assets.",
- "page-apps-dapp-description-loopring": "Peer-to-Peer-Tradingplattform – für Geschwindigkeit entwickelt.",
- "page-apps-dapp-description-marble-cards": "Erstellen und tauschen Sie einzigartige, digitale Spielkarten basierend auf URL.",
- "page-apps-dapp-description-matcha": "Durchsucht mehrere Börsen, um für Sie den besten Preis zu finden.",
- "page-apps-dapp-description-meeds": "Web3-Community-Hubs für das Zeitalter der dezentralisierten Arbeit. Belohnen Sie wichtige Beiträge auf faire und transparente Weise.",
- "page-apps-dapp-description-mirror": "Mirrors robuste Veröffentlichungsplattform ist auf Web3 für Web3 gebaut und verschiebt die Grenzen des Online-Schreibens",
- "page-apps-dapp-description-multichain": "Der ultimative Router für Web3. Es handelt sich um eine Infrastruktur, die für beliebige Cross-Chain-Interaktionen entwickelt wurde.",
- "page-apps-dapp-description-nifty-gateway": "Kaufen Sie Werke on-chain von Top-Künstlern, Athleten, Marken und Erstellern.",
- "page-apps-dapp-description-summerfi": "Handeln, leihen und sparen mit Dai, einer Ethereum-Stablecoin.",
- "page-apps-dapp-description-opensea": "Kaufen, verkaufen, entdecken und handeln Sie Waren mit limitierter Auflage.",
- "page-apps-dapp-description-opera": "Senden Sie Kryptowährung von Ihrem Browser an Händler, andere Nutzer und Apps.",
- "page-apps-dapp-description-osuvox": "3D-Avatare, die auf der Blockchain leben",
- "page-apps-dapp-description-poap": "Sammeln Sie NFTs um zu beweisen, dass Sie bei verschiedenen virtuellen oder persönlichen Veranstaltungen waren. Nutzen Sie sie, um an Tombolas teilzunehmen, zu stimmen, zu kollaborieren oder einfach nur anzugeben.",
- "page-apps-dapp-description-polymarket": "Wetten Sie auf Ergebnisse. Handeln Sie auf den Informationsmärkten.",
- "page-apps-dapp-description-pooltogether": "Eine Lotterie, bei der Sie nicht verlieren können. Preise jede Woche.",
- "page-apps-dapp-description-index-coop": "Ein Krypto-Indexfonds, der Ihr Portfolio den Top-DeFi-Token aussetzt.",
- "page-apps-dapp-description-nexus-mutual": "Deckung ohne Versicherungsgesellschaft. Schützen Sie sich gegen Smart-Contract-Bugs und -Hacks.",
- "page-apps-dapp-description-etherisc": "Eine dezentrale Versicherungsvorlage, mit der jeder seinen eigenen Versicherungsschutz erstellen kann.",
- "page-apps-dapp-description-zapper": "Verfolgen Sie Ihr Portfolio und verwenden Sie eine Reihe von DeFi-Produkten von einer Website aus.",
- "page-apps-dapp-description-zerion": "Verwalten Sie Ihr Portfolio und bewerten Sie einfach jede einzelne DeFi-Anlage am Markt.",
- "page-apps-dapp-description-rotki": "Open-Source-Portfolio-Tracking, Analytik, Buchhaltung und Steuerberichterstattung unter Wahrung Ihrer Privatsphäre.",
- "page-apps-dapp-description-krystal": "Eine One-Stop-Plattform für den Zugriff auf alle Ihre Lieblings-DeFi-Dienste.",
- "page-apps-dapp-description-rarible": "Erstellen, verkaufen und kaufen Sie tokenisierte Sammlerstücke.",
- "page-apps-dapp-description-request-finance": "Eine Reihe von finanziellen Werkzeugen für Rechnungen, Gehaltsabrechnungen und Ausgaben auf Basis von Kryptowährungen.",
- "page-apps-dapp-description-rubic": "Cross-Chain-Technologie-Aggregator für Nutzer und dApps.",
- "page-apps-dapp-description-sablier": "Übertragen Sie Geld in Echtzeit.",
- "page-apps-dapp-description-spatial": "Erstellen Sie Ihren persönlichen Avatar und eigene 3D-Welten",
- "page-apps-dapp-description-spruce": "Open-Source-Stack, um die Kontrolle über Identität und Daten bei den Nutzern zu belassen.",
- "page-apps-dapp-description-status": "Entwickelt, um den freien Informationsfluss zu ermöglichen, das Recht auf private, sichere Unterhaltungen zu schützen und die Souveränität von Einzelpersonen zu fördern.",
- "page-apps-dapp-description-superrare": "Kaufen Sie digitale Kunst direkt vom Künstler oder auf dem Zweitmarkt.",
- "page-apps-dapp-description-synthetix": "Synthetix ist ein Protokoll für die Emission und den Handel mit synthetischen Vermögenswerten",
- "page-apps-dapp-description-token-sets": "Strategien für Krypto-Investitionen, die sich automatisch ausgleichen.",
- "page-apps-dapp-description-uniswap": "Tauschen Sie Token einfach oder stellen Sie Token für prozentuale Vergütung zur Verfügung.",
- "page-apps-dapp-description-xmtp": "Senden Sie Nachrichten zwischen Blockchain-Konten, einschließlich Direktnachrichten, Alarmen, Ankündigungen und mehr.",
- "page-apps-dapp-description-yearn": "Yearn Finance ist ein Rendite-Aggregator. Einzelpersonen, DAOs und andere Protokolle haben damit eine Möglichkeit, digitale Vermögenswerte zu hinterlegen und Renditen zu erwirtschaften.",
- "page-apps-docklink-dapps": "Einführung in dApps",
- "page-apps-docklink-smart-contracts": "Smart Contracts",
- "page-apps-dark-forest-logo-alt": "Dark-Forest-Logo",
- "page-apps-decentraland-logo-alt": "Decentraland-Logo",
- "page-apps-index-coop-logo-alt": "Index-Coop-Logo",
- "page-apps-nexus-mutual-logo-alt": "Nexus-Mutual-Logo",
- "page-apps-etherisc-logo-alt": "Etherisc-Logo",
- "page-apps-zapper-logo-alt": "Zapper-Logo",
- "page-apps-zerion-logo-alt": "Zerion-Logo",
- "page-apps-rotki-logo-alt": "Rotki-Logo",
- "page-apps-krystal-logo-alt": "Krystal Logo",
- "page-apps-synthetix-logo-alt": "Synthetix-Logo",
- "page-apps-desc": "Finden Sie eine Ethereum-Anwendung zum Ausprobieren.",
- "page-apps-doge-img-alt": "Illustration eines Doge, der einen Computer benutzt",
- "page-apps-editors-choice-dark-forest": "Spielen Sie gegen andere, um Planeten zu erobern, und testen Sie die neueste Skalierungs- und Privatsphäre-Technologie von Ethereum. Vielleicht etwas für diejenigen, die bereits mit Ethereum vertraut sind.",
- "page-apps-editors-choice-foundation": "Investieren Sie in Kultur. Kaufen, handeln und verkaufen Sie einzigartige digitale Kunst und Mode von einigen unglaublichen Künstlern, Musikern und Marken.",
- "page-apps-editors-choice-pooltogether": "Kaufen Sie ein Ticket für eine Lotterie ohne Verlust. Jede Woche werden die Zinsen, die sich aus dem gesamten Ticket-Pool ergeben, an einen glücklichen Gewinner ausgeschüttet. Sie bekommen Ihr Geld zurück, wann immer Sie es möchten.",
- "page-apps-editors-choice-uniswap": "Tauschen Sie Ihre Token ganz einfach. Ein Liebling der Community, der es Ihnen erlaubt, Token mit allen möglichen Menschen im Netzwerk zu handeln.",
- "page-apps-ens-logo-alt": "Ethereum-Name-Service-Logo",
- "page-apps-explore-dapps-description": "Viele dApps sind immer noch in der Experimentierphase und loten die Möglichkeiten des dezentralen Netzwerks aus. Aber es gab einige erfolgreiche Frühstarter in den Kategorien Technologie, Finanzen, Spiele und Sammlerstücke.",
- "page-apps-explore-dapps-title": "Entdecken Sie dApps",
- "page-apps-features-1-description": "Einmal in Ethereum eingespielt, kann ein dApp-Code nicht mehr zurückgenommen werden. Jeder kann die Funktionen der dApp nutzen. Sogar wenn das Team hinter der dApp aufgelöst wurde, können Sie sie immer noch nutzen. Einmal auf Ethereum, bleibt sie auch dort.",
- "page-apps-features-1-title": "Keine Besitzer",
- "page-apps-features-2-description": "Sie können nicht von einer dApp oder vom Senden von Transaktionen ausgeschlossen werden. Wenn z. B. Twitter auf Ethereum wäre, könnte niemand Ihr Konto blockieren oder Sie vom Tweeten abhalten.",
- "page-apps-features-2-title": "Frei von Zensur",
- "page-apps-features-3-description": "Da Ethereum über ETH verfügt, sind Zahlungen ein natürlicher Teil von Ethereum. Entwickler brauchen keine Zeit mit der Integration von Zahlungs-Drittanbietern zu verbringen.",
- "page-apps-features-3-title": "Integrierte Zahlungen",
- "page-apps-features-4-description": "dApp-Code ist frei zugänglich und standardmäßig kompatibel. Teams bauen regelmäßig unter Verwendung der Arbeit anderer Teams. Wenn man möchte, dass Benutzer Token in Ihrer dApp austauschen, können Sie einfach den Code einer anderen dApp einfügen.",
- "page-apps-features-4-title": "Plug-and-Play",
- "page-apps-features-5-description": "Bei den meisten dApps braucht man nicht seine echte Identität anzugeben. Ihr Ethereum-Account ist Ihr Zugang und alles, was Sie brauchen, ist eine Wallet.",
- "page-apps-features-5-title": "Ein anonymer Login",
- "page-apps-features-6-description": "Kryptographie stellt sicher, dass Angreifer keine Transaktionen und anderen dApp-Interaktionen in Ihrem Namen ausführen können. Sie autorisieren dApp-Aktionen mit Ihrem Ethereum-Konto, in der Regel über Ihre Wallet. So bleiben Ihre Zugangsdaten sicher.",
- "page-apps-features-6-title": "Durch Kryptographie gesichert",
- "page-apps-features-7-description": "Sobald die dApp auf Ethereum läuft, wird sie nur stoppen, wenn Ethereum selbst nicht mehr funktioniert. Netzwerke von Ethereums Größe sind bekanntermaßen sehr schwer anzugreifen.",
- "page-apps-features-7-title": "Keine Downtime",
- "page-apps-finance-benefits-1-description": "Finanzdienstleistungen, die auf Ethereum laufen, haben keine Anmeldebedingungen. Wenn Sie ein Guthaben und eine Internetverbindung haben, können Sie loslegen.",
- "page-apps-finance-benefits-1-title": "Offener Zugang",
- "page-apps-finance-benefits-2-description": "Es gibt eine ganze Welt von Token, mit denen man über diese Finanzprodukte interagieren kann. Leute bauen die ganze Zeit neue Token auf Basis von Ethereum auf.",
- "page-apps-finance-benefits-2-title": "Eine neue Token-Ökonomie",
- "page-apps-finance-benefits-3-description": "Stablecoins wurden in Teamarbeit entwickelt – dabei handelt es sich um eine weniger volatile Kryptowährung, mit der Sie ohne Risiko und Unsicherheiten in die Krypto-Welt eintauchen und damit experimentieren können.",
- "page-apps-finance-benefits-3-title": "Stablecoins",
- "page-apps-finance-benefits-4-description": "Finanzprodukte im Ethereum-Ökosystem sind alle modular aufgebaut und miteinander kompatibel. Neue Konfigurationen dieser Module kommen laufend auf den Markt und erhöhen die Möglichkeiten, was Sie mit Krypto machen können.",
- "page-apps-finance-benefits-4-title": "Vernetzte Finanzdienstleistungen",
- "page-apps-finance-benefits-description": "Was ist besonders an Ethereum, das dezentralisierte Finanzanwendungen aufblühen lässt?",
- "page-apps-finance-benefits-title": "Dezentralisierte Finanzen",
- "page-apps-finance-button": "Finanzen",
- "page-apps-finance-description": "Dies sind Anwendungen, die sich auf den Aufbau von Finanzdienstleistungen mit Kryptowährungen konzentrieren. Sie bieten z. B. Kreditvergabe, Kreditaufnahme, Zinseinnahmen und private Zahlungen – ohne persönliche Daten.",
- "page-apps-finance-title": "Dezentralisierte Finanzen",
- "page-apps-foundation-logo-alt": "Foundation-Logo",
- "page-apps-gaming-benefits-1-description": "Seien es virtuelles Land oder Sammelkarten, Ihre Gegenstände sind auf Sammlermärkten handelbar. All diese Spielgegenstände haben einen realen Wert.",
- "page-apps-gaming-benefits-1-title": "Spielgegenstände dienen als Token",
- "page-apps-gaming-benefits-2-description": "Ihre Gegenstände und in einigen Fällen Ihr Fortschritt gehören Ihnen, nicht den Spieleentwicklern. Sie werden also nichts verlieren, wenn die Firma hinter dem Spiel angegriffen wird, eine Serverstörung erleidet oder sich auflöst.",
- "page-apps-gaming-benefits-2-title": "Ihre Spielstände sind hier sicher",
- "page-apps-gaming-benefits-3-description": "Auf die gleiche Weise, wie Ethereum-Zahlungen für jedermann verifizierbar sind, können Spiele diese Qualität nutzen, um Fairness zu gewährleisten. Theoretisch ist alles verifizierbar, von der Anzahl der kritischen Treffer bis zur Größe der Kriegskasse eines Gegners.",
- "page-apps-gaming-benefits-3-title": "Nachweisbare Fairness",
- "page-apps-gaming-benefits-description": "Was ist besonders an Ethereum, das dezentralisiertes Gaming fördert?",
- "page-apps-gaming-benefits-title": "Dezentralisiertes Gaming",
- "page-apps-gaming-button": "Gaming",
- "page-apps-gaming-description": "Dies sind Anwendungen, die sich auf die Schaffung virtueller Welten konzentrieren und andere Spieler mit Sammlerstücken herausfordern, die einen realen Wert haben.",
- "page-apps-gaming-title": "Dezentralisiertes Gaming",
- "page-apps-get-some-eth-description": "dApp-Aktionen kosten Überweisungsgebühren",
- "page-apps-get-started-subtitle": "Um eine DApp auszuprobieren, benötigen Sie eine Wallet und einige ETH. Mit einer Wallet können Sie eine Verbindung herstellen oder sich anmelden. Und Sie benötigen ETH, um alle anfallenden Transaktionsgebühren zu bezahlen.",
- "page-apps-get-started-title": "Erste Schritte",
- "page-apps-gitcoin-grants-logo-alt": "Gitcoin-Grants-Logo",
- "page-apps-gitcoin-logo-alt": "Gitcoin-Logo",
- "page-apps-gm-logo-alt": "gm.xyz-Logo",
- "page-apps-gods-unchained-logo-alt": "Gods-Unchained-Logo",
- "page-apps-golem-logo-alt": "Golem-Logo",
- "page-apps-graph-logo-alt": "Graph-Logo",
- "page-apps-radicle-logo-alt": "Radicle-Logo",
- "page-apps-hero-header": "Ethereum-basierte Werkzeuge und Dienste",
- "page-apps-hero-subtitle": "dApps sind eine wachsende Bewegung von Anwendungen, die Ethereum verwenden, um Geschäftsmodelle aufzumischen oder neue zu erfinden.",
- "page-apps-how-dapps-work-p1": "Bei DApps läuft der Backend-Code (Smart Contracts) in einem dezentralen Netzwerk und nicht auf einem zentralen Server. Sie nutzen die Blockchain von Ethereum zur Datenspeicherung und Smart Contracts für ihre App-Logik.",
- "page-apps-how-dapps-work-p2": "Ein Smart Contract ist wie eine Reihe von Regeln, die für alle sichtbar exakt nach diesen Regeln auf der Blockchain funktionieren. Stellen Sie sich einen Verkaufsautomaten vor: Wenn Sie genügend Geld haben und die richtige Auswahl treffen, bekommen Sie den gewünschten Artikel. Ebenso wie Automaten können Smart Contracts, genau wie Ihr Ethereum-Account, Geld halten. Dies ermöglicht Code, Vereinbarungen und Transaktionen zu vermitteln.",
- "page-apps-how-dapps-work-p3": "Sobald dApps im Ethereum-Netzwerk installiert sind, können Sie diese nicht mehr ändern. dApps können dezentralisiert werden, weil sie durch die in den Smart Contract geschriebene Logik kontrolliert werden, nicht durch eine Person oder ein Unternehmen.",
- "page-apps-how-dapps-work-title": "So funktionieren dApps",
- "page-apps-ipfs-logo-alt": "IPFS-Logo",
- "page-apps-kyberswap-logo-alt": "KyberSwap-Logo",
- "page-apps-learn-callout-button": "Fangen Sie an zu bauen",
- "page-apps-learn-callout-description": "Unser Community-Entwicklerportal verfügt über Dokumente, Tools und Frameworks, um Ihnen bei der Entwicklung einer dapp zu helfen.",
- "page-apps-learn-callout-image-alt": "Illustration einer Hand, die ein Ethereum-Logo aus Lego-Steinen aufbaut.",
- "page-apps-learn-callout-title": "Lernen Sie, eine dApp zu entwickeln",
- "page-apps-lido-logo-alt": "Lido-Logo",
- "page-apps-loopring-logo-alt": "Loopring-Logo",
- "page-apps-magic-behind-dapps-description": "dApps mögen sich wie normale Apps anfühlen, aber hinter den Kulissen haben sie einige besondere Eigenschaften, weil ihnen alle Superkräfte von Ethereum zur Verfügung stehen. Hier sehen Sie, was dApps von Apps unterscheidet.",
- "page-apps-magic-behind-dapps-link": "Was macht Ethereum großartig?",
- "page-apps-magic-behind-dapps-title": "Die Magie hinter dApps",
- "page-apps-magic-title-1": "Die Magie",
- "page-apps-magic-title-2": "hinter",
- "page-apps-magician-img-alt": "Illustration von Zauberern",
- "page-apps-marble-cards-logo-alt": "marble.cards-Logo",
- "page-apps-async-logo-alt": "Async-Logo",
- "page-apps-matcha-logo-alt": "Matcha-Logo",
- "page-apps-meeds-logo-alt": "Meeds-Logo",
- "page-apps-metaverse-benefits-title": "Metaversum",
- "page-apps-metaverse-benefits-description": "Was hat Ethereum an sich, das das Metaversum florieren lässt?",
- "page-apps-metaverse-benefits-1-title": "NFTs",
- "page-apps-metaverse-benefits-1-description": "Einzigartige In-Game-Objekte, die Nutzern gehören und über virtuelle Welten und Marktplätze hinweg verwendet werden können, die dieselben Standards unterstützen.",
- "page-apps-metaverse-benefits-2-title": "Benutzereigene Gemeinschaften",
- "page-apps-metaverse-benefits-2-description": "Identitäten gehören den Nutzern und bieten endlose Möglichkeiten, soziale Netzwerke über mehrere virtuelle Welten hinweg zu erkunden und zu erstellen.",
- "page-apps-metaverse-button": "Metaversum",
- "page-apps-metaverse-title": "Metaversum",
- "page-apps-metaverse-description": "Das sind Anwendungen, die es Benutzern ermöglichen, sich ungebunden in virtuellen Welten zu beteiligen. Benutzer können persönliche Netzwerke bilden und digitale Vermögenswerte besitzen",
- "page-apps-mirror-logo-alt": "Mirror-Logo",
- "page-apps-mobile-options-header": "Andere Kategorie durchsuchen",
- "page-apps-multichain-logo-alt": "Multichain-Logo",
- "page-apps-nifty-gateway-logo-alt": "Nifty-Gateway-Logo",
- "page-apps-summerfi-logo-alt": "Summer.fi-Logo",
- "page-apps-opensea-logo-alt": "OpenSea-Logo",
- "page-apps-opera-logo-alt": "Opera-Logo",
- "page-apps-osuvox-logo-alt": "OSUVOX-Logo",
- "page-apps-polymarket-logo-alt": "Polymarket-Logo",
- "page-apps-poap-logo-alt": "Proof- of-Attendance-Protokoll-Logo",
- "page-apps-pooltogether-logo-alt": "PoolTogether-Logo",
- "page-apps-rarible-logo-alt": "Rarible-Logo",
- "page-apps-ready-button": "Los",
- "page-apps-ready-description": "Wählen Sie eine dApp zum Probieren aus",
- "page-apps-ready-title": "Bereit?",
- "page-apps-request-finance-logo-alt": "Finanz-Logo beantragen",
- "page-apps-rubic-logo-alt": "Rubic-Logo",
- "page-apps-sablier-logo-alt": "Sablier-Logo",
- "page-apps-set-up-a-wallet-button": "Finden Sie eine Wallet",
- "page-apps-set-up-a-wallet-description": "Eine Wallet ist Ihr Login für eine dApp",
- "page-apps-set-up-a-wallet-title": "Richten Sie eine Wallet ein",
- "page-apps-social-button": "Sozial",
- "page-apps-social-description": "Das sind Anwendungen, die sich darauf konzentrieren, dezentrale soziale Netzwerke unter Verwendung von dezentralen Identitätstechnologien zu erstellen, bei denen digitale Identitäten und soziale Beziehungen den Benutzern gehören.",
- "page-apps-social-title": "Sozial",
- "page-apps-spatial-logo-alt": "Spatial-Logo",
- "page-apps-spruce-logo-alt": "Spruce-Logo",
- "page-apps-status-logo-alt": "Status-Logo",
- "page-apps-superrare-logo-alt": "SuperRare-Logo",
- "page-apps-technology-button": "Technologie",
- "page-apps-technology-description": "Diese Anwendungen konzentrieren sich auf die Dezentralisierung von Entwicklerwerkzeugen, die Einbindung kryptoökonomischer Systeme in bestehende Technologien und die Schaffung von Marktplätzen für Open-Source-Entwicklungsarbeit.",
- "page-apps-technology-title": "Dezentralisierte Technologie",
- "page-apps-token-sets-logo-alt": "Token-Sets-Logo",
- "page-apps-uniswap-logo-alt": "Uniswap-Logo",
- "page-apps-wallet-callout-button": "Finde eine Wallet",
- "page-apps-wallet-callout-description": "Wallets sind auch dapps. Finde eine basierend auf den Merkmalen, die Ihnen passen.",
- "page-apps-wallet-callout-image-alt": "Illustration eines Roboters.",
- "page-apps-wallet-callout-title": "Wallets anschauen",
- "page-apps-warning-header": "Informieren Sie sich immer ausgiebig selbst",
- "page-apps-warning-message": "Ethereum ist eine neue Technologie und die meisten Anwendungen sind neu. Bevor Sie große Mengen an Geld einsetzen, stellen Sie sicher, dass Sie die Risiken verstehen.",
- "page-apps-what-are-dapps": "Was sind dApps?",
- "page-apps-more-on-defi-button": "Mehr zu dezentralisierten Finanzen",
- "page-apps-more-on-nft-button": "Mehr zu tokenisierten Sammlerstücken",
- "page-apps-more-on-nft-gaming-button": "Mehr zu tokenisierten In-Game-Items",
- "page-apps-dapp-description-pwn": "Einfache Kredite, die durch jedes Token oder NFT auf Ethereum abgesichert sind.",
- "page-apps-pwn-image-alt": "PWN-Logo",
- "page-apps-xmtp-logo-alt": "XMTP-Logo",
- "opage-apps-yearn-logo-alt": "Yearn-Logo",
- "page-apps-yearn-image-alt": "Yearn-Logo",
- "page-apps-convex-image-alt": "Convex-Logo",
+ "page-apps-dapp-description-augur": "Wetten Sie auf Ergebnisse. Handeln Sie auf den Informationsmärkten.",
+ "page-apps-ready-button": "Go",
"foundation": "Foundation",
"page-wallets-get-some": "Erwerben Sie ETH",
- "page-apps-dapp-description-curve": "Curve ist ein Dex, der sich auf Stablecoins konzentriert",
- "page-apps-curve-image-alt": "Curve-Logo",
- "page-apps-dapp-description-dodo": "DODO ist ein On-Chain-Liquiditätsanbieter, der den Proactive Market Maker(PMM)-Algorithmus nutzt",
- "page-apps-dodo-image-alt": "DODO-Logo",
- "page-apps-dapp-description-artblocks": "Art Blocks zielt darauf ab, fesselnde Werke zeitgenössischer generativer Kunst zum Leben zu erwecken",
- "page-apps-artblocks-image-alt": "Art Blocks-Logo",
- "page-apps-explore-title": "Möchten Sie weitere Apps durchstöbern?",
- "page-apps-explore": "Sehen Sie sich Hunderte DApps an"
-}
+ "page-apps-title": "Apps",
+ "page-apps-subtitle": "Entdecke eine Liste kuratierter Anwendungen, die auf Ethereum und Layer-2-Netzwerken laufen",
+ "page-apps-learn-button": "Erfahre mehr über Apps",
+ "page-apps-highlights-title": "Highlights",
+ "page-apps-discover-title": "Entdecken",
+ "page-apps-applications-title": "Anwendungen",
+ "page-apps-categories-title": "Anwendungskategorien",
+ "page-apps-community-picks-title": "Auswahl der Community",
+ "page-apps-meta-title": "Top Crypto Apps in Ethereum",
+ "page-apps-meta-description": "Entdecke Krypto-Apps auf Ethereum: Erkunde DeFi, NFTs, Social, Gaming, Bridges, Datenschutz, Produktivität & DAO-Dapps. Finde vertrauenswürdige Onchain-Apps zum Handeln, Verdienen und Interagieren.",
+ "page-apps-category-defi-name": "DeFi",
+ "page-apps-category-defi-description": "DeFi ist eine Kategorie von dezentralen Anwendungen, die es Nutzern ermöglicht, Krypto-Vermögenswerte zu verleihen, auszuleihen, zu handeln, und Zinsen darauf zu verdienen.",
+ "page-apps-category-defi-meta-title": "Liste von Ethereum DeFi-Apps — Verleihen, Ausleihen & Rendite",
+ "page-apps-category-defi-meta-description": "Entdecken Sie die besten DeFi-Apps auf Ethereum zum Verleihen, Ausleihen, Stablecoin-Emission, Kreditvergabe und Onchain-DEX-Handel.",
+ "page-apps-category-collectibles-name": "Sammlerstücke",
+ "page-apps-category-collectibles-description": "Sammlerstücke sind einzigartige, digitale Vermögenswerte, die sich nicht replizieren lassen.",
+ "page-apps-category-collectibles-meta-title": "Liste der besten NFT-Apps auf Ethereum",
+ "page-apps-category-collectibles-meta-description": "Erkunden Sie die besten NFT-Apps, um Sammlerstücke zu kaufen, Gaming-Skins zu tauschen und neue digitale Vermögenswerte auf den führenden Ethereum-Marktplätzen zu entdecken.",
+ "page-apps-category-social-name": "Sozial",
+ "page-apps-category-social-description": "Social ist eine Kategorie dezentraler Anwendungen, die es Nutzern ermöglicht, sich zu vernetzen und Inhalte zu teilen. ",
+ "page-apps-category-social-meta-title": "Social-Apps auf Ethereum: Farcaster, Zora und mehr",
+ "page-apps-category-social-meta-description": "Erkunde die besten Messenger- und Social-Apps auf Ethereum.",
+ "page-apps-category-gaming-name": "Gaming",
+ "page-apps-category-gaming-description": "Gaming ist eine Kategorie dezentraler Anwendungen, die es Nutzern ermöglicht, Spiele zu spielen und Belohnungen zu erhalten.",
+ "page-apps-category-gaming-meta-title": "Liste von Krypto- und NFT-Spielen auf Ethereum",
+ "page-apps-category-gaming-meta-description": "Entdecken Sie die besten Blockchain-Spiele, die Spaß machen. Von MMORPG, Kartenspiele, KI-Spiele, RPG bis hin zu Casual Games. ",
+ "page-apps-category-bridge-name": "Brücke",
+ "page-apps-category-bridge-description": "Bridge ist eine Kategorie dezentraler Anwendungen, die es Nutzern ermöglicht, ihre Vermögenswerte zwischen unterschiedlichen Netzwerken zu übertragen.",
+ "page-apps-category-bridge-meta-title": "Liste von Ethereum-Bridges zu unterschiedlichen Netzwerken",
+ "page-apps-category-bridge-meta-description": "Entdecken Sie die besten Krypto-Bridge-Apps, um Ihre Vermögenswerte zwischen unterschiedlichen Netzwerken und Layer-2s zu verschieben. ",
+ "page-apps-category-productivity-name": "Produktivität",
+ "page-apps-category-productivity-description": "Produktivität ist eine Kategorie dezentraler Anwendungen, die es Nutzern ermöglicht, produktiv zu sein.",
+ "page-apps-category-productivity-meta-title": "Produktivität und dezentrale Identitäts-Apps",
+ "page-apps-category-productivity-meta-description": "Erkunden Sie Ethereum-Apps für dezentrale Identität, Speicher, DNS und Video-Computing. Optimieren Sie Ihre Onchain-Produktivität mit vertrauenswürdigen Infrastruktur-Tools.",
+ "page-apps-category-privacy-name": "Privatsphäre",
+ "page-apps-category-privacy-description": "Datenschutz ist eine Kategorie von dezentralen Anwendungen, die es Nutzern erlaubt, privat zu bleiben.",
+ "page-apps-category-privacy-meta-title": "Ethereum Datenschutz-Apps: Tornado Cash und andere",
+ "page-apps-category-privacy-meta-description": "Entdecke Ethereum Privacy-Apps wie Tornado Cash und andere, die die Anonymität der Nutzer schützten, private Transaktionen ermöglichen und die Vertraulichkeit On-Chain ermöglichen.",
+ "page-apps-category-dao-name": "DAO",
+ "page-apps-category-dao-description": "DAO ist eine Kategorie dezentraler Anwendungen, die es Nutzern ermöglichen, dezentrale autonome Organisationen zu steuern und zu gründen.",
+ "page-apps-category-dao-meta-title": "Liste von DAO-Tools auf Ethereum",
+ "page-apps-category-dao-meta-description": "Entdecken Sie die besten DAO-Tools auf Ethereum für Governance, Treasury-Management, Abstimmungen und die Koordination von Beitragenden. Starten, verwalten und wachsen Sie mit Ihrer dezentralen Organisation.",
+ "page-apps-see-all": "Alle anzeigen",
+ "page-apps-suggest-an-app-title": "Dapp vorschlagen",
+ "page-apps-suggest-an-app-description": "Wir sind immer auf der Suche nach neuen Apps für unsere Liste. Wenn Sie eine App kennen, die unbedingt dabei sein sollte, lassen Sie es uns bitte wissen.",
+ "page-apps-suggest-an-app-button": "Dapp vorschlagen",
+ "page-apps-filter-by": "Gefiltert durch",
+ "page-apps-filter-all": "Alle",
+ "page-apps-showing": "Angezeigt",
+ "page-apps-visit-app": "Besuche",
+ "page-apps-see-next": "Nächste",
+ "page-apps-info-title": "Info",
+ "page-apps-info-founded": "Gegründet",
+ "page-apps-info-creator": "Ersteller",
+ "page-apps-info-last-updated": "Zuletzt aktualisiert",
+ "page-apps-gallery-title": "Galerie",
+ "page-apps-more-apps-like-this": "Ähnliche Apps anzeigen",
+ "page-apps-today": "Heute",
+ "page-apps-one-day-ago": "Vor 1 Tag",
+ "page-apps-days-ago": "vor {days} Tagen"
+}
\ No newline at end of file
diff --git a/src/intl/de/page-assets.json b/src/intl/de/page-assets.json
index 9db2b206407..be06b366874 100644
--- a/src/intl/de/page-assets.json
+++ b/src/intl/de/page-assets.json
@@ -33,6 +33,9 @@
"page-assets-future": "Zukunft",
"page-assets-h1": "ethereum.org Assets",
"page-assets-hero": "ethereum.org Held",
+ "page-assets-hero-panda": "ethereum.org-Hero mit Zusammenführungspanda",
+ "page-assets-merge-panda": "Zusammenführungspanda",
+ "page-assets-merge-panda-svg": "Zusammenführungspanda-SVG",
"page-assets-hero-particles": "ETH Partikelbild",
"page-assets-historical-artwork": "Historische Kunstwerke",
"page-assets-illustrations": "Illustrationen",
@@ -46,5 +49,13 @@
"page-assets-page-assets-transparent-background": "Transparenter Hintergrund",
"page-assets-robot": "Robot-Wallet",
"page-assets-sharding": "Sharding",
- "page-assets-hackathon": "Hackathon"
+ "page-assets-hackathon": "Hackathon",
+ "page-assets-learn-hero-name": "Seitenressourcen-Lernen-Heldenname",
+ "page-assets-community-hero-name": "Gemeinschafts-Versammlung",
+ "page-assets-quizzes-hero-name": "Unendlicher Spielplatz",
+ "page-assets-developers-hero-name": "Die Zukunft bauen",
+ "page-assets-garden-name": "Garten von Ethereum",
+ "page-assets-roadmap-hero-name": "Weg(e) in die Zukunft",
+ "page-assets-layer-2-hero-name": "Ethereum konstruieren",
+ "page-assets-guides-hero-name": "Ethereum Labor"
}
diff --git a/src/intl/de/page-bug-bounty.json b/src/intl/de/page-bug-bounty.json
index 145ad49c714..e34c8b2be9c 100644
--- a/src/intl/de/page-bug-bounty.json
+++ b/src/intl/de/page-bug-bounty.json
@@ -1,79 +1,92 @@
{
"page-upgrades-bug-bounty-annotated-specs": "kommentierte Spezifikation",
"page-upgrades-bug-bounty-annotations": "Es könnte hilfreich sein, die folgenden Anmerkungen zu prüfen:",
- "page-upgrades-bug-bounty-client-bugs": "Client-Fehler im Konsens-Layer",
- "page-upgrades-bug-bounty-client-bugs-desc": "Die Clients führen die Beacon Chain aus, sobald das Upgrade installiert ist. Die Clients müssen der in der Spezifikation dargelegten Logik folgen und gegen mögliche Angriffe geschützt sein. Die Fehler, die wir finden wollen, stehen in Zusammenhang mit der Implementierung des Protokolls.",
- "page-upgrades-bug-bounty-client-bugs-desc-2": "Derzeit sind Lighthouse-, Nimbus-, Teku- und Prysm-Fehler für die vollen Bounty-Belohnungen berechtigt. Lodestar ist ebenfalls teilnahmeberechtigt, aber bis weitere Audits abgeschlossen sind, sind die Punkte und Prämien auf 10 % begrenzt (maximale Auszahlung beträgt 5.000 DAI). Weitere Clients können hinzugefügt werden, wenn sie Audits abschließen und produktionsbereit sind.",
+ "page-upgrades-bug-bounty-client-bugs": "Client-Fehler",
+ "page-upgrades-bug-bounty-client-bugs-desc": "Clients betreiben das Ethereum-Netzwerk und müssen der Logik folgen, die in der Spezifikation festgelegt ist, und gegen mögliche Angriffe abgesichert sein. Die Fehler, die wir finden möchten, beziehen sich auf die Implementierung des Protokolls.",
+ "page-upgrades-bug-bounty-client-bugs-desc-2": "Derzeit sind die Execution-Layer-Clients (Besu, Erigon, Geth, Nethermind und Reth) und die Consensus-Layer-Clients (Lighthouse, Lodestar, Nimbus, Teku und Prysm) im Bug-Bounty-Programm enthalten. Weitere Clients können hinzugefügt werden, wenn sie Audits abschließen und produktionsbereit sind.",
"page-upgrades-bug-bounty-clients": "In den Belohnungen aufgeführte Clients",
"page-upgrades-bug-bounty-clients-type-1": "Probleme mit der Nichteinhaltung der Spezifikation",
- "page-upgrades-bug-bounty-clients-type-2": "Unerwartete Abstürze oder Denial-of-Service (DOS)-Schwachstellen",
- "page-upgrades-bug-bounty-clients-type-3": "Alle Probleme, die irreparable Abspaltungen vom Konsens des restlichen Netzwerks verursachen",
+ "page-upgrades-bug-bounty-clients-type-2": "Unerwartete Abstürze, RCE oder Denial-of-Service(DoS)-Schwachstellen",
+ "page-upgrades-bug-bounty-clients-type-3": "Alle Probleme, die irreparable Konsensabspaltungen des restlichen Netzwerks verursachen",
+ "page-upgrades-bug-bounty-misc-bugs": "Fehler im Sprachcompiler",
+ "page-upgrades-bug-bounty-misc-bugs-desc": "Die Solidity- und Vyper-Compiler sind Teil des Bug-Bounty-Programms. Bitte geben Sie alle Details an, die zur Reproduktion der Sicherheitslücke erforderlich sind, wie z.B.: das Eingabeprogramm, das den Fehler auslöst, die betroffene Compiler-Version, die Ziel-EVM-Version, ggf. das Framework/die IDE, ggf. die EVM-Ausführungsumgebung/den Client und das Betriebssystem. Bitte fügen Sie eine möglichst detaillierte Beschreibung der Schritte bei, um den von Ihnen gefundenen Fehler zu reproduzieren.",
+ "page-upgrades-bug-bounty-misc-bugs-desc-2": "Solidity und Vyper bieten keine Sicherheitsgarantien bezüglich der Kompilierung von nicht vertrauenswürdigen Eingaben – und wir vergeben keine Belohnungen für Abstürze des Compilers bei böswillig generierten Daten.",
+ "page-upgrades-bug-bounty-deposit-bugs": "Fehler im Deposit-Vertrag",
+ "page-upgrades-bug-bounty-deposit-bugs-desc": "Die Spezifikationen und der Quellcode des Beacon Chain-Einzahlungsvertrags sind Teil des Bug-Bounty-Programms.",
+ "page-upgrades-bug-bounty-deposit-contract-specs": "Spezifikationen des Einzahlungsvertrags",
+ "page-upgrades-bug-bounty-deposit-contract-source": "Quellcode des Einzahlungsvertrags",
+ "page-upgrades-bug-bounty-dependency-bugs": "Fehler in Abhängigkeiten",
+ "page-upgrades-bug-bounty-dependency-bugs-desc": "Bestimmte Abhängigkeiten sind für die Funktionsfähigkeit des Ethereum-Netzwerks von entscheidender Bedeutung, und einige von ihnen wurden in das Bug-Bounty-Programm aufgenommen. Derzeit sind die im Bug-Bounty-Programm enthaltenen Abhängigkeiten C-KZG-4844 und Go-KZG-4844.",
"page-upgrades-bug-bounty-docking": "zusammenführen",
- "page-upgrades-bug-bounty-email-us": "Senden Sie uns eine E-Mail an:",
+ "page-upgrades-bug-bounty-email-us": "Senden Sie uns eine E-Mail:",
"page-upgrades-bug-bounty-help-links": "Hilfreiche Links",
"page-upgrades-bug-bounty-hunting": "Regeln für die Fehlersuche",
- "page-upgrades-bug-bounty-hunting-desc": "Das Fehlerbelohnungsprogramm ist ein experimentelles, unserem Ermessen überlassenes Prämienprogramm für unsere aktive Ethereum-Community, um diejenigen zu ermuntern und zu belohnen, die zur Verbesserung der Plattform beitragen. Es ist kein Wettbewerb. Hinweis: Wir behalten uns vor, das Programm jederzeit zu beenden. Auszeichnungen werden nach alleinigem Ermessen des Bug-Bounty-Programm-Gremiums der Ethereum Foundation vergeben. Außerdem können wir keine Auszeichnungen an Personen vergeben, die auf Sanktionslisten stehen oder sich in Ländern auf Sanktionslisten befinden (bspw. in Nordkorea, Iran etc.). Jeder ist selbst für die korrekte Versteuerung verantwortlich. Alle Auszeichnungen unterliegen dem geltenden Recht. Das Testen darf zudem keine Gesetze verletzen oder Daten kompromittieren, die nicht die eigenen sind.",
- "page-upgrades-bug-bounty-hunting-leaderboard": "Rangliste bei der Fehlersuche",
- "page-upgrades-bug-bounty-hunting-leaderboard-subtitle": "Finden Sie Konsens-Layer-Fehler, um zu dieser Rangliste hinzugefügt zu werden",
- "page-upgrades-bug-bounty-hunting-li-1": "Probleme, die bereits von einem anderen Nutzer eingereicht wurden oder die bereits Spezifikations- oder Client-Betreuern bekannt sind, berechtigen nicht zu Belohnungsprämien.",
- "page-upgrades-bug-bounty-hunting-li-2": "Die öffentliche Bekanntgabe einer Sicherheitslücke führt dazu, dass sie nicht für eine Belohnung in Frage kommt.",
- "page-upgrades-bug-bounty-hunting-li-3": "Forscher der Ethereum Foundation und Mitarbeiter von Konsens-Layer-Kundenteams haben keinen Anspruch auf Belohnungen.",
- "page-upgrades-bug-bounty-hunting-li-4": "Das Ethereum Bounty-Programm berücksichtigt eine Reihe von Variablen bei der Bestimmung der Belohnungen. Die Anspruchsprüfung, die Berechnung des Ergebnisses und alle weiteren Bestimmungen bezüglich einer Belohnung liegen im alleinigen und endgültigen Ermessen des Ethereum Foundation-Bug-Bounty-Panels.",
- "page-upgrades-bug-bounty-leaderboard": "Vollständige Rangliste anzeigen",
+ "page-upgrades-bug-bounty-hunting-desc": "Das Bug-Bounty-Programm ist ein experimentelles und nach Ermessen angebotenes Belohnungsprogramm für unsere aktive Ethereum-Community, um diejenigen zu fördern und zu belohnen, die dazu beitragen, die Plattform zu verbessern. Es ist kein Wettbewerb. Sie sollten wissen, dass wir das Programm jederzeit beenden können und die Vergabe von Belohnungen allein im Ermessen des Bug-Bounty-Gremiums der Ethereum Foundation liegt. Außerdem können wir keine Belohnungen an Personen vergeben, die auf Sanktionslisten stehen oder sich in sanktionierten Ländern befinden (z. B. Nordkorea, Iran usw.). Lokale Gesetze verlangen von uns, einen Nachweis Ihrer Identität einzuholen. Sie sind für alle Steuern verantwortlich. Alle Belohnungen unterliegen dem gültigen Recht. Schließlich darf Ihr Testing gegen kein Gesetz verstoßen sowie keine Daten kompromittieren, die Ihnen nicht gehören, und muss in lokal ausgeführten Testnets stattfinden.",
+ "page-upgrades-bug-bounty-hunting-leaderboard": "Rangliste für Konsensebenen-Bug-Bounty",
+ "page-upgrades-bug-bounty-hunting-execution-leaderboard": "Rangliste für Ausführungsebenen-Bug-Bounty",
+ "page-upgrades-bug-bounty-hunting-leaderboard-subtitle": "Finden Sie Fehler in der Konsensebene, um in diese Rangliste aufgenommen zu werden",
+ "page-upgrades-bug-bounty-hunting-execution-leaderboard-subtitle": "Finden Sie Fehler in der Ausführungsebene, um in diese Rangliste aufgenommen zu werden",
+ "page-upgrades-bug-bounty-hunting-li-1": "Probleme ohne einen POC (Proof of Concept) oder die bereits von einem anderen Benutzer eingereicht wurden oder den Spezifikations- und Client-Betreuern bereits bekannt sind, sind für Bounty-Belohnungen nicht berechtigt.",
+ "page-upgrades-bug-bounty-hunting-li-2": "Die öffentliche Bekanntgabe einer Sicherheitslücke oder die Meldung an Dritte ohne vorherige Absprache führt dazu, dass kein Anspruch auf eine Prämie besteht.",
+ "page-upgrades-bug-bounty-hunting-li-3": "Mitarbeiter und Auftragnehmer der Ethereum Foundation oder am Bounty-Programm beteiligte Client-Teams können nur im Rahmen der Anhäufung von Punkten am Programm teilnehmen und erhalten keine monetären Belohnungen.",
+ "page-upgrades-bug-bounty-hunting-li-4": "Das Bounty-Programm von Ethereum berücksichtigt eine Reihe von Variablen bei der Bestimmung der Belohnungen. Die Anspruchsprüfung, die Berechnung des Ergebnisses und alle Bestimmungen bezüglich einer Belohnung liegen im alleinigen und endgültigen Ermessen des Bug-Bounty-Gremiums der Ethereum Foundation.",
+ "page-upgrades-bug-bounty-leaderboard": "Vollständige Ranglisten anzeigen",
+ "page-upgrades-bug-bounty-leaderboard-list": "Bug-Bounty-Rangliste",
"page-upgrades-bug-bounty-leaderboard-points": "Punkte",
- "page-upgrades-bug-bounty-ledger-desc": "Die Beacon Chain-Spezifikation beschreibt das Designprinzip und die vorgeschlagenen Änderungen an Ethereum durch das Beacon Chain-Upgrade.",
- "page-upgrades-bug-bounty-ledger-title": "Die Fehler in der Spezifikation der Beacon Chain",
- "page-upgrades-bug-bounty-meta-description": "Ein Überblick über das Consensus-Layer-Bug-Bounty-Programm: So können Sie sich beteiligen und Informationen zur Belohnung.",
- "page-upgrades-bug-bounty-meta-title": "Konsensus-Layer-Prämienprogramm für die Fehlersuche",
- "page-upgrades-bug-bounty-not-included": "Nicht enthalten",
- "page-upgrades-bug-bounty-not-included-desc": "Die Zusammenführung und die Shard-Chain- und Docking-Upgrades befinden sich derzeit noch in der Entwicklung und sind daher noch nicht Teil dieses Belohnungsprogramms.",
+ "page-upgrades-bug-bounty-ledger-desc": "Die Ethereum-Spezifikationen beschreiben das Gestaltungsprinzip für die Ausführungs- und Konsensebene.",
+ "page-upgrades-bug-bounty-ledger-title": "Spezifikationsfehler",
+ "page-upgrades-bug-bounty-meta-description": "Eine Übersicht über das Bug-Bounty-Programm von Ethereum: Informationen zu Teilnahme und Belohnungen.",
+ "page-upgrades-bug-bounty-meta-title": "Bug-Bounty-Programm von Ethereum",
+ "page-upgrades-bug-bounty-not-included": "Außerhalb des Geltungsbereichs",
+ "page-upgrades-bug-bounty-not-included-desc": "Nur die unter „In-Scope“ aufgeführten Ziele sind Teil des Bug-Bounty-Programms. Zu den Sicherheitslücken, die sich NICHT für das Programm qualifizieren, gehören:",
"page-upgrades-bug-bounty-owasp": "OWASP-Methode anzeigen",
- "page-upgrades-bug-bounty-points": "Die EF vergibt ebenfalls Punkte, basierend auf:",
- "page-upgrades-bug-bounty-points-error": "Fehler beim Laden der Daten... bitte aktualisieren.",
+ "page-upgrades-bug-bounty-points": "Die EF wird ebenfalls Belohnungen basierend auf Folgendem bereitstellen:",
+ "page-upgrades-bug-bounty-points-error": "Fehler beim Laden der Daten ... Bitte aktualisieren.",
"page-upgrades-bug-bounty-points-exchange": "Punktebörse",
- "page-upgrades-bug-bounty-points-loading": "Daten werden geladen...",
+ "page-upgrades-bug-bounty-points-loading": "Daten werden geladen ...",
"page-upgrades-bug-bounty-points-payout-desc": "Die Ethereum Foundation zahlt den USD-Wert in ETH oder DAI aus.",
"page-upgrades-bug-bounty-points-point": "1 Punkt",
"page-upgrades-bug-bounty-points-rights-desc": "Die Ethereum Foundation behält sich das Recht vor, Änderungen ohne vorherige Ankündigung vorzunehmen.",
"page-upgrades-bug-bounty-points-usd": "2 USD",
"page-upgrades-bug-bounty-quality": "Beschreibungsqualität",
- "page-upgrades-bug-bounty-quality-desc": ": Höhere Prämien werden für klare, gut geschriebene Beiträge gezahlt.",
- "page-upgrades-bug-bounty-quality-fix": "Qualität der Korrektur, falls enthalten: Für Einreichungen mit einer klaren Beschreibung der Problemlösung werden höhere Prämien bezahlt.",
+ "page-upgrades-bug-bounty-quality-desc": ": Höhere Belohnungen werden für klare, gut geschriebene Einreichungen gezahlt.",
+ "page-upgrades-bug-bounty-quality-fix": "Qualität der Korrektur, falls enthalten: Für Einreichungen mit einer klaren Beschreibung der Problemlösung werden höhere Belohnungen gezahlt.",
"page-upgrades-bug-bounty-quality-repro": "Qualität der Reproduzierbarkeit",
- "page-upgrades-bug-bounty-quality-repro-desc": ": Bitte fügen Sie Testcode, Skripte und detaillierte Anweisungen bei. Je einfacher es für uns ist, die Vulnerabilität zu reproduzieren und zu überprüfen, desto höher die Belohnung.",
+ "page-upgrades-bug-bounty-quality-repro-desc": ": Ein Proof of Concept (POC) muss enthalten sein, um für Belohnungen berechtigt zu sein. Bitte fügen Sie den Testcode, Skripte und detaillierte Anweisungen bei. Je einfacher es für uns ist, die Schwachstelle zu reproduzieren und zu verifizieren, desto höher fällt die Belohnung aus.",
"page-upgrades-bug-bounty-questions": "Fragen?",
"page-upgrades-bug-bounty-rules": "Regeln lesen",
- "page-upgrades-bug-bounty-slogan": "Konsens-Layer-Bug-Bounties",
- "page-upgrades-bug-bounty-specs": "Vollständige Spezifikation lesen",
+ "page-upgrades-bug-bounty-slogan": "Bug-Bounty-Programm",
+ "page-upgrades-bug-bounty-specs": "Spezifikationen zur Konsensebene",
+ "page-upgrades-bug-bounty-execution-specs": "Spezifikationen zur Ausführungsebene",
"page-upgrades-bug-bounty-specs-docs": "Spezifikationsdokumente",
- "page-upgrades-bug-bounty-submit": "Fehler melden",
- "page-upgrades-bug-bounty-submit-desc": "Für jeden Fehler, den Sie finden, werden Sie mit Punkten belohnt. Die Punkte, die Sie verdienen, hängen vom Schweregrad des Fehlers ab. Lodestar-Fehler werden derzeit mit 10 % der unten aufgeführten Punkte ausgezeichnet, da weitere Audits abgeschlossen werden müssen. Die Ethereum Foundation (EF) bestimmt den Schweregrad mit der OWASP-Methode.",
- "page-upgrades-bug-bounty-subtitle": "Verdienen Sie bis zu 50.000 USD und einen Platz auf der Rangliste, indem Sie Konsens-Layer-Protokoll- und Client-Fehler finden.",
+ "page-upgrades-bug-bounty-submit": "Einen Fehler einreichen",
+ "page-upgrades-bug-bounty-submit-desc": "Für jeden gültigen Fehler, den Sie finden, erhalten Sie eine Belohnung. Die Höhe der Belohnung variiert je nach Schweregrad. Der Schweregrad wird nach dem OWASP-Risikobewertungsmodell auf der Grundlage der Auswirkungen auf das Ethereum-Netzwerk und der Eintrittswahrscheinlichkeit berechnet.",
+ "page-upgrades-bug-bounty-subtitle": "Verdienen Sie bis zu 250.000 USD und einen Platz in der Rangliste, indem Sie Fehler im Protokoll, im Client und im Sprachcompiler finden, die das Ethereum-Netzwerk betreffen.",
"page-upgrades-bug-bounty-title": "Für Einreichungen offen",
"page-upgrades-bug-bounty-title-1": "Beacon Chain",
"page-upgrades-bug-bounty-title-2": "Auswahl forken",
- "page-upgrades-bug-bounty-title-3": "Solidity-Deposit-Vertrag",
- "page-upgrades-bug-bounty-title-4": "Peer-to-Peer-Netzwerk",
+ "page-upgrades-bug-bounty-title-3": "Solidity-Einzahlungsvertrag",
+ "page-upgrades-bug-bounty-title-4": "Peer-to-Peer-Networking",
"page-upgrades-bug-bounty-type-1": "Sicherheits-/endgültigkeitsverletzende Fehler",
- "page-upgrades-bug-bounty-type-2": "Denial-of-Service (DOS)-Vektoren",
- "page-upgrades-bug-bounty-type-3": "Inkonsistenzen in den Annahmen, wie Situationen, in denen ehrliche Validatoren geslasht werden",
+ "page-upgrades-bug-bounty-type-2": "Denial-of-Service(DOS)-Vektoren",
+ "page-upgrades-bug-bounty-type-3": "Inkonsistenzen in den Annahmen, z. B. Situationen, in denen ehrliche Validatoren geslasht werden können",
"page-upgrades-bug-bounty-type-4": "Berechnungs- oder Parameterinkonsistenzen",
"page-upgrades-bug-bounty-types": "Fehlerarten",
- "page-upgrades-bug-bounty-validity": "Gültige Fehler",
- "page-upgrades-bug-bounty-validity-desc": "Dieses Bug-Bounty-Programm konzentriert sich auf die Suche nach Fehlern in der Beacon Chain-Spezifikation und den Lighthouse-, Nimbus-, Teku-, Prysm- und Lodestar-Client-Implementierungen.",
+ "page-upgrades-bug-bounty-validity": "Im Geltungsbereich",
+ "page-upgrades-bug-bounty-validity-desc": "Unser Bug-Bounty-Programm ist durchgängig: von der Solidität der Protokolle (wie dem Blockchain-Konsensmodell, den Wire- und p2p-Protokollen, Proof-of-Stake usw.) und der Protokoll-/Implementierungskonformität bis hin zur Netzwerksicherheit und Konsensintegrität. Die klassische Client-Sicherheit sowie die Sicherheit kryptographischer Primitiven sind ebenfalls Teil des Programms. Senden Sie im Zweifelsfall eine E-Mail an bounty@ethereum.org und fragen Sie uns. Sie können eine Offenlegung/Schwachstelle auch direkt an bounty@ethereum.org senden. In diesem Fall bitten wir Sie, die Nachricht mit unserem PGP-Schlüssel zu verschlüsseln.",
"page-upgrades-bug-bounty-card-critical": "Kritisch",
- "page-upgrades-bug-bounty-card-critical-risk": "Fehler mit kritischem Risiko melden",
+ "page-upgrades-bug-bounty-card-critical-risk": "Fehler mit kritischem Risiko einreichen",
"page-upgrades-bug-bounty-card-h2": "Mittel",
"page-upgrades-bug-bounty-card-high": "Hoch",
- "page-upgrades-bug-bounty-card-high-risk": "Fegker mit hohem Risiko melden",
+ "page-upgrades-bug-bounty-card-high-risk": "Fehler mit hohem Risiko einreichen",
"page-upgrades-bug-bounty-card-label-1": "Bis zu 1.000 Punkte",
- "page-upgrades-bug-bounty-card-label-2": "Bis zu 2.000 DAI",
+ "page-upgrades-bug-bounty-card-label-2": "Bis zu 2.000 USD",
"page-upgrades-bug-bounty-card-label-3": "Bis zu 5.000 Punkte",
- "page-upgrades-bug-bounty-card-label-4": "Bis zu 10.000 DAI",
+ "page-upgrades-bug-bounty-card-label-4": "Bis zu 10.000 USD",
"page-upgrades-bug-bounty-card-label-5": "Bis zu 10.000 Punkte",
- "page-upgrades-bug-bounty-card-label-6": "Bis zu 20.000 DAI",
+ "page-upgrades-bug-bounty-card-label-6": "Bis zu 50.000 USD",
"page-upgrades-bug-bounty-card-label-7": "Bis zu 25.000 Punkte",
- "page-upgrades-bug-bounty-card-label-8": "Bis zu 50.000 DAI",
+ "page-upgrades-bug-bounty-card-label-8": "Bis zu 250.000 USD",
"page-upgrades-bug-bounty-card-li-1": "Geringe Auswirkung, mittlere Wahrscheinlichkeit",
"page-upgrades-bug-bounty-card-li-2": "Mittlere Auswirkung, geringe Wahrscheinlichkeit",
"page-upgrades-bug-bounty-card-li-3": "Hohe Auswirkung, geringe Wahrscheinlichkeit",
@@ -83,13 +96,74 @@
"page-upgrades-bug-bounty-card-li-7": "Mittlere Auswirkung, hohe Wahrscheinlichkeit",
"page-upgrades-bug-bounty-card-li-8": "Hohe Auswirkung, hohe Wahrscheinlichkeit",
"page-upgrades-bug-bounty-card-low": "Gering",
- "page-upgrades-bug-bounty-card-low-risk": "Fehler mit geringem Risiko melden",
- "page-upgrades-bug-bounty-card-medium-risk": "Fehler mit mittlerem Risiko melden",
+ "page-upgrades-bug-bounty-card-low-risk": "Fehler mit geringem Risiko einreichen",
+ "page-upgrades-bug-bounty-card-medium-risk": "Fehler mit mittlerem Risiko einreichen",
"page-upgrades-bug-bounty-card-subheader": "Schweregrad",
"page-upgrades-bug-bounty-card-subheader-2": "Beispiel",
- "page-upgrades-bug-bounty-card-text": "Ein Angreifer kann manchmal einen Knoten in einen Zustand versetzen, der ihn dazu veranlasst, eine von hundert Bescheinigungen zu verlieren, die von einem Validator gemacht wurden",
- "page-upgrades-bug-bounty-card-text-1": "Ein Angreifer kann erfolgreich einen Eclipse-Angriff auf Knoten mit Peer-IDs mit 4 führenden Nullbytes ausführen",
- "page-upgrades-bug-bounty-card-text-2": "Es gibt einen Konsensfehler zwischen zwei Clients, aber es ist schwierig oder unpraktisch für den Angreifer, das Ereignis auszulösen.",
- "page-upgrades-bug-bounty-card-text-3": "Es gibt einen Konsensfehler zwischen zwei Clients und es ist trivial für einen Angreifer, das Ereignis auszulösen.",
- "page-upgrades-question-title": "Häufig gestellte Fragen"
+ "page-upgrades-bug-bounty-card-text": "Der Angreifer kann manchmal einen Knoten in einen Zustand versetzen, der ihn dazu veranlasst, eine von hundert Attestierungen zu verlieren, die von einem Validator gemacht wurden",
+ "page-upgrades-bug-bounty-card-text-1": "Der Angreifer kann erfolgreich Eclipse-Angriffe auf Knoten mit Peer-IDs mit 4 führenden Nullbytes ausführen",
+ "page-upgrades-bug-bounty-card-text-2": "Der Angreifer kann leicht große Teile des Netzwerks partitionieren und es ist für einen Angreifer einfach, die Schwachstelle auszulösen",
+ "page-upgrades-bug-bounty-card-text-3": "Der Angreifer kann erfolgreich eine Remote-Code-Ausführung in einem Mehrheits-Client durchführen und es ist für einen Angreifer einfach, die Schwachstelle auszulösen",
+ "page-upgrades-question-title": "Häufig gestellte Fragen",
+ "bug-bounty-faq-q1-title": "Wie sollte eine gute Schwachstelleneinreichung aussehen?",
+ "bug-bounty-faq-q1-contentPreview": "Sehen Sie sich ein echtes Beispiel für eine hochwertige Schwachstelleneinreichung an.",
+ "bug-bounty-faq-q1-content-1": "Beschreibung: Remote-Denial-of-Service durch nicht validierte Blöcke",
+ "bug-bounty-faq-q1-content-2": "Angriffsszenario: Ein Angreifer kann Blöcke senden, die möglicherweise eine hohe Anzahl an Berechnungen erfordern können (das maximale gasLimit), aber ohne Proof-of-Work. Wenn der Angreifer kontinuierlich Blöcke sendet, kann er den Empfängerknoten zu 100 % CPU-Auslastung zwingen.",
+ "bug-bounty-faq-q1-content-3": "Auswirkung: Ein Angreifer kann die CPU-Auslastung auf entfernten Knoten missbrauchen und möglicherweise DoS in vollem Umfang verursachen.",
+ "bug-bounty-faq-q1-content-4": "Komponenten: Go-Client Version v0.6.8",
+ "bug-bounty-faq-q1-content-5": "Reproduktion: Senden Sie einen Block an einen Go-Knoten, der viele Txs aber keinen gültigen PoW enthält.",
+ "bug-bounty-faq-q1-content-6": "Details: Blöcke werden in der Methode Process(Block, dontReact) validiert. Diese Methode führt teure CPU-intensive Aufgaben durch, wie zum Beispiel das Ausführen von Transaktionen (sm.ApplyDiff) und anschließend die Verifizierung des Proof-of-Work (sm.ValidateBlock()). Dadurch kann ein Angreifer Blöcke senden, die möglicherweise eine hohe Rechenleistung erfordern (das maximale gasLimit), aber keinen Proof-of-Work haben. Wenn der Angreifer kontinuierlich Blöcke sendet, kann er den angegriffenen Knoten zu 100 % CPU-Auslastung zwingen.",
+ "bug-bounty-faq-q1-content-7": "Korrektur: Kehren Sie die Reihenfolge der Überprüfungen um.",
+ "bug-bounty-faq-q2-title": "Ist das Bug-Bounty-Programm zeitlich befristet?",
+ "bug-bounty-faq-q2-contentPreview": "Nein.",
+ "bug-bounty-faq-q2-content-1": "Derzeit ist kein Enddatum festgelegt. Im Blog der Ethereum Foundation finden Sie aktuelle Neuigkeiten.",
+ "bug-bounty-faq-q3-title": "Wie werden Belohnungen ausgezahlt?",
+ "bug-bounty-faq-q3-contentPreview": "Belohnungen werden in ETH oder DAI ausgezahlt.",
+ "bug-bounty-faq-q3-content-1": "Belohnungen werden in ETH oder DAI ausgezahlt, nachdem die Einreichung validiert wurde, was in der Regel einige Tage danach erfolgt. Lokale Gesetze verlangen von uns, den Nachweis Ihrer Identität zu verlangen. Zusätzlich benötigen wir Ihre ETH-Adresse.",
+ "bug-bounty-faq-q4-title": "Kann ich meine Belohnung für wohltätige Zwecke spenden?",
+ "bug-bounty-faq-q4-contentPreview": "Ja!",
+ "bug-bounty-faq-q4-content-1": "Wir können Ihre Belohnung an eine etablierte Wohltätigkeitsorganisation Ihrer Wahl spenden.",
+ "bug-bounty-faq-q5-title": "Ich habe ein Problem/eine Schwachstelle gemeldet, aber keine Antwort erhalten!",
+ "bug-bounty-faq-q5-contentPreview": "Bitte geben Sie uns ein paar Tage Zeit, auf Ihre Einreichung zu antworten.",
+ "bug-bounty-faq-q5-content-1": "Wir möchten so schnell wie möglich auf Einreichungen antworten. Senden Sie uns gern eine E-Mail an bounty@ethereum.org, wenn Sie nicht innerhalb von ein oder zwei Tagen eine Antwort erhalten.",
+ "bug-bounty-faq-q6-title": "Ich möchte anonym sein/Ich möchte nicht, dass mein Name in der Rangliste erscheint.",
+ "bug-bounty-faq-q6-contentPreview": "Sie können dies tun, aber es könnte Sie für Belohnungen disqualifizieren.",
+ "bug-bounty-faq-q6-content-1": "Anonyme oder pseudonymisierte Einreichungen sind in Ordnung, machen Sie aber für ETH/DAI-Belohnungen unberechtigt. Um für ETH/DAI-Belohnungen berechtigt zu sein, benötigen wir Ihren echten Namen und einen Identitätsnachweis. Diese Daten müssen mittels PGP verschlüsselt über unsere sichere Drop-Website an unser Rechtsteam bei der Ethereum Foundation gesendet werden, welches als einziges die Dokumentation prüft. Wenn Sie Ihre Prämie an eine Wohltätigkeitsorganisation spenden, ist Ihre Identität nicht erforderlich.",
+ "bug-bounty-faq-q6-content-2": "Bitte teilen Sie uns mit, wenn Sie nicht möchten, dass Ihr Name/Spitzname in der Rangliste angezeigt wird.",
+ "bug-bounty-faq-q7-title": "Was bedeuten die Punkte in der Rangliste?",
+ "bug-bounty-faq-q7-contentPreview": "Jeder gefundenen Schwachstelle/Jedem gefundenen Problem wird eine Punktzahl zugeordnet",
+ "bug-bounty-faq-q7-content-1": "Jeder gefundenen Schwachstelle/Jedem gefundenen Problem wird eine Punktzahl zugeordnet. Teilnehmer werden in unserer Rangliste nach Gesamtpunkten eingestuft.",
+ "bug-bounty-faq-q8-title": "Haben Sie einen PGP-Schlüssel?",
+ "bug-bounty-faq-q8-contentPreview": "Ja. Erweitern, um Details anzuzeigen.",
+ "bug-bounty-faq-q8-content-1": "Bitte verwenden Sie AE96 ED96 9E47 9B00 84F3 E17F E88D 3334 FA5F 6A0A",
+ "bug-bounty-faq-q8-PGP-key": "PGP-Schlüssel",
+ "page-upgrades-bug-bounty-severity-qualifications-title": "Qualifikationen für den Schweregrad von Sicherheitslücken",
+ "page-upgrades-bug-bounty-severity-qualifications-desc": "Der Schweregrad wird danach bemessen, inwieweit eine entdeckte Sicherheitslücke Folgendes bewirken kann:",
+ "page-upgrades-bug-bounty-severity-low-title": "Niedriger Schweregrad",
+ "page-upgrades-bug-bounty-severity-low-li-1": "Slashing von 0,01 % der Validatoren",
+ "page-upgrades-bug-bounty-severity-low-li-2": "Leichtes Verursachen von Netzwerk-Splits, die 0,01 % des Netzwerks betreffen",
+ "page-upgrades-bug-bounty-severity-low-li-3": "Möglichkeit, 0,01 % des Netzwerks durch Senden eines einzelnen Netzwerkpakets oder einer On-Chain-Transaktion lahmzulegen",
+ "page-upgrades-bug-bounty-severity-medium-title": "Mittlerer Schweregrad",
+ "page-upgrades-bug-bounty-severity-medium-li-1": "Slashing von 1 % der Validatoren",
+ "page-upgrades-bug-bounty-severity-medium-li-2": "Leichtes Verursachen von Netzwerk-Splits, die 5 % des Netzwerks betreffen",
+ "page-upgrades-bug-bounty-severity-medium-li-3": "Möglichkeit, 5 % des Netzwerks durch Senden eines einzelnen Netzwerkpakets oder einer On-Chain-Transaktion lahmzulegen",
+ "page-upgrades-bug-bounty-severity-high-title": "Hoher Schweregrad",
+ "page-upgrades-bug-bounty-severity-high-li-1": "Slashing von 33 % der Validatoren",
+ "page-upgrades-bug-bounty-severity-high-li-2": "Leichtes Verursachen von Netzwerk-Splits, die 33 % des Netzwerks betreffen",
+ "page-upgrades-bug-bounty-severity-high-li-3": "Möglichkeit, 33 % des Netzwerks durch Senden eines einzelnen Netzwerkpakets oder einer On-Chain-Transaktion lahmzulegen",
+ "page-upgrades-bug-bounty-severity-critical-title": "Kritischer Schweregrad",
+ "page-upgrades-bug-bounty-severity-critical-li-1": "Slashing von 50 % der Validatoren",
+ "page-upgrades-bug-bounty-severity-critical-li-2": "Ausnutzen eines EIP/einer Spezifikation oder eines Client-Bugs, um auf einfache Weise eine unendliche Menge an ETH zu erzeugen, die vom Netzwerk finalisiert wird",
+ "page-upgrades-bug-bounty-severity-critical-li-3": "ETH stehlen von allen EOAs",
+ "page-upgrades-bug-bounty-severity-critical-li-4": "ETH verbrennen von allen EOAs",
+ "page-upgrades-bug-bounty-severity-critical-li-5": "Das gesamte Netzwerk lahmlegen, indem eine einzige bösartige On-Chain-Transaktion gesendet wird, die zum Absturz aller Clients führt",
+ "page-upgrades-bug-bounty-out-of-scope-footnote": "Diese sind in der Regel nicht enthalten, wir können jedoch in solchen Fällen helfen, betroffene Parteien wie Autoren oder Börsen zu kontaktieren",
+ "page-upgrades-bug-bounty-not-included-li-1": "Infrastrukturfehler – wie z. B. Webseiten, DNS, E-Mail usw.",
+ "page-upgrades-bug-bounty-not-included-li-2": "Fehler in ERC-20-Verträgen",
+ "page-upgrades-bug-bounty-not-included-li-3": "Fehler im Ethereum Naming Service (ENS) (wird von der ENS-Foundation gewartet)",
+ "page-upgrades-bug-bounty-not-included-li-4": "Schwachstellen, die erfordern, dass der Benutzer eine API, wie z. B. JSON-RPC oder die Beacon-API, öffentlich zugänglich gemacht hat",
+ "page-upgrades-bug-bounty-not-included-li-5": "Tippfehler",
+ "page-upgrades-bug-bounty-not-included-li-6": "Tests",
+ "page-upgrades-bug-bounty-not-included-li-7": "Single-Peer-DoS-Angriffe mit hohem Aufwand (dauerhaft, CPU- oder bandbreitenintensiv und/oder mehr als 1 Paket oder On-Chain-Transaktion erfordernd)",
+ "page-upgrades-bug-bounty-not-included-li-8": "Alle öffentlich bekannten Probleme (einschließlich Forenbeiträge, PRs, GitHub-Issues, Commits, Blogbeiträge, öffentliche Discord-Nachrichten usw.)"
}
diff --git a/src/intl/de/page-collectibles.json b/src/intl/de/page-collectibles.json
new file mode 100644
index 00000000000..d929eed3476
--- /dev/null
+++ b/src/intl/de/page-collectibles.json
@@ -0,0 +1,67 @@
+{
+ "page-collectibles-already-desc": "Überprüfen Sie Ihren Fortschritt",
+ "page-collectibles-already-title": "Sind Sie bereits ein Mitwirkender?",
+ "page-collectibles-code-content-desc": "Beheben Sie Probleme, schreiben oder verbessern Sie Artikel oder schlagen Sie Designverbesserungen für die Website vor.",
+ "page-collectibles-code-content-design-1issue": "Abzeichen für gelöstes Design-Problem",
+ "page-collectibles-code-content-design-desc": "Nehmen Sie an Design-Kritiken teil, verbessern Sie unser Design-System oder beteiligen Sie sich an Benutzertests.",
+ "page-collectibles-code-content-design-title": "Design",
+ "page-collectibles-code-content-design-user-testing": "Abzeichen für die Teilnahme an Benutzertests",
+ "page-collectibles-code-content-developer-10pr": "Abzeichen für 10 gemergte PRs",
+ "page-collectibles-code-content-developer-1pr": "Abzeichen für 1 gemergten PR",
+ "page-collectibles-code-content-developer-5pr": "Abzeichen für 5 gemergte PRs",
+ "page-collectibles-code-content-developer-desc": "Jede in die Website gemergte Verbesserung.",
+ "page-collectibles-code-content-developer-title": "Entwickler",
+ "page-collectibles-code-content-gitpoap-1pr": "Abzeichen für gemergten PR",
+ "page-collectibles-code-content-gitpoap-desc": "Automatisch beanspruchbar, nachdem Ihr PR gemergt wurde.",
+ "page-collectibles-code-content-gitpoap-title": "GitPOAP",
+ "page-collectibles-code-content-instructions-1": "Gehen Sie zu unserem GitHub Repository",
+ "page-collectibles-code-content-instructions-2": "Wählen Sie ein Problem zur Bearbeitung aus",
+ "page-collectibles-code-content-instructions-3": "Committen Sie eine Fehlerbehebung oder Verbesserung",
+ "page-collectibles-code-content-title": "Code & Inhalte",
+ "page-collectibles-code-content-writing-badge-1": "Abzeichen für Inhaltsbeitrag",
+ "page-collectibles-code-content-writing-desc": "Für jede Inhaltsverbesserung, die in den Master-Branch gemergt wurde.",
+ "page-collectibles-code-content-writing-title": "Schreiben",
+ "page-collectibles-connect-wallet": "Wallet verbinden",
+ "page-collectibles-contributing-since": "Mitwirkend seit",
+ "page-collectibles-contributor-img-alt": "Zwei Mitwirkende unterhalten sich",
+ "page-collectibles-contributor-progress-label": "Beansprucht",
+ "page-collectibles-current-year-title": "Aktuelles Jahr",
+ "page-collectibles-get-started": "Erste Schritte",
+ "page-collectibles-hero-description": "Beweisen Sie on-chain, dass Sie an ethereum.org mitgearbeitet haben.",
+ "page-collectibles-hero-header": "Sammelobjekte von ethereum.org",
+ "page-collectibles-hero-title": "Abzeichen",
+ "page-collectibles-how-step1-desc": "zur Website",
+ "page-collectibles-how-step1-title": "Mitwirken",
+ "page-collectibles-how-step2-desc": "auf Discord",
+ "page-collectibles-how-step2-title": "Lassen Sie sich verifizieren",
+ "page-collectibles-how-step3-desc": "auf Galxe",
+ "page-collectibles-how-step3-title": "NFT beanspruchen",
+ "page-collectibles-how-title": "Wie es funktioniert",
+ "page-collectibles-improve-desc-1": "Verdienen Sie einzigartige NFTs, indem Sie bei der Pflege und Erweiterung der ethereum.org-Website helfen. Diese Abzeichen würdigen Ihre Teilnahme on-chain.",
+ "page-collectibles-improve-desc-2": "Top-Inhaber erhalten Contributor-Swag oder ermäßigte Tickets für Events wie Devcon. Ihre On-chain-Abzeichen machen es für andere einfach, Sie zu unterstützen.",
+ "page-collectibles-improve-title": "Verbessern Sie ethereum.org",
+ "page-collectibles-index-frequency": "Die Ergebnisse werden einmal täglich um 15:15 UTC aktualisiert",
+ "page-collectibles-instructions-label": "Anleitungen",
+ "page-collectibles-previous-years-badge-count": "{count, plural, =0 {keine Abzeichen} =1 {1 Abzeichen} other {# Abzeichen}}",
+ "page-collectibles-previous-years-collectors-count": "{count, plural, =0 {keine Sammler} =1 {1 Sammler} other {# Sammler}}",
+ "page-collectibles-previous-years-no-badges": "Keine Abzeichen geprägt",
+ "page-collectibles-previous-years": "Vorherige Jahre",
+ "page-collectibles-social-desc": "Nehmen Sie an einem unserer Discord-Calls teil, um die Website vor Veröffentlichungen auf Fehler zu testen oder bleiben Sie bei unseren monatlichen Community-Calls über Neuigkeiten zu ethereum.org auf dem Laufenden.",
+ "page-collectibles-social-instructions-1": "Treten Sie unserem Discord-Server bei",
+ "page-collectibles-social-instructions-2": "Zeitplan ansehen",
+ "page-collectibles-social-instructions-3": "Beitreten!",
+ "page-collectibles-social-title": "Sozial",
+ "page-collectibles-stats-collectors": "Sammler",
+ "page-collectibles-stats-minted": "Geprägt",
+ "page-collectibles-stats-unique-badges": "Einzigartige Abzeichen",
+ "page-collectibles-translations-1000": "Abzeichen für 1.000 Wörter",
+ "page-collectibles-translations-10000": "Abzeichen für 10.000 Wörter",
+ "page-collectibles-translations-250": "Abzeichen für 250 Wörter",
+ "page-collectibles-translations-50000": "Abzeichen für 50.000 Wörter",
+ "page-collectibles-translations-badge-desc": "In jede Sprache.",
+ "page-collectibles-translations-desc": "Die meisten Benutzer sprechen kein Englisch, daher ist es wichtig, bei der Übersetzung unserer Artikel in andere Sprachen zu helfen. Es ist keine Übersetzungserfahrung erforderlich.",
+ "page-collectibles-translations-instructions-1": "Registrieren Sie sich auf Crowdin",
+ "page-collectibles-translations-instructions-2": "Sprache auswählen",
+ "page-collectibles-translations-instructions-3": "Mit dem Übersetzen beginnen",
+ "page-collectibles-translations-title": "Übersetzungen"
+}
diff --git a/src/intl/de/page-community-events.json b/src/intl/de/page-community-events.json
index c52fa7cbf1c..2fc16610010 100644
--- a/src/intl/de/page-community-events.json
+++ b/src/intl/de/page-community-events.json
@@ -75,7 +75,6 @@
"page-events-tag-hackathon": "Hackathon",
"page-events-tag-meetup": "Meetup",
"page-events-tag-popup": "Popup",
- "page-events-tag-regional": "Regional",
"page-events-tag-group": "Gruppe",
"page-events-tag-other": "Andere",
"page-events-tag-cowork": "Cowork",
diff --git a/src/intl/de/page-community.json b/src/intl/de/page-community.json
index bcdfdc7f048..387a69d9304 100644
--- a/src/intl/de/page-community.json
+++ b/src/intl/de/page-community.json
@@ -7,16 +7,19 @@
"page-community-card-3-description": "Auf der Seite „So können Sie sich engagieren“ finden Sie eine Liste mit Möglichkeiten, wie Sie sich je nach Ihren Fähigkeiten und Ihrem beruflichen Hintergrund einbringen können.",
"page-community-card-4-title": "Nach Zuschüssen suchen",
"page-community-card-4-description": "Es gibt Fördergelder, die Ihnen helfen, ein Projekt auf den Weg zu bringen.",
+ "page-community-community-hub-list-h3": "Community-Hub",
+ "page-community-community-hub-list-cta-label-1": "Co-Working-Anmeldung",
+ "page-community-community-hub-list-cta-label-2": "Meetup",
"page-community-contribute": "Einen Beitrag für ethereum.org leisten",
"page-community-contribute-button": "Mehr zum Beitragen",
"page-community-contribute-description": "Für viele Menschen ist ethereum.org der erste Schritt in das Ökosystem. Die Site wird von Tausenden von Open-Source-Mitarbeitern auf dem laufenden Stand und genau gehalten. Möchten Sie helfen? Lesen Sie unseren Leitfaden zur Teilnahme oder erstellen Sie einen Beitrag auf GitHub.",
"page-community-contribute-secondary-button": "Auf GitHub anzeigen",
"page-community-daos-callout-title": "Dezentralisierte Autonome Organisationen (DAO)",
"page-community-daos-callout-description": "Diese Gruppen nutzen die Ethereum-Technologie, um die Organisation und Zusammenarbeit zu erleichtern. Zum Beispiel, um die Mitgliedschaft zu kontrollieren, über Vorschläge abzustimmen oder gepooltes Vermögen zu verwalten.",
- "page-community-explore-dapps": "dApps entdecken",
- "page-community-explore-dapps-alt": "dApps entdecken",
- "page-community-explore-dapps-description": "dApps sind Anwendungen, die auf Ethereum basieren. dApps verändern aktuelle Geschäftsmodelle und erfinden neue.",
- "page-community-explore-dapps-title": "Ein paar dApps testen",
+ "page-community-explore-dapps": "DApps entdecken",
+ "page-community-explore-dapps-alt": "DApps entdecken",
+ "page-community-explore-dapps-description": "DApps sind Anwendungen, die auf Ethereum basieren. DApps verändern aktuelle Geschäftsmodelle und erfinden neue.",
+ "page-community-explore-dapps-title": "Ein paar DApps testen",
"page-community-explore-grants": "Zuschüsse entdecken",
"page-community-find-a-job": "Einen Job finden",
"page-community-get-eth": "ETH erwerben",
@@ -32,7 +35,7 @@
"page-community-hero-title": "Der Community beitreten",
"page-community-meetuplist-no-meetups": "Wir haben keine Treffen, die zu dieser Suche passen. Kennen Sie eines?",
"page-community-meta-title": "Community-Hub",
- "page-community-meta-description": "Community-Homepage – Beschreibung",
+ "page-community-meta-description": "Community-Hub für das Ethereum-Ökosystem",
"page-community-open-source": "Creator? Builder? Lassen Sie sich für Ihre Arbeit bezahlen.",
"page-community-open-source-description": "Erstellen Sie auf Grundlage von Ethereum oder möchten Sie das tun? Unternehmen besetzen Tausende technische und nicht-technische Stellen. Haben Sie eine eigene Idee? Versuchen Sie, eine Förderung zu erhalten, um Ihr Projekt auf den Weg zu bringen.",
"page-community-open-source-image-alt": "Lassen Sie sich für Ihre Arbeit bezahlen",
@@ -44,11 +47,18 @@
"page-community-try-ethereum": "Probieren Sie Ethereum selbst aus",
"page-community-upcoming-events-no-events": "Uns sind keine bevorstehenden Veranstaltungen bekannt. Kennen Sie eine?",
"page-community-upcoming-events-load-more": "Mehr laden",
+ "page-community-upcoming-events-view-event": "Veranstaltung anzeigen",
"page-community-why-get-involved-title": "Warum sollten Sie sich engagieren?",
"page-community-why-get-involved-card-1-title": "Gleichgesinnte finden",
"page-community-why-get-involved-card-1-description": "Für jeden gibt es einen Ort zum Ankommen. Finden Sie Gleichgesinnte und schließen Sie sich zusammen, um gemeinsam über Ethereum zu diskutieren, nachzudenken und zu feiern.",
"page-community-why-get-involved-card-2-title": "Den Lebensunterhalt verdienen",
"page-community-why-get-involved-card-2-description": "Wir alle müssen unsere Rechnungen bezahlen. Ethereum ermöglicht es Ihnen, eine sinnvolle Arbeit zu finden und gut dafür bezahlt zu werden.",
"page-community-why-get-involved-card-3-title": "Einen Unterschied bewirken",
- "page-community-why-get-involved-card-3-description": "Wenn Sie sich mit Ethereum beschäftigen, können Sie aktiv an einer Technologie mitwirken, die positive Auswirkungen auf Millionen von Menschen hat."
+ "page-community-why-get-involved-card-3-description": "Wenn Sie sich mit Ethereum beschäftigen, können Sie aktiv an einer Technologie mitwirken, die positive Auswirkungen auf Millionen von Menschen hat.",
+ "page-index-internet-image-alt": "Abbildung eines futuristischen Computers, angetrieben von Ethereum-Kristallen.",
+ "page-index-get-started-image-alt": "Darstellung einer Person, die am Computer arbeitet.",
+ "page-index-get-started-wallet-image-alt": "Darstellung eines Roboters mit einem Tresor als Körper, der eine Ethereum-Wallet repräsentiert.",
+ "page-index-get-started-eth-image-alt": "Illustration einer Gruppe von Leuten, die eine ETH-Glyphe (Ether) bestaunen.",
+ "page-index-get-started-dapps-image-alt": "Illustration eines Doge, der einen Computer benutzt.",
+ "page-index-get-started-devs-image-alt": "Darstellung einer Hand, die ein ETH-Logo aus Legosteinen baut."
}
diff --git a/src/intl/de/page-contributing-translation-program-acknowledgements.json b/src/intl/de/page-contributing-translation-program-acknowledgements.json
index b0410f363a9..d355b3ccd5b 100644
--- a/src/intl/de/page-contributing-translation-program-acknowledgements.json
+++ b/src/intl/de/page-contributing-translation-program-acknowledgements.json
@@ -28,15 +28,15 @@
"page-contributing-translation-program-acknowledgements-translator": "Übersetzer:in",
"page-contributing-translation-program-acknowledgements-language": "Sprache",
"page-contributing-translation-program-acknowledgements-total-words": "Wörter gesamt",
- "page-contributing-translation-program-acknowledgements-oats-title": "POAPs",
- "page-contributing-translation-program-acknowledgements-1": "Alle unsere Übersetzerinnen und Übersetzer haben Anspruch auf ein POAP (Proof of Attendance Protocol) – ein Non Fungible Token, der ihre Teilnahme am Übersetzungprogramm von ethereum.org belegt.",
- "page-contributing-translation-program-acknowledgements-2": "Wir stellen verschiedene POAPs für Übersetzerinnen und Übersetzer zur Verfügung, die auf ihrer Tätigkeit basieren",
- "page-contributing-translation-program-acknowledgements-3": "Wenn Sie zu den Übersetzungsarbeiten in Crowdin beigetragen haben, wartet ein POAP auf Sie.",
+ "page-contributing-translation-program-acknowledgements-oats-title": "OATs",
+ "page-contributing-translation-program-acknowledgements-1": "Mitwirkende am Übersetzungsprogramm haben Anspruch auf verschiedene OTAs (Organ Agreement Tokens) – nicht fungible Token, die ihre Teilnahme am Übersetzungsprogramm von ethereum.org belegen.",
+ "page-contributing-translation-program-acknowledgements-2": "Wir bieten Übersetzern je nach ihrer Tätigkeit eine Reihe verschiedener OTAs an.",
+ "page-contributing-translation-program-acknowledgements-3": "Wenn Sie zu den Übersetzungsarbeiten in Crowdin beigetragen haben, wartet ein OAT auf Sie!",
"page-contributing-translation-program-acknowledgements-how-to-claim-title": "So beanspruchen Sie den NFT",
"page-contributing-translation-program-acknowledgements-how-to-claim-1": "Mitmachen",
"page-contributing-translation-program-acknowledgements-how-to-claim-1-discord": "Discord-Server",
- "page-contributing-translation-program-acknowledgements-how-to-claim-2": "Fügen Sie einen Link zu Ihrem Crowdin-Konto in den #🥇 | poaps Kanal hinzu.",
- "page-contributing-translation-program-acknowledgements-how-to-claim-3": "Warten Sie darauf, dass ein Mitglied unseres Teams Ihnen einen Link zu Ihrem POAP schickt.",
- "page-contributing-translation-program-acknowledgements-how-to-claim-4": "Beanspruchen Sie Ihr POAP",
- "page-contributing-translation-program-acknowledgements-4": "Sie sollten nur selbst verwahrte Wallets verwenden, um POAPs zu beanspruchen. Verwenden Sie keine Konten von Handelsplätzen oder andere Konten, für die Sie die privaten Schlüssel nicht besitzen, da Sie dann keinen Zugriff auf Ihre POAPs haben und sie nicht verwalten können."
+ "page-contributing-translation-program-acknowledgements-how-to-claim-2": "Fügen Sie einen Link zu Ihrem Crowdin-Konto in den Kanal #🥇pro-von-Kontributionenn ein.",
+ "page-contributing-translation-program-acknowledgements-how-to-claim-3": "Warten Sie, bis Ihnen ein Mitglied unseres Teams die erforderlichen Rollen zugewiesen hat, um Ihre OTAs zu beanspruchen.",
+ "page-contributing-translation-program-acknowledgements-how-to-claim-4": "Fordern Sie Ihre OTAs an!",
+ "page-contributing-translation-program-acknowledgements-4": "Sie sollten nur Wallets in Eigenverwahrung verwenden, um die OTAs zu beanspruchen. Verwenden Sie keine Börsenkonten oder andere Konten, für die Sie nicht die privaten Schlüssel besitzen, da Sie damit nicht auf Ihre OTAs zugreifen und diese verwalten können."
}
diff --git a/src/intl/de/page-contributing-translation-program-contributors.json b/src/intl/de/page-contributing-translation-program-contributors.json
index 96e98d4a787..0d54dd8547a 100644
--- a/src/intl/de/page-contributing-translation-program-contributors.json
+++ b/src/intl/de/page-contributing-translation-program-contributors.json
@@ -4,7 +4,7 @@
"page-contributing-translation-program-contributors-our-translators-1": "Die Community steht im Mittelpunkt des ethereum.org-Übersetzungsprogramms.",
"page-contributing-translation-program-contributors-our-translators-2": "Da Tausende von Community-Mitgliedern Übersetzungen zu unserem Projekt beisteuern, ist es schwierig, alle zu würdigen.",
"page-contributing-translation-program-contributors-our-translators-3": "Alle Übersetzerinnen und Übersetzer werden in Crowdin alphabetisch nach ihrem gewählten Namen aufgelistet. Wenn Sie Übersetzer:in sind und Ihren richtigen Namen, Spitznamen, ENS-Domain usw. verwenden möchten, können Sie Ihren vollständigen Namen in Crowdin ändern.",
- "page-contributing-translation-program-contributors-meta-title": "Unsere Übersetzungen",
+ "page-contributing-translation-program-contributors-meta-title": "Unsere Übersetzer",
"page-contributing-translation-program-contributors-meta-description": "Eine Liste unserer Übersetzerinnen und Übersetzer.",
"page-contributing-translation-program-contributors-number-of-contributors": "Anzahl der Mitwirkenden:"
}
diff --git a/src/intl/de/page-developers-docs.json b/src/intl/de/page-developers-docs.json
index 221acd1ae40..051c7ad892f 100644
--- a/src/intl/de/page-developers-docs.json
+++ b/src/intl/de/page-developers-docs.json
@@ -6,7 +6,7 @@
"docs-nav-block-explorers": "Block-Explorer",
"docs-nav-blocks": "Blöcke",
"docs-nav-blocks-description": "Die Art und Weise, wie Transaktionen zusammengefasst werden, um sicherzustellen, dass der Zustand über alle Akteure hinweg synchronisiert wird",
- "docs-nav-bridges": "Bridges",
+ "docs-nav-bridges": "Brücken",
"docs-nav-bridges-description": "Eine Übersicht über Bridging für Entwickler",
"docs-nav-compiling-smart-contracts": "Kompilieren von Smart Contracts",
"docs-nav-composability": "Zusammensetzbarkeit",
@@ -33,6 +33,7 @@
"docs-nav-development-networks-description": "Lokale Blockchain-Umgebungen zum Testen von dApps vor dem Deployment",
"docs-nav-dex-design-best-practice": "Bewährte Praktiken für das Design einer dezentralen Börse (DEX)",
"docs-nav-dot-net": ".NET",
+ "docs-nav-elixir": "Elixir",
"docs-nav-erc-20": "ERC-20: Fungible Tokens",
"docs-nav-erc-721": "ERC-721: NFTs",
"docs-nav-erc-777": "ERC-777",
@@ -62,10 +63,10 @@
"docs-nav-java-script-apis": "JavaScript-APIs",
"docs-nav-javascript": "JavaScript",
"docs-nav-json-rpc": "JSON-RPC",
- "docs-nav-mev": "Maximaler extrahierbarer Wert (MEV)",
+ "docs-nav-mev": "Maximal extrahierbarer Wert (MEV)",
"docs-nav-mev-description": "Wie der Wert aus der Ethereum-Blockchain über die Blockbelohnung hinaus gewonnen wird",
"docs-nav-mining": "Mining",
- "docs-nav-mining-algorithms": "Bergbau-Algorithmen",
+ "docs-nav-mining-algorithms": "Mining-Algorithmen",
"docs-nav-dagger-hashimoto": "Dagger-Hashimoto",
"docs-nav-ethash": "Ethash",
"docs-nav-networks": "Netzwerke",
@@ -82,6 +83,7 @@
"docs-nav-oracles-description": "Wie Informationen in die Ethereum-Blockchain eingefügt werden",
"docs-nav-programming-languages": "Programmiersprachen",
"docs-nav-programming-languages-description": "Wie man mit Ethereum mit Sprachen beginnt, die man vielleicht schon kennt",
+ "docs-nav-proof-of-authority": "Proof-of-Authority",
"docs-nav-proof-of-stake": "Proof-of-Stake",
"docs-nav-proof-of-work": "Proof-of-Work",
"docs-nav-python": "Python",
@@ -114,6 +116,7 @@
"docs-nav-transactions": "Transaktionen",
"docs-nav-transactions-description": "Transfers und andere Aktionen, die Ethereums Zustand ändern",
"docs-nav-upgrading-smart-contracts": "Aktualisierung von Smart Contracts",
+ "docs-nav-naming-smart-contracts": "Benennung von Smart Contracts",
"docs-nav-verifying-smart-contracts": "Überprüfen von Smart Contracts",
"docs-nav-web2-vs-web3": "Web2 vs Web3",
"docs-nav-web2-vs-web3-description": "Die grundlegenden Unterschiede, die blockchain-basierte Anwendungen bieten",
diff --git a/src/intl/de/page-developers-index.json b/src/intl/de/page-developers-index.json
index a35f46cf007..ffcbc3f05bc 100644
--- a/src/intl/de/page-developers-index.json
+++ b/src/intl/de/page-developers-index.json
@@ -1,46 +1,36 @@
{
"page-developer-meta-title": "Ethereum Entwickler-Ressourcen",
- "page-developers-about": "Über diese Entwickler-Ressourcen",
- "page-developers-about-desc": "ethereum.org hilft Ihnen, mit Ethereum zu bauen, mit Dokumentationen zu grundlegenden Konzepten sowie mit dem Entwicklungsstack. Außerdem gibt es Tutorials, die Ihnen den Einstieg erleichtern.",
- "page-developers-about-desc-2": "Inspiriert durch das Mozilla-Entwicklernetzwerk dachten wir, dass Ethereum einen Ort braucht, an dem großartige Inhalte und Ressourcen für Entwickler untergebracht werden. Wie bei unseren Freunden von Mozilla ist hier alles open-source und bereit für Sie, um es zu erweitern und zu verbessern.",
"page-developers-account-desc": "Verträge oder Personen im Netzwerk",
"page-developers-accounts-link": "Konten",
- "page-developers-advanced": "Fortgeschritten",
"page-developers-api-desc": "Verwendung von Bibliotheken zur Interaktion mit Smart Contracts",
"page-developers-api-link": "Backend-APIs",
"page-developers-block-desc": "Stapel von Transaktionen, die der Blockchain hinzugefügt werden",
"page-developers-block-explorers-desc": "Ihr Portal zu Ethereum-Daten",
"page-developers-block-explorers-link": "Block-Explorer",
"page-developers-blocks-link": "Blöcke",
- "page-developers-browse-tutorials": "Tutorials durchsuchen",
- "page-developers-choose-stack": "Wähle Deinen Stack",
- "page-developers-contribute": "Mitwirken",
- "page-developers-dev-env-desc": "IDEs, die für dApp-Entwicklung geeignet sind",
+ "page-developers-dev-env-desc": "IDEs, die für DApp-Entwicklung geeignet sind",
"page-developers-dev-env-link": "Entwicklungsumgebungen",
- "page-developers-discord": "Discord beitreten",
"page-developers-docs-introductions": "Einführung",
"page-developers-evm-desc": "Der Computer, der Transaktionen verarbeitet",
"page-developers-evm-link": "Die Ethereum Virtual Machine (EVM)",
"page-developers-explore-documentation": "Dokumentation erkunden",
- "page-developers-feedback": "Wenn Sie Feedback haben, wenden Sie sich bitte an uns über ein GitHub-Ticket oder auf unserem Discord-Server.",
"page-developers-frameworks-desc": "Werkzeuge zur Beschleunigung der Entwicklung",
"page-developers-frameworks-link": "Entwicklungs-Frameworks",
"page-developers-fundamentals": "Grundlagen",
"page-developers-gas-desc": "Ether wird zur Durchführung von Transaktionen benötigt",
"page-developers-gas-link": "Gas",
- "page-developers-get-started": "Wie möchten Sie beginnen?",
- "page-developers-improve-ethereum": "Hilf uns, ethereum.org besser zu machen",
- "page-developers-improve-ethereum-desc": "Wie ethereum.org sind auch diese Dokumente eine Gemeinschaftsanstrengung. Erstellen Sie eine PR, wenn Sie Fehler, Raum für Verbesserungen oder neue Möglichkeiten, Ethereum-Entwicklern zu helfen, bemerken.",
+ "page-developers-get-started": "Was möchtest du heute bauen?",
"page-developers-into-eth-desc": "Eine Einführung in Blockchain und Ethereum",
"page-developers-intro-ether-desc": "Eine Einführung zu Kryptowährungen und Ether",
"page-developers-intro-dapps-desc": "Eine Einführung in dezentralisierte Anwendungen",
- "page-developers-intro-dapps-link": "Einführung in dApps",
+ "page-developers-intro-dapps-link": "Einführung in DApps",
"page-developers-intro-eth-link": "Einführung in Ethereum",
"page-developers-intro-ether-link": "Einleitung zu Ether",
"page-developers-intro-stack": "Einführung in den Stack",
"page-developers-intro-stack-desc": "Eine Einführung in den Ethereum-Stack",
"page-developers-js-libraries-desc": "Javascript verwenden, um mit Smart Contracts zu interagieren",
"page-developers-js-libraries-link": "JavaScript-Bibliotheken",
+ "page-developers-jump-right-in-title": "Deine Idee schnell starten",
"page-developers-language-desc": "Verwende Ethereum mit vertrauten Sprachen",
"page-developers-languages": "Programmiersprachen",
"page-developers-learn": "Ethereum-Entwicklung lernen",
@@ -49,41 +39,32 @@
"page-developers-learn-tutorials-cta": "Tutorials anzeigen",
"page-developers-learn-tutorials-desc": "Lernen Sie die Entwicklung von Ethereum Schritt für Schritt von Buildern, die es bereits gemacht haben.",
"page-developers-meta-desc": "Dokumentation, Tutorials und Tools für Entwickler, die auf Ethereum bauen.",
- "page-developers-mev-desc": "Einführung in den maximal extrahierbaren Wert (MEV)",
- "page-developers-mev-link": "Maximal extrahierbarer Wert (MEV)",
- "page-developers-mining-desc": "Wie neue Blöcke erstellt werden und durch Proof-of-Work Konsens erreicht wird",
- "page-developers-mining-link": "Mining",
- "page-developers-mining-algorithms-desc": "Informationen zu den Mining-Algorithmen von Ethereum",
- "page-developers-mining-algorithms-link": "Mining-Algorithmen",
"page-developers-networks-desc": "Eine Übersicht über Mainnet und die Testnetzwerke",
"page-developers-networks-link": "Netzwerke",
"page-developers-node-clients-desc": "Wie Blöcke und Transaktionen im Netzwerk verifiziert werden",
"page-developers-node-clients-link": "Knotenpunkte und Clients",
- "page-developers-oracle-desc": "Off-Chain-Daten in Ihre Smart Contracts einbeziehen",
- "page-developers-oracles-link": "Oracles",
"page-developers-play-code": "Mit Code spielen",
+ "page-developers-quickstart-scaffold-subtext": "Stelle deinen Ethereum-App-Stack in Sekunden bereit.",
+ "page-developers-quickstart-scaffold-docs": "Lesen Sie Scaffold-ETH 2",
"page-developers-read-docs": "Dokumentation lesen",
- "page-developers-scaling-desc": "Lösungen für schnellere Transaktionen",
- "page-developers-scaling-link": "Skalierung",
+ "page-developers-start-quest": "Quest starten",
+ "page-developers-resources": "Ressourcen",
"page-developers-smart-contract-security-desc": "Sicherheitsmaßnahmen, die bei der Entwicklung von Smart Contracts zu berücksichtigen sind",
"page-developers-smart-contract-security-link": "Smart Contract – Sicherheit",
- "page-developers-set-up": "Lokale Umgebung einrichten",
- "page-developers-setup-desc": "Bereite durch das Konfigurieren der Entwicklerumgebung Deinen Stack für das Bauen vor.",
- "page-developers-smart-contracts-desc": "Die Logik hinter dApps – selbstausführende Vereinbarungen",
+ "page-developers-smart-contracts-desc": "Die Logik hinter DApps – selbstausführende Vereinbarungen",
"page-developers-smart-contracts-link": "Smart Contracts",
+ "page-developers-solidity-docs": "Lies die Solidity-Doks",
"page-developers-speedrunethereum-title": "Lernen Sie alle wichtigen Konzepte kennen und setzen Sie auf Ethereum",
+ "page-developers-speedrunethereum-description": "Lassen Sie sich von anderen betreuen und lernen Sie, wie Sie mit anderen Entwicklern zusammenarbeiten können.",
"page-developers-speedrunethereum-link": "SpeedRun Ethereum",
"page-developers-stack": "Der Stack",
- "page-developers-start": "Mit dem Experimentieren beginnen",
- "page-developers-start-desc": "Wollen Sie erst experimentieren und dann Fragen stellen?",
- "page-developers-storage-desc": "Wie man mit dem dApp-Speicher umgeht",
+ "page-developers-start": "Herausforderungen und Mentoring",
+ "page-developers-storage-desc": "Wie man mit dem DApp-Speicher umgeht",
"page-developers-storage-link": "Speicher",
- "page-developers-subtitle": "Ein Builder-Handbuch für Ethereum. Von Buildern, für Builder.",
+ "page-developers-subtitle": "Ein Handbuch für Entwickler von Ethereum. Alles, was Sie zum Erstellen und Skalieren Ihrer In-Klein-App benötigen.",
"page-developers-title-1": "Ethereum",
"page-developers-title-2": "Entwickler",
"page-developers-title-3": "Ressourcen",
- "page-developers-token-standards-desc": "Eine Übersicht der akzeptierten Tokenstandards",
- "page-developers-token-standards-link": "Tokenstandards",
"page-developers-transactions-desc": "Wie sich der Zustand von Ethereum ändert",
"page-developers-transactions-link": "Transaktionen",
"page-developers-web3-desc": "Wie sich die web3-Welt der Entwicklung unterscheidet",
@@ -95,5 +76,57 @@
"page-developers-data-structures-and-encoding-link": "Datenstrukturen und Kodierung",
"page-developers-data-structures-and-encoding-desc": "Einführung in die Datenstrukturen und das Kodierungsschema des Ethereum-Stacks",
"alt-eth-blocks": "Illustration von Blöcken, die wie ein ETH-Symbol angeordnet sind",
- "page-assets-doge": "Doge nutzt dApps"
+ "page-assets-doge": "Doge nutzt dApps",
+ "page-developers-build-section-desc": "Alles, was Sie brauchen, um Ihre ersten Apps auf Ethereum zu entwickeln und zu erstellen.",
+ "page-developers-resources-section-title": "Hilfreiche Ressourcen für Entwickler",
+ "page-developers-get-help-title": "Hilfe erhalten",
+ "page-developers-get-help-desc": "Wenn Sie nicht weiterkommen oder Hilfe bei der Lösung von Problemen benötigen, fragen Sie unbedingt um Rat.",
+ "page-developers-stack-exchange": "Stapelaustausch",
+ "page-developers-ask-ai": "Fragen Sie die KI",
+ "page-developers-resources-title": "Ressourcen",
+ "page-developers-resources-desc": "Möchten Sie zuerst experimentieren und später Fragen stellen? Informieren Sie sich über Sandboxes, Bootcamps usw.",
+ "page-developers-tutorials-title": "Lernprogramme",
+ "page-developers-tutorials-desc": "Lernen Sie die Entwicklung von Ethereum Schritt für Schritt von Buildern, die es bereits gemacht haben.",
+ "page-developers-video-courses-title": "Videokurse",
+ "page-developers-video-courses-desc": "Möchten Sie Ihre berufliche Karriere im Bereich Blockchain starten? Diese Kurse bereiten Sie darauf vor, als Blockchain-Entwickler eingestellt zu werden.",
+ "page-developers-docs-section-desc": "Die grundlegenden Konzepte von Ethereum und Blockchains verstehen",
+ "page-developers-hackathons-title": "Mach bei Hackathons mit! ",
+ "page-developers-hackathons-desc": "Bei Hackathons kann man nicht nur wertvolle Kontakte knüpfen und von anderen lernen, sondern auch eigene Projekte ins Leben rufen und Preise gewinnen. ",
+ "page-developers-visit-ethglobal": "Besuche EthGlobal",
+ "page-developers-founders-title": "Bist du ein Gründer?",
+ "page-developers-founders-desc": "Besteht schon eine Projektidee oder ist bereits ein Prototyp in Arbeit? Entdecke, wie du dein Projekt aufs nächste Level bringen kannst. Wir bringen dich mit den passenden Organisationen und Fachexpterten zusammen.",
+ "page-developers-get-in-touch": "Kontaktieren Sie uns",
+ "page-developers-see-grant-options": "Entdecke die Fördermöglichkeiten",
+ "page-developers-speedrun-nft-alt": "Speedrun Ethereum Tokenisierungs-Banner",
+ "page-developers-speedrun-nft-title": "Tokenisierung",
+ "page-developers-speedrun-nft-desc": "Erstelle einen einzigartigen Token, um die Grundlagen von scaffold-eth zu lernen.",
+ "page-developers-skill-beginner": "Anfänger",
+ "page-developers-skill-intermediate": "Fortgeschritten",
+ "page-developers-skill-advanced": "Fortgeschritten",
+ "page-developers-speedrun-dex-alt": "Speedrun Ethereum DEX-Banner",
+ "page-developers-speedrun-dex-title": "DEX",
+ "page-developers-speedrun-dex-desc": "Erstelle einen einfachen automatisierten Market Maker, stelle Liquidität bereit und implementiere Token-Swaps.",
+ "page-developers-speedrun-stablecoins-alt": "Speedrun Ethereum Stablecoins-Banner",
+ "page-developers-speedrun-stablecoins-title": "Stablecoins",
+ "page-developers-speedrun-stablecoins-desc": "Entwickle einen Stablecoin und lerne Stabilitätsmechanismen sowie Preisorakel kennen.",
+ "page-developers-course-duration": "-Lehrgang",
+ "page-developers-course-blockchain-basics-title": "Einführung in die Blockchain",
+ "page-developers-course-blockchain-basics-desc": "Erfahren Sie, wie Blockchains und Smart Contracts funktionieren, erstellen Sie eine Wallet und unterzeichnen Sie Ihre erste Transaktion.",
+ "page-developers-course-blockchain-basics-alt": "Cyfrin Updraft: Blockchain-Grundlagenkurs-Banner",
+ "page-developers-course-solidity-title": "Smart Contracts mit Solidity entwickeln",
+ "page-developers-course-solidity-desc": "Mit Solidity findest du den Weg in die Welt der Web3-Entwicklung für Ethereum und mit Ethereum kompatiblen Ökosystemen.",
+ "page-developers-course-solidity-alt": "Cyfrin Updraft: Banner zum Solidity-Entwicklerkurs",
+ "page-developers-course-foundry-fundamentals-title": "Grundlegendes zu Foundry",
+ "page-developers-course-foundry-fundamentals-desc": "Vertiefe deine Kenntnisse in der Solidity-Entwicklung mit Foundry und lerne fortgeschrittene Konzepte und Tools für Web3 kennen.",
+ "page-developers-course-foundry-fundamentals-alt": "Cyfrin Updraft: Foundry-Grundlagenkurs-Banner",
+ "page-developers-course-advanced-foundry-title": "Foundry für Fortgeschrittene",
+ "page-developers-course-advanced-foundry-desc": "Meister die Technik der professionellen Web3-Entwicklung mit Foundry und fortgeschrittenen Konzepten für Smart Contracts mit Solidity.",
+ "page-developers-course-advanced-foundry-alt": "Cyfrin Updraft: Banner zum Foundry Kurs für Fortgeschrittene",
+ "page-developers-course-security-title": "Sicherheit von Smart Contracts",
+ "page-developers-course-security-desc": "Dein Weg zum Smart Contract Security Researches! Lerne alles über das Analysieren von Smart Contracts und die wichtigsten Best Practices der Branche.",
+ "page-developers-course-security-alt": "Cyfrin Updraft: Blockchain-Grundlagenkurs-Banner",
+ "page-developers-why-title": "Werde gut bezahlt. Arbeite remote. Gestalte die Zukunft.",
+ "page-developers-why-subtitle": "Über die Hälfte der Karrieren im Blockchain-Bereich sind „Remote-First“, wobei einige Schätzungen von bis zu 70 % ausgehen.",
+ "page-developers-why-avg-salary-dev": "Durchschnittliches Entwicklergehalt",
+ "page-developers-why-avg-salary-blockchain": "Durchschnittsgehalt in der Blockchain-Branche"
}
diff --git a/src/intl/de/page-developers-learning-tools.json b/src/intl/de/page-developers-learning-tools.json
index a0d54d1a5ac..dce3578dc6a 100644
--- a/src/intl/de/page-developers-learning-tools.json
+++ b/src/intl/de/page-developers-learning-tools.json
@@ -2,7 +2,7 @@
"page-learning-tools-bloomtech-description": "Der BloomTech Web3-Kurs vermittelt Ihnen die Fähigkeiten, die Arbeitgeber bei Ingenieuren suchen.",
"page-learning-tools-bloomtech-logo-alt": "BloomTech-Logo",
"page-learning-tools-bootcamps": "Entwickler-Bootcamps",
- "page-learning-tools-bootcamps-desc": "Bezahlte Online-Kurse, um sich schnell auf den aktuellen Stand zu bringen.",
+ "page-learning-tools-bootcamps-desc": "Kostenlose oder kostenpflichtige Online-Kurse, um dich schnell auf den neuesten Stand zu bringen.",
"page-learning-tools-browse-docs": "Dokumente durchsuchen",
"page-learning-tools-capture-the-ether-description": "Capture the Ether ist ein Spiel, in dem Sie Smart Contracts auf Ethereum hacken, um mehr über Sicherheit zu lernen.",
"page-learning-tools-capture-the-ether-logo-alt": "Erobern Sie das Ether-Logo",
@@ -58,5 +58,7 @@
"page-learning-tools-learnweb3-logo-alt": "LearnWeb3-Logo",
"page-learning-tools-cyfrin-updraft-description": "Erlernen Sie die Entwicklung von Smart Contracts für alle Fähigkeitsstufen sowie Sicherheitsüberprüfungen.",
"page-learning-tools-cyfrin-updraft-logo-alt": "Cyfrin Updraft-Logo",
+ "page-learning-tools-price-free": "Kostenlos",
+ "page-learning-tools-price-paid": "Kostenpflichtig",
"alt-eth-blocks": "Illustration von Blöcken, die wie ein ETH-Symbol angeordnet sind"
}
diff --git a/src/intl/de/page-developers-local-environment.json b/src/intl/de/page-developers-local-environment.json
index 0db4e66fbe9..06db5c8b28e 100644
--- a/src/intl/de/page-developers-local-environment.json
+++ b/src/intl/de/page-developers-local-environment.json
@@ -15,7 +15,7 @@
"page-local-environment-framework-feature-4": "Konfiguration für die Verbindung zu Ethereum-Netzwerken und dem Einsatz von Verträgen, sei es zu einer lokal laufenden Instanz oder zu einem öffentlichen Netzwerk von Ethereum.",
"page-local-environment-framework-feature-5": "Dezentralisierte App-Verteilung – Integration mit Speicheroptionen wie IPFS.",
"page-local-environment-framework-features": "Diese Frameworks verfügen über eine Vielzahl von Funktionen, wie zum Beispiel:",
- "page-local-environment-frameworks-desc": "Wir empfehlen, ein Framework auszuwählen, besonders wenn Sie gerade erst anfangen. Das Aufbauen einer vollwertigen dApp erfordert unterschiedliche Technologien. Frameworks enthalten viele der benötigten Funktionen oder bieten einfache Plugin-Systeme, um die gewünschten Werkzeuge auszuwählen.",
+ "page-local-environment-frameworks-desc": "Wir empfehlen, ein Framework auszuwählen, besonders wenn Sie gerade erst anfangen. Das Aufbauen einer vollwertigen DApp erfordert unterschiedliche Technologien. Frameworks enthalten viele der benötigten Funktionen oder bieten einfache Plugin-Systeme, um die gewünschten Werkzeuge auszuwählen.",
"page-local-environment-frameworks-title": "Frameworks und vorgefertigte Stacks",
"page-local-environment-hardhat-desc": "Hardhat ist eine Ethereum-Entwicklungsumgebung für Profi-Anwender.",
"page-local-environment-hardhat-logo-alt": "Hardhat-Logo",
@@ -28,6 +28,6 @@
"page-local-environment-setup-subtitle": "Wenn Sie bereit sind, mit der Entwicklung zu beginnen, ist es Zeit, Ihren Stack auszuwählen.",
"page-local-environment-setup-subtitle-2": "Hier sind die Werkzeuge und Frameworks, die Sie zum Aufbau Deiner Ethereum-Anwendung verwenden können.",
"page-local-environment-setup-title": "Richten Sie Ihre lokale Entwicklungsumgebung ein",
- "page-local-environment-solidity-template-desc": "Eine GitHub-Vorlage für eine vorgefertigte Einrichtung für Ihre Solidity-Smart-Contracts. Enthält ein lokales Hardhat-Netzwerk, Ethers für die Wallet-Implementierung und mehr.",
+ "page-local-environment-solidity-template-desc": "Ein GitHub-Template für eine vorbereitete Entwicklungsumgebung für deine Solidity-Smart-Contracts. Enthält ein Hardhat-Localnetzwerk, Ethers zur Wallet-Implementierung und vieles mehr.",
"page-local-environment-solidity-template-logo-alt": "Solidity-Vorlagen-Logo"
}
diff --git a/src/intl/de/page-developers-tutorials.json b/src/intl/de/page-developers-tutorials.json
index 6d5d6c88255..8e20e669d06 100644
--- a/src/intl/de/page-developers-tutorials.json
+++ b/src/intl/de/page-developers-tutorials.json
@@ -1,17 +1,22 @@
{
"comp-tutorial-metadata-minute-read": "Minuten Lesedauer",
- "page-tutorial-listing-policy-intro": "Bevor du ein Tutorial einreichst, lies bitte unsere Veröffentlichungsrichtlinien.",
+ "page-tutorial-listing-policy-intro": "Bevor du ein Tutorial einreichst, lies bitte unsere Veröffentlichungsrichtlinien.",
"comp-tutorial-metadata-tip-author": "Tipp-Autor",
+ "page-tutorial-create-an-issue": "Eintrag erstellen",
+ "page-tutorial-create-an-issue-desc": "Fülle die Issue-Vorlage aus, um dein Tutorial zu beschreiben.",
"page-tutorial-raise-issue-btn": "Problem ansprechen",
"page-tutorial-read-time": "min",
"page-tutorial-submit-btn": "Tutorial einreichen",
- "page-tutorial-submit-tutorial": "Um ein Tutorial einzureichen, musst du GitHub verwenden. Nutze dafür gern die Optionen Issue und Pull-Request.",
"page-tutorial-subtitle": "Willkommen zu unserer kuratierten Liste der Community-Tutorials.",
- "page-tutorial-tags-error": "Kein Tutorial hat alle diese Tags",
+ "page-tutorial-tags-error": "Es gibt noch keine Tutorials mit allen von dir gewählten Tags.",
"page-tutorial-title": "Ethereum-Entwicklungsanleitungen",
"page-tutorials-meta-description": "Durchsuche und filtere geprüfte Ethereum Community-Tutorials nach Themen.",
"page-tutorial-external-link": "Extern",
"page-tutorials-meta-title": "Ethereum Community-Tutorials",
+ "page-tutorial-beginner": "Anfänger",
+ "page-tutorial-intermediate": "Fortgeschritten",
+ "page-tutorial-advanced": "Fortgeschritten",
"page-find-wallet-try-removing": "Versuchen Sie ein oder zwei Funktionen zu entfernen",
- "page-find-wallet-clear": "Filter aufheben"
+ "page-find-wallet-clear": "Filter aufheben",
+ "page-tutorials-env-banner": "Führe .env nicht aus! Es wird dringend davon abgeraten, Deine persönlichen Daten, die in dieser Datei.env enthalten sind, auszustellen oder sie mit anderen Personen zu teilen, da dies die Vertraulichkeit Deiner persönlichen Daten gefährden könnte. Wenn eine Systemsteuerung schon vorhanden ist, füge in die Datei gitignore Deinen.env ein."
}
diff --git a/src/intl/de/page-energy-consumption.json b/src/intl/de/page-energy-consumption.json
new file mode 100644
index 00000000000..1f69a562eb7
--- /dev/null
+++ b/src/intl/de/page-energy-consumption.json
@@ -0,0 +1,21 @@
+{
+ "adoption-chart-artists-label": "Künstler:innen",
+ "adoption-chart-column-now-label": "Gerade",
+ "adoption-chart-companies-label": "Unternehmen",
+ "adoption-chart-developers-label": "Entwickler",
+ "adoption-chart-gamers-label": "Gamer",
+ "adoption-chart-investors-label": "Investoren",
+ "adoption-chart-musicians-label": "Musiker:innen",
+ "adoption-chart-refugees-label": "Flüchtlinge",
+ "adoption-chart-writers-label": "Autor:innen",
+ "energy-consumption-chart-airbnb-label": "AirBnB",
+ "energy-consumption-chart-btc-pow-label": "BTC PoW",
+ "energy-consumption-chart-eth-pos-label": "ETH PoS",
+ "energy-consumption-chart-eth-pow-label": "ETH PoW",
+ "energy-consumption-chart-gaming-us-label": "Gaming in den USA",
+ "energy-consumption-chart-global-data-centers-label": "Globale Rechenzentren",
+ "energy-consumption-chart-netflix-label": "Netflix",
+ "energy-consumption-chart-paypal-label": "PayPal",
+ "energy-consumption-gold-mining-cbeci-label": "Goldabbau",
+ "energy-consumption-chart-legend": "Jährlicher Energieverbrauch in TWh/Jahr"
+}
diff --git a/src/intl/de/page-ethereum-history-founder-and-ownership.json b/src/intl/de/page-ethereum-history-founder-and-ownership.json
new file mode 100644
index 00000000000..882bf301f7b
--- /dev/null
+++ b/src/intl/de/page-ethereum-history-founder-and-ownership.json
@@ -0,0 +1,65 @@
+{
+ "page-ethereum-history-founder-and-ownership-meta-title": "Geschichte von Ethereum: Gründer, Start und Eigentümerschaft | ethereum.org",
+ "page-ethereum-history-founder-and-ownership-meta-description": "Erfahren Sie mehr über die Geschichte von Ethereum, einschließlich wer es erschaffen hat, wann es gestartet wurde und wer es heute kontrolliert.",
+ "page-ethereum-history-founder-and-ownership-twitter-meta-description": "Erfahren Sie mehr über die Unterschiede zwischen Bitcoin und Ethereum, einschließlich Anwendungsfällen, Netzwerkleistung, Token-Ökonomie und mehr.",
+ "page-ethereum-history-founder-and-ownership-title": "Geschichte von Ethereum: Gründer, Start und Eigentümerschaft",
+ "page-ethereum-history-founder-and-ownership-description-1": "Ethereum wurde 2013 von Vitalik Buterin gegründet. Später kamen mehrere Mitbegründer hinzu, darunter Gavin Wood und Joseph Lubin. Das Ethereum-Netzwerk wurde offiziell am 30. Juli 2015 mit dem Mining des ersten Blocks (dem Genesis-Block) gestartet.",
+ "page-ethereum-history-founder-and-ownership-who-founded-ethereum-description-1": "Im Gegensatz zu traditionellen Organisationen hat Ethereum keinen CEO, keinen Vorstand und keine einzelne kontrollierende Partei. Es ist eine dezentralisierte Plattform, die von ihrer Community verwaltet wird, wobei die gemeinnützige Ethereum Foundation Unterstützung leistet.",
+ "page-ethereum-history-founder-and-ownership-who-founded-ethereum": "Wer hat Ethereum gegründet/mitgegründet?",
+ "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-description-1": "Ethereum wurde von Vitalik Buterin gegründet, der die Idee Ende 2013 konzipierte.",
+ "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-description-2": "Buterin wurde 1994 in Russland geboren und wuchs in Kanada auf. Er zeigte schon in jungen Jahren ein außergewöhnliches mathematisches Talent.",
+ "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-description-3": "Er entdeckte Bitcoin 2011 und begann, Bitcoin-Artikel zu schreiben, was ihn 2012 zur Mitgründung des Bitcoin Magazine führte. Dies war eine der ersten Veröffentlichungen, die sich der Kryptowährung widmete. Als Teil der frühen Bitcoin-Community erlebte er aus erster Hand ihr Potenzial und ihre Grenzen.",
+ "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-description-4": "2014 veröffentlichte Vitalik das Ethereum Whitepaper , in dem er eine Plattform skizzierte, die über Bitcoin hinausgehen sollte, indem sie eine Blockchain schuf, die mehr als nur Zahlungen abwickeln konnte.",
+ "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-description-5": "Ethereum erweitert den Bitcoin-Ansatz und sagt im Grunde: Nun, anstatt Regeln zu haben, die darauf ausgelegt sind, eine einzige Anwendung zu unterstützen, werden wir etwas Allgemeineres schaffen, bei dem die Leute einfach ihre eigenen Anwendungen entwickeln können, und die Regeln für die von ihnen entwickelten Anwendungen können auf der Ethereum-Plattform ausgeführt und implementiert werden.",
+ "page-ethereum-history-founder-and-ownership-when-ethereum-when-did-ethereum-launch": "Wann wurde Ethereum gestartet?",
+ "page-ethereum-history-founder-and-ownership-who-owns-and-runs-ethereum-now": "Wem gehört Ethereum heute und wer betreibt es?",
+ "page-ethereum-history-founder-and-ownership-founder-of-ethereum": "Gründer von Ethereum",
+ "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-description-6": "Ethereum wurde von 8 Personen mitbegründet, die halfen, Ethereum ins Leben zu rufen.",
+ "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-vitalik-buterin": "Vitalik Buterin: Konzipierte Ethereum 2013, verfasste das ursprüngliche Whitepaper und wurde zu dessen Hauptvisionär und Verfechter, indem er das Konzept eines dezentralen Weltcomputers formulierte und die technische und philosophische Ausrichtung des Protokolls leitete.",
+ "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-gavin-wood": "Gavin Wood: Entwickelte die Programmiersprache Solidity und schrieb das Ethereum Yellow Paper , das technische Handbuch für die Ethereum Virtual Machine (EVM).",
+ "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-joseph-lubin": "Joseph Lubin: Half bei der Finanzierung der sehr frühen Phasen von Ethereum und gründete später ConsenSys , ein Unternehmen, das sich auf die Entwicklung von Ethereum-basierten Apps und Infrastruktur konzentriert.",
+ "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-jeffrey-wilcke": "Jeffrey Wilcke: Erstellte Geth , den ursprünglichen und am weitesten verbreiteten Ethereum Execution Client, der für die Ausführung der EVM und die Speicherung von Daten des Ethereum-Netzwerks verantwortlich ist.",
+ "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-mihai-alisie": "Mihai Alisie: Mitbegründer des Bitcoin Magazine zusammen mit Vitalik Buterin, half bei der Gründung der Ethereum Foundation in der Schweiz, war als Vizepräsident tätig und schuf den rechtlichen Rahmen für den Vorverkauf von Ether.",
+ "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-anthony-di-lorio": "Anthony Di Lorio",
+ "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-amir-chetrit": "Amir Chetrit",
+ "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-charles-hoskinson": "Charles Hoskinson",
+ "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-description-7": "Heute ist Vitalik Buterin weiterhin aktiv an der Entwicklung von Ethereum beteiligt. Joseph Lubin leitet weiterhin ConsenSys. Sein Unternehmen entwickelt wichtige Werkzeuge für das Ethereum-Ökosystem wie MetaMask und Infura.",
+ "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-1": "Der Weg von Vitaliks ursprünglicher Idee bis zum offiziellen Start von Ethereum dauerte etwa 20 Monate. Hier sind die wichtigsten Meilensteine:",
+ "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-2": "November 2013: Vitalik Buterin teilt das Ethereum Whitepaper. Es beschreibt seine Vision einer Blockchain-Plattform, die Smart Contracts ausführen kann.",
+ "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-3": "Januar 2014: Vitalik kündigt öffentlich das Konzept für Ethereum auf der North American Bitcoin Conference in Miami an.",
+ "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-4": "Juli–August 2014: Um die Entwicklung von Ethereum zu finanzieren, führte das Gründerteam eine öffentliche Crowdfunding-Kampagne durch. Sie sammelten 31.000 BTC (im damaligen Wert von etwa 18 Millionen $) als Gegenleistung für Ether (ETH).",
+ "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-5": "April 2015: Vitalik und die Mitbegründer starten das Olympic-Testnet von Ethereum. Dies war die letzte Testphase vor dem Start des Hauptnetzwerks.",
+ "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-6": "30. Juli 2015: Das Gründerteam startet offiziell das Ethereum Mainnet durch das Mining des Genesis-Blocks. Dies markiert die Geburtsstunde des Ethereum-Netzwerks.",
+ "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-7": "14. März 2016: Die Ethereum-Community implementiert „Homestead“, das erste geplante Upgrade. Dies signalisiert, dass Ethereum für die breite Akzeptanz bereit war.",
+ "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-8": "Wir hatten bei dem Ethereum-Projekt die Vorstellung, dass wir nur eine einzige Chance dafür bekommen würden, es war wirklich alles oder nichts, also mussten wir es richtig machen.",
+ "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-9": "Ethereum-Mitbegründer",
+ "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-10": "Der Start von Ethereum markierte einen wichtigen Meilenstein in der Blockchain-Technologie. Er führte Smart Contracts ein und schuf eine Plattform für dezentralisierte Anwendungen.",
+ "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-11": "Sie können den Ethereum Genesis-Block jederzeit ansehen und so den Moment bewahren, in dem Ethereum zum ersten Mal zum Leben erweckt wurde.",
+ "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-12": "Sehen Sie sich die vollständige Liste der Ethereum-Upgrades an",
+ "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-13": "Sehen Sie sich die zukünftige Ethereum-Roadmap an",
+ "page-ethereum-history-founder-and-ownership-who-owns-and-runs-ethereum-now-description-1": "Einer der einzigartigsten Aspekte von Ethereum ist seine Eigentümerstruktur, oder genauer gesagt, das Fehlen traditioneller Eigentumsverhältnisse. Im Gegensatz zu einem normalen Unternehmen, Ethereum:",
+ "page-ethereum-history-founder-and-ownership-who-owns-and-runs-ethereum-now-description-2": "hat keinen CEO oder eine zentrale Autorität",
+ "page-ethereum-history-founder-and-ownership-who-owns-and-runs-ethereum-now-description-3": "steht nicht unter der Kontrolle einer einzelnen Entität oder Organisation",
+ "page-ethereum-history-founder-and-ownership-who-owns-and-runs-ethereum-now-description-4": "hat keine Aktionäre im traditionellen Sinne",
+ "page-ethereum-history-founder-and-ownership-who-owns-and-runs-ethereum-now-description-5": "Stattdessen funktioniert Ethereum als dezentralisiertes Netzwerk. Es wird von Tausenden von unabhängigen Computern (Knoten) auf der ganzen Welt gewartet. Dieses dezentrale Modell ist der Kern des Designs und des Werts von Ethereum.",
+ "page-ethereum-history-founder-and-ownership-who-owns-and-runs-ethereum-now-description-6": "Mehrere wichtige Gruppen helfen bei der laufenden Entwicklung und Governance von Ethereum:",
+ "page-ethereum-history-founder-and-ownership-ethereum-foundation": "1. Die Ethereum Foundation",
+ "page-ethereum-history-founder-and-ownership-ethereum-foundation-description-1": "Die Ethereum Foundation ist eine gemeinnützige Organisation, die Ethereum und verwandte Technologien unterstützt. Obwohl sie wichtig ist, kontrolliert sie das Netzwerk nicht. Die Stiftung:",
+ "page-ethereum-history-founder-and-ownership-ethereum-foundation-description-2": "Verwaltet Gelder zur Unterstützung der Ethereum-Entwicklung",
+ "page-ethereum-history-founder-and-ownership-ethereum-foundation-description-3": "Vergibt Zuschüsse an Projekte, die auf Ethereum aufbauen",
+ "page-ethereum-history-founder-and-ownership-ethereum-foundation-description-4": "Organisiert Community-Events und Bildungsinitiativen",
+ "page-ethereum-history-founder-and-ownership-ethereum-foundation-description-5": "Koordiniert Forschungsbemühungen",
+ "page-ethereum-history-founder-and-ownership-core-developers": "2. Kernentwickler und Forscher",
+ "page-ethereum-history-founder-and-ownership-core-developers-description-1": "Eine globale Gemeinschaft von Entwicklern und Forschern trägt zum Code und Design von Ethereum bei. Diese Mitwirkenden schlagen Verbesserungen in einem offenen, öffentlichen Prozess vor, diskutieren und implementieren sie. Vitalik Buterin genießt in der Community nach wie vor hohes Ansehen, Entscheidungen werden jedoch durch Gruppenkonsens und nicht von einer einzelnen Person getroffen.",
+ "page-ethereum-history-founder-and-ownership-eip": "3. Ethereum-Verbesserungsvorschläge (EIPs)",
+ "page-ethereum-history-founder-and-ownership-eip-description-1": "Die Ethereum-Community schlägt Änderungen am Netzwerk durch Ethereum-Verbesserungsvorschläge (EIPs) vor. Dieses offene System ermöglicht es jedem, Verbesserungen vorzuschlagen. Diese Ideen werden dann von der Community diskutiert, verfeinert und potenziell umgesetzt.",
+ "page-ethereum-history-founder-and-ownership-validators": "4. Knotenbetreiber und Validatoren",
+ "page-ethereum-history-founder-and-ownership-validators-description-1": "Seit der Umstellung von Ethereum auf Proof-of-Stake im September 2022 wird das Netzwerk von Validatoren gesichert, die ETH sperren (staken) und Transaktionen verarbeiten. Es gibt eine große Anzahl von Validatoren , die auf der ganzen Welt verteilt sind, was die Kontrolle über das Netzwerk weit verteilt.",
+ "page-ethereum-history-founder-and-ownership-validators-description-2": "Dieses dezentrale Modell begrenzt die Kontrolle durch eine einzelne Entität und macht Ethereum widerstandsfähig gegen Zensur. Dies schließt seine ursprünglichen Gründer ein. Keine einzelne Person oder Organisation kann die Regeln von Ethereum ändern oder das Netzwerk im Alleingang abschalten.",
+ "page-ethereum-history-founder-and-ownership-validators-description-3": "Der Kernunterschied zwischen der Entwicklung einer Anwendung auf Ethereum und der Entwicklung auf einer traditionellen, zentralisierten Plattform ist diese Kernidee: Sobald Sie Ihre Anwendung erstellt haben, ist sie für ihr Fortbestehen nicht mehr von Ihnen oder einer anderen Einzelperson abhängig. Und die Anwendung läuft garantiert nach den festgelegten Regeln weiter.",
+ "page-ethereum-history-founder-and-ownership-conclusion": "Zusammenfassung",
+ "page-ethereum-history-founder-and-ownership-conclusion-description-1": "Von seiner Erschaffung durch Vitalik Buterin im Jahr 2013 über seinen Start im Jahr 2015 bis zu seinem heutigen Wachstum ist Ethereum seiner Gründungsvision treu geblieben. Es bleibt eine dezentrale, glaubwürdig neutrale Plattform für Anwendungen, die genau wie programmiert ausgeführt werden. Das Netzwerk und die darauf aufbauenden Apps laufen ohne Ausfallzeiten, Zensur, Betrug oder Einmischung Dritter.",
+ "page-ethereum-history-founder-and-ownership-conclusion-description-2": "Die Geschichte von Ethereum entfaltet sich mit jedem Update und jeder Innovation weiter. Während sich das Netzwerk weiterentwickelt, veranschaulicht es, wie dezentrale Governance den technologischen Fortschritt ohne traditionelle Unternehmensstrukturen vorantreiben kann.",
+ "page-ethereum-history-founder-and-ownership-conclusion-description-3": "Ethereum hat sich von einem visionären Whitepaper zu einer globalen Infrastrukturschicht entwickelt, die Tausende von Anwendungen und Werte in Milliardenhöhe antreibt. Dies beweist, dass offene Zusammenarbeit nicht nur das Finanzwesen, sondern auch grundlegende Konzepte von Eigentum, Governance und digitalem Vertrauen neu gestalten kann.",
+ "page-ethereum-history-founder-and-ownership-conclusion-description-4": "Erfahren Sie mehr über den Governance-Prozess von Ethereum"
+}
diff --git a/src/intl/de/page-ethereum-vs-bitcoin.json b/src/intl/de/page-ethereum-vs-bitcoin.json
new file mode 100644
index 00000000000..8b831f22182
--- /dev/null
+++ b/src/intl/de/page-ethereum-vs-bitcoin.json
@@ -0,0 +1,101 @@
+{
+ "page-ethereum-vs-bitcoin-meta-title": "Ethereum vs. Bitcoin: Was ist der Unterschied? | ethereum.org",
+ "page-ethereum-vs-bitcoin-meta-description": "Erfahren Sie mehr über die Unterschiede zwischen Bitcoin und Ethereum, einschließlich Anwendungsfällen, Netzwerkleistung, Sicherheit, Token-Ökonomie, Dezentralisierungsgrad und mehr.",
+ "page-ethereum-vs-bitcoin-twitter-meta-description": "Erfahren Sie mehr über die Unterschiede zwischen Bitcoin und Ethereum, einschließlich Anwendungsfällen, Netzwerkleistung, Token-Ökonomie und mehr.",
+ "page-ethereum-vs-bitcoin-title": "Ethereum vs. Bitcoin: Was ist der Unterschied?",
+ "page-ethereum-vs-bitcoin-description-1": "Bitcoin und Ethereum sind zwei der bekanntesten dezentralisierten Blockchain-Netzwerke, aber sie dienen sehr unterschiedlichen Zwecken.",
+ "page-ethereum-vs-bitcoin-section-1": "Bitcoin (mit großem B) ist eine Blockchain, die für eine digitale Währung namens Bitcoin (mit kleinem b) entwickelt wurde. Ethereum ist als dezentrale Plattform für Anwendungen und Vermögenswerte konzipiert und wird durch seine native Kryptowährung Ether (ETH) angetrieben.",
+ "page-ethereum-vs-bitcoin-section-2": "Beide nutzen die Blockchain-Technologie, sind Open-Source und werden von globalen Gemeinschaften gepflegt, aber ihre Ziele und Merkmale sind unterschiedlich. In diesem Leitfaden werden wir erläutern, was die einzelnen Netzwerke ausmacht, was sie gemeinsam haben und wie sie sich in Bereichen wie Technologie, Kultur und Zukunftsaussichten unterscheiden.",
+ "page-ethereum-vs-bitcoin-bitcoin-section-title": "Bitcoin – eine kurze Einführung",
+ "page-ethereum-vs-bitcoin-bitcoin-section-1": "Bitcoin ist ein dezentrales digitales Währungsnetzwerk. Es wurde 2009 von einer anonymen Person unter dem Namen Satoshi Nakamoto kurz nach der Finanzkrise von 2008 geschaffen. Die Idee war, dass Bitcoin ein elektronisches Peer-to-Peer-Bezahlsystem sein sollte.",
+ "page-ethereum-vs-bitcoin-bitcoin-section-2": "Bitcoin ermöglicht es jedem, Bitcoin über das Internet zu senden und zu empfangen, ohne sich auf eine zentrale Autorität wie eine Bank zu verlassen. Alle Transaktionen werden in einem öffentlichen Hauptbuch, der Blockchain, aufgezeichnet.",
+ "page-ethereum-vs-bitcoin-bitcoin-section-3": "Bitcoin verwendet Proof-of-Work, um sein Netzwerk zu sichern. Computer auf der ganzen Welt wetteifern darum, kryptografische Rätsel zu lösen, mit denen sie neue Blöcke hinzufügen können. Diese spezialisierten Computer werden als Miner bezeichnet und erhalten Bitcoin als Block-Belohnung für das „Mining“ neuer Blöcke.",
+ "page-ethereum-vs-bitcoin-bitcoin-section-4": "Bitcoin hat ein festes maximales Angebot von 21 Millionen Coins. Diese Design-Entscheidung ist ein Hauptgrund, warum Bitcoin oft als digitales Gold bezeichnet wird.",
+ "page-ethereum-vs-bitcoin-ethereum-section-title": "Ethereum – eine kurze Einführung",
+ "page-ethereum-vs-bitcoin-ethereum-section-1": "Wie Bitcoin ist auch Ethereum ein dezentrales Blockchain-Netzwerk, aber es wurde entwickelt, um mehr als nur Zahlungen aufzuzeichnen. Ethereum wurde 2015 von einem Softwareentwickler namens Vitalik Buterin und seinen Mitbegründern ins Leben gerufen und als Plattform für Smart Contracts und dezentralisierte Anwendungen konzipiert.",
+ "page-ethereum-vs-bitcoin-ethereum-section-2": "Mit Ethereum kann jeder, genau wie bei Bitcoin, Werte senden und empfangen, aber es fungiert auch als eine Plattform, die jeder für Anwendungen nutzen kann. Das Ethereum-Netzwerk läuft auf Tausenden von Nodes und wird nicht von einer einzigen Entität kontrolliert.",
+ "page-ethereum-vs-bitcoin-ethereum-section-3": "Jeder kann Anwendungen erstellen und auf Ethereum bereitstellen. Diese Programme werden Smart Contracts genannt und sind die Kerninnovation von Ethereum.",
+ "page-ethereum-vs-bitcoin-ethereum-section-4": "Sobald der Smart Contract bereitgestellt ist, läuft er bei Interaktion deterministisch ab. Dies ermöglicht es, Apps für Dinge wie Kreditvergabe, Handel, Spiele und digitale Sammlerstücke zu erstellen, die rund um die Uhr für Millionen von Nutzern weltweit laufen.",
+ "page-ethereum-vs-bitcoin-ethereum-section-5": "Genauso wie Bitcoin zur Bezahlung von Transaktionsgebühren im Bitcoin-Netzwerk verwendet wird, wird die native Währung von Ethereum, Ether, zur Bezahlung von Transaktionsgebühren, zur Veröffentlichung und Nutzung von Smart Contracts und zur Sicherung des Netzwerks verwendet. Ether dient sowohl als Treibstoff für die Ausführung von Programmen als auch als Wertspeicher.",
+ "page-ethereum-vs-bitcoin-ethereum-section-6": "Erfahren Sie mehr über Ethereum und seine Funktionsweise",
+ "page-ethereum-vs-bitcoin-differences-section-title": "Die wichtigsten Unterschiede",
+ "page-ethereum-vs-bitcoin-differences-section-1": "Bitcoin und Ethereum nutzen die Blockchain-Technologie, um dezentrale Netzwerke zu unterhalten, unterscheiden sich aber in ihrem Design, ihrem Zweck und ihren Fähigkeiten.",
+ "page-ethereum-vs-bitcoin-differences-table-area": "Bereich",
+ "page-ethereum-vs-bitcoin-differences-table-bitcoin": "Bitcoin",
+ "page-ethereum-vs-bitcoin-differences-table-ethereum": "Ethereum",
+ "page-ethereum-vs-bitcoin-differences-table-row-1-1": "Hauptzweck",
+ "page-ethereum-vs-bitcoin-differences-table-row-1-2": "Digitale Peer-to-Peer-Währung",
+ "page-ethereum-vs-bitcoin-differences-table-row-1-3": "Plattform für Apps und digitale Ökonomien",
+ "page-ethereum-vs-bitcoin-differences-table-row-2-1": "Smart Contracts",
+ "page-ethereum-vs-bitcoin-differences-table-row-2-2": "Nicht unterstützt",
+ "page-ethereum-vs-bitcoin-differences-table-row-2-3": "Kernfunktionalität",
+ "page-ethereum-vs-bitcoin-differences-table-row-3-1": "Angebot",
+ "page-ethereum-vs-bitcoin-differences-table-row-3-2": "Bitcoin wird in jedem Block mit einer festen/vorbestimmten Rate ausgegeben, die durch das ursprüngliche und unveränderte Protokoll vorgegeben ist, mit einer eventuellen festen Obergrenze von 21 Millionen.",
+ "page-ethereum-vs-bitcoin-differences-table-row-3-3": "Ether wird in jedem Block proportional zur Aktivität/Nachfrage verbrannt und in jeder Epoche proportional zum gesamten gestaketen ETH emittiert. Es gibt keine feste Obergrenze, aber die Emissionsrate ist durch die Gesamtzahl der gestaketen ETH begrenzt.",
+ "page-ethereum-vs-bitcoin-differences-table-row-4-1": "Konsensmechanismus",
+ "page-ethereum-vs-bitcoin-differences-table-row-4-2": "Proof-of-Work (Arbeitsnachweis)",
+ "page-ethereum-vs-bitcoin-differences-table-row-4-3": "Proof-of-Stake (Einsatznachweis)",
+ "page-ethereum-vs-bitcoin-differences-table-row-5-1": "Geschwindigkeit",
+ "page-ethereum-vs-bitcoin-differences-table-row-5-2": "Gilt bei den meisten nach sechs Blöcken als unumkehrbar, was durchschnittlich 60 Minuten dauert",
+ "page-ethereum-vs-bitcoin-differences-table-row-5-3": "Etwa 15 Minuten bis zur Endgültigkeit",
+ "page-ethereum-vs-bitcoin-differences-table-row-6-1": "Energieverbrauch",
+ "page-ethereum-vs-bitcoin-differences-table-row-6-2": "Hoch",
+ "page-ethereum-vs-bitcoin-differences-table-row-6-3": "Gering",
+ "page-ethereum-vs-bitcoin-differences-table-row-7-1": "Verwaltung",
+ "page-ethereum-vs-bitcoin-differences-table-row-7-2": "Konservativ, langsam",
+ "page-ethereum-vs-bitcoin-differences-table-row-7-3": "Flexibel, von der Community gesteuert",
+ "page-ethereum-vs-bitcoin-differences-table-row-8-1": "Entwickler-Ökosystem",
+ "page-ethereum-vs-bitcoin-differences-table-row-8-2": "Kleiner",
+ "page-ethereum-vs-bitcoin-differences-table-row-8-3": "Groß und aktiv",
+ "page-ethereum-vs-bitcoin-differences-table-row-9-1": "Die Upgrades",
+ "page-ethereum-vs-bitcoin-differences-table-row-9-2": "Selten",
+ "page-ethereum-vs-bitcoin-differences-table-row-9-3": "Häufig und iterativ",
+ "page-ethereum-vs-bitcoin-purpose-title": "Zweck von Bitcoin im Vergleich zu Ethereum",
+ "page-ethereum-vs-bitcoin-purpose-1": "Bitcoin wurde 2009 im Zuge der globalen Finanzkrise geschaffen. Sein Ziel war es, eine Peer-to-Peer-Form von Geld anzubieten, die ohne Banken oder Regierungen funktioniert. Es ist von Grund auf einfach konzipiert. Das Netzwerk zielt darauf ab, Werte von einer Person zur anderen ohne Zwischenhändler zu übertragen. Dieser enge Fokus hat dazu beigetragen, dass es weithin als eine Form von digitalem Gold bekannt wurde, ein knapper und langlebiger Wertspeicher, der auch als Tauschmittel verwendet werden kann.",
+ "page-ethereum-vs-bitcoin-purpose-2": "Ethereum startete 2015 mit einer breiteren Vision. Seine Schöpfer wollten die Sicherheit und Dezentralisierung der Blockchain nutzen und sie programmierbar machen. Anstatt sich auf Zahlungen zu beschränken, ermöglicht Ethereum jedem, selbstausführende Programme zu schreiben und zu veröffentlichen, die als Smart Contracts bezeichnet werden. Dies öffnet die Tür zu einer völlig neuen Kategorie von Anwendungen, von dezentralen Finanzen (DeFi) und Stablecoins bis hin zu nicht-fungiblen Token (NFTs), Spielen und dezentralen sozialen Medien.",
+ "page-ethereum-vs-bitcoin-purpose-3": "Die technischen Designs spiegeln diese Zwecke wider. Die Skriptsprache von Bitcoin ist begrenzt, was die Komplexität reduziert und hilft, das Netzwerk sicher zu halten. Die Programmiersprache von Ethereum ist ausdrucksstärker und ermöglicht es, komplexere Zustände und Interaktionen zwischen Anwendungen zu speichern und zu verwalten. Diese Flexibilität ist eine Stärke, bedeutet aber auch, dass sich das Netzwerk schneller entwickelt, mit regelmäßigen Upgrades und neuen Funktionen.",
+ "page-ethereum-vs-bitcoin-purpose-4": "Beide spielen unterschiedliche Rollen in der breiteren digitalen Wirtschaft. Bitcoin konzentriert sich darauf, ein stabiler und dezentraler Wertspeicher zu sein. Ethereum zielt darauf ab, eine globale Abwicklungsebene für dezentralisierte Anwendungen und programmierbare Vermögenswerte zu sein.",
+ "page-ethereum-vs-bitcoin-usecases-and-adoption-title": "Anwendungsfälle und Akzeptanz",
+ "page-ethereum-vs-bitcoin-usecases-and-adoption-1": "Bitcoin wird häufig als Wertspeicher verwendet. Viele Anleger sehen es als Absicherung gegen Inflation oder wirtschaftliche Instabilität. In einigen Ländern wird es als alternative Währung oder als eine Möglichkeit für Menschen verwendet, außerhalb des traditionellen Bankensystems zu sparen.",
+ "page-ethereum-vs-bitcoin-usecases-and-adoption-2": "Ether dient ebenfalls als Wertspeicher, aber seine Hauptaufgabe ist es, ein breites Ökosystem von Anwendungen und Vermögenswerten anzutreiben. Entwickler können Ethereum nutzen, um neue Protokolle zu erstellen, Token zu starten, dezentrale Börsen zu betreiben, NFTs zu prägen, Spiele zu entwickeln und soziale Plattformen zu schaffen, die ohne zentrale Kontrolle laufen.",
+ "page-ethereum-vs-bitcoin-usecases-and-adoption-3": "Ethereum unterstützt Tausende von dezentralisierten Anwendungen für neue Formen von Finanzen, Crowdfunding und digitalem Eigentum. Einige Anwendungsfälle verbinden sogar beide Netzwerke. Zum Beispiel kann Bitcoin „wrapped“ und auf Ethereum verwendet werden für Aktivitäten wie Kreditvergabe, Kreditaufnahme und Handel in DeFi.",
+ "page-ethereum-vs-bitcoin-usecases-and-adoption-4": "Die institutionelle Akzeptanz spiegelt diese Unterschiede wider. Die Kryptowährung Bitcoin wird weithin als langfristiger Wertspeicher gehalten, während Ethereum als dezentrale Infrastruktur angesehen wird. Seine Programmierbarkeit spricht Fintech-Plattformen und Zahlungsanbieter an.",
+ "page-ethereum-vs-bitcoin-usecases-and-adoption-5": "Erfahren Sie mehr darüber, wofür Ethereum verwendet wird",
+ "page-ethereum-vs-bitcoin-monetary-policy-title": "Geldpolitik",
+ "page-ethereum-vs-bitcoin-monetary-policy-1": "Das Angebot von Bitcoin wird bei 21 Millionen Coins begrenzt sein. Diese harte Grenze wird durch das Protokoll durchgesetzt und ist einer der Gründe, warum Bitcoin mit Gold verglichen wird. Neue Bitcoin kommen durch Mining-Belohnungen in Umlauf, die sich alle 210.000 Blöcke halbieren, was etwa 4 Jahre Mining dauert, in einem Ereignis, das Halving genannt wird. Die Belohnung begann 2009 mit 50 Bitcoin pro Block, fiel 2012 auf 25, dann 2016 auf 12,5 und so weiter. Bei dieser Rate wird der letzte Bitcoin voraussichtlich um das Jahr 2140 geschürft.",
+ "page-ethereum-vs-bitcoin-monetary-policy-2": "Die Mining-Belohnungen und Transaktionsgebühren von Bitcoin finanzieren das Netzwerk und werden zur Sicherung verwendet. Da sich die Block-Belohnung jedoch halbiert, ist das Netzwerk stärker auf Transaktionsgebühren angewiesen, um sich selbst zu finanzieren. Derzeit machen die Netzwerkgebühren nur einen kleinen Teil des Netzwerkeinkommens aus (<5 %), was bedeutet, dass die langfristige Sicherheit des Netzwerks gefährdet sein könnte, da die Emission des Bitcoin-Netzwerks auf 0 sinkt.",
+ "page-ethereum-vs-bitcoin-monetary-policy-3": "Ethereum hat keine feste Angebotsobergrenze. Stattdessen wird seine Emission durch Protokollregeln bestimmt, und jüngste Upgrades haben Mechanismen eingeführt, die das Angebot im Laufe der Zeit reduzieren können. Das bemerkenswerteste ist das EIP-1559-Upgrade, das einen Teil der Transaktionsgebühren verbrennt. Wenn die Netzwerkaktivität hoch ist, kann mehr ETH verbrannt werden als emittiert wird, wodurch das Angebot in diesen Perioden deflationär wird.",
+ "page-ethereum-vs-bitcoin-monetary-policy-4": "Der monetäre Ansatz von Ethereum garantiert ein Sicherheitsbudget auf Dauer, wobei Transaktionsgebühren und Block-Belohnungen das Sicherheitsbudget des Netzwerks bereitstellen.",
+ "page-ethereum-vs-bitcoin-developer-ecosystem-title": "Entwickler-Ökosystem",
+ "page-ethereum-vs-bitcoin-developer-ecosystem-1": "Ethereum hat eine der größten Blockchain-Entwickler-Communitys. Wenn Sie auf Ethereum aufbauen, erhalten Sie Zugang zu einer breiten Palette von Tools, Frameworks, Zuschüssen und Hackathons. Die Ethereum Virtual Machine (EVM) ist die Laufzeitumgebung von Ethereum und hat sich zu einem gängigen Standard entwickelt, wobei viele andere Blockchains sie zur Gewährleistung der Kompatibilität verwenden.",
+ "page-ethereum-vs-bitcoin-developer-ecosystem-2": "Token-Standards wie ERC-20 und ERC-721 sind zur Grundlage für einen Großteil der breiteren Blockchain-Wirtschaft geworden. Viele Layer-2-Netzwerke und andere Blockchains verwenden die EVM, damit Apps, Wallets und Smart-Contract-Code mit minimalen Änderungen über Blockchains hinweg verwendet werden können.",
+ "page-ethereum-vs-bitcoin-developer-ecosystem-3": "Die Entwickler-Community von Bitcoin ist kleiner und fokussierter. Die meisten Aktivitäten konzentrieren sich auf die Wartung und Verbesserung des Kernprotokolls sowie auf die Entwicklung von Layer-2-Lösungen wie dem Lightning Network für schnellere und günstigere Zahlungen.",
+ "page-ethereum-vs-bitcoin-developer-ecosystem-4": "Erfahren Sie mehr über die Entwicklerressourcen von Ethereum",
+ "page-ethereum-vs-bitcoin-security-and-consensus-title": "Sicherheit und Konsens",
+ "page-ethereum-vs-bitcoin-security-and-consensus-1": "Bitcoin und Ethereum werden beide durch große, verteilte Netzwerke unabhängiger Nodes gesichert, aber sie verwenden unterschiedliche Methoden, um sich auf den Zustand des Netzwerks zu einigen.",
+ "page-ethereum-vs-bitcoin-security-and-consensus-2": "Bitcoin verwendet ein System namens Proof-of-Work. Computer, die als Miner bezeichnet werden, konkurrieren darum, kryptografische Rätsel zu lösen. Der Erste, der eines löst, darf den nächsten Transaktionsblock zur Blockchain hinzufügen und erhält eine Belohnung in Bitcoin. Dieser Ansatz verleiht Bitcoin eine sogenannte probabilistische Endgültigkeit, was bedeutet, dass eine Transaktion erst als hochsicher gilt, nachdem mehrere weitere Blöcke darauf hinzugefügt wurden. Bei Bitcoin sind das oft etwa sechs Bestätigungen oder ungefähr eine Stunde.",
+ "page-ethereum-vs-bitcoin-security-and-consensus-3": "Ethereum verwendet Proof-of-Stake. In diesem Modell sperren oder staken Validatoren ETH, um die Chance zu haben, für den Vorschlag und die Bestätigung neuer Blöcke ausgewählt zu werden. Die Auswahl ist zufällig, aber die Wahrscheinlichkeit, ausgewählt zu werden, steigt mit der Menge des gestaketen ETH. Validatoren, die unehrlich handeln, riskieren den Verlust ihres Stakes. Dies ermöglicht Ethereum, eine wirtschaftliche Endgültigkeit zu erreichen, bei der finalisierte Blöcke extrem schwer rückgängig zu machen sind, oft innerhalb von etwa 15 Minuten. Ethereum verwendet auch Checkpoints, um Blöcke als unumkehrbar zu markieren, sobald genügend Validatoren zugestimmt haben.",
+ "page-ethereum-vs-bitcoin-security-and-consensus-4": "Erfahren Sie mehr über den Konsensmechanismus von Ethereum",
+ "page-ethereum-vs-bitcoin-underlying-technology-title": "Zugrundeliegende Technologie",
+ "page-ethereum-vs-bitcoin-underlying-technology-1": "Bitcoin verwendet das sogenannte Unspent Transaction Output (UTXO)-Modell. In diesem System verfolgt die Blockchain keine Kontostände. Stattdessen zeichnet sie die Ausgaben (Outputs) aus früheren Transaktionen auf, die noch nicht ausgegeben wurden. Wenn Sie Bitcoin ausgeben, verwenden Sie diese Outputs als Inputs für eine neue Transaktion und erzeugen dabei neue Outputs.",
+ "page-ethereum-vs-bitcoin-underlying-technology-2": "Sie können sich das wie die Verwendung von Bargeld vorstellen. Wenn Sie zwei Fünf-Dollar-Scheine haben und sieben Dollar ausgeben möchten, geben Sie beide Scheine ab und erhalten drei Dollar Wechselgeld. Bitcoin zeichnet die Scheine und das Wechselgeld auf, nicht Ihren Gesamtsaldo.",
+ "page-ethereum-vs-bitcoin-underlying-technology-3": "Ethereum verwendet ein kontobasiertes Modell. Anstatt einzelne Outputs zu verfolgen, führt es eine Aufzeichnung der Kontostände, wie es ein Bankkonto tut. Dieser Ansatz erleichtert die Verwaltung von Smart Contracts und komplexer Logik, da Konten Daten speichern und wie Programme miteinander interagieren können.",
+ "page-ethereum-vs-bitcoin-underlying-technology-4": "Jedes Modell hat seine Vor- und Nachteile. UTXOs können mehr Privatsphäre bieten und es einfacher machen, einzelne Coins zu verfolgen. Kontobasierte Systeme sind für die Erstellung von Anwendungen unkomplizierter.",
+ "page-ethereum-vs-bitcoin-underlying-technology-5": "Lesen Sie mehr in der Ethereum-Entwicklerdokumentation",
+ "page-ethereum-vs-bitcoin-decentralization-title": "Dezentralisierung",
+ "page-ethereum-vs-bitcoin-decentralization-1": "Bitcoin und Ethereum sind beide so konzipiert, dass sie dezentral sind, aber sie messen und nähern sich dem auf unterschiedliche Weise.",
+ "page-ethereum-vs-bitcoin-decentralization-2": "Die Dezentralisierung von Bitcoin wird durch sein einfaches technisches Design, seine langfristige Stabilität und die weite Verbreitung von Nodes unterstützt. Seine geringen Ressourcenanforderungen machen es für Menschen einfacher, Full Nodes zu Hause zu betreiben, was dazu beiträgt, die Unabhängigkeit und Zensurresistenz des Netzwerks zu wahren.",
+ "page-ethereum-vs-bitcoin-decentralization-3": "Ethereum hat ebenfalls ein großes und wachsendes Node-Netzwerk. Es legt großen Wert auf Client-Vielfalt, was bedeutet, dass mehrere Versionen der Software von unabhängigen Teams gewartet werden. Dies verringert die Abhängigkeit von einem einzelnen Client und hilft, vor Bugs oder Ausfällen zu schützen, die das Netzwerk beeinträchtigen könnten.",
+ "page-ethereum-vs-bitcoin-decentralization-4": "Ethereum hat eine breitere Anzahl von Teilnehmern, die an Aktivitäten wie Staking, Upgrades und Governance-Diskussionen beteiligt sind, aber beide Netzwerke zielen darauf ab, offen und widerstandsfähig zu bleiben. Bitcoin hält die Node-Anforderungen unverändert und verlässt sich auf weniger Software-Clients. Ethereum ermutigt verschiedene Mitwirkende, die jeweils ihre eigene Perspektive einbringen.",
+ "page-ethereum-vs-bitcoin-environmental-impact-title": "Umweltauswirkungen",
+ "page-ethereum-vs-bitcoin-environmental-impact-1": "Eine der bedeutendsten Änderungen in der Geschichte von Ethereum war der Wechsel von Proof-of-Work zu Proof-of-Stake im Jahr 2022. Bekannt als The Merge, hat dieser Übergang den Energieverbrauch des Netzwerks um mehr als 99 Prozent reduziert.",
+ "page-ethereum-vs-bitcoin-environmental-impact-2": "Unter Proof-of-Stake ist Ethereum nicht mehr auf energieintensives Mining angewiesen. Stattdessen werden Validatoren zufällig ausgewählt, wobei die Wahrscheinlichkeit der Auswahl mit der Menge des von ihnen gestaketen ETH zunimmt. Dieser Wandel hat Ethereum zu einem der energieeffizienteren Blockchain-Netzwerke gemacht.",
+ "page-ethereum-vs-bitcoin-environmental-impact-3": "Bitcoin verwendet weiterhin Proof-of-Work, das große Mengen an Strom erfordert, da Miner darum konkurrieren, kryptografische Rätsel zu lösen. Ein Teil dieser Energie stammt aus erneuerbaren Quellen, und es gibt in der Bitcoin-Community laufende Diskussionen über Möglichkeiten zur Verbesserung der Nachhaltigkeit.",
+ "page-ethereum-vs-bitcoin-environmental-impact-4": "Der Unterschied im Energieverbrauch ist zu einem wichtigen Vergleichspunkt zwischen den beiden Netzwerken geworden. Der geringere Energie-Fußabdruck von Ethereum macht es in Kontexten, in denen die Umweltauswirkungen eine Priorität sind, attraktiver.",
+ "page-ethereum-vs-bitcoin-environmental-impact-5": "Lesen Sie den vollständigen Bericht über den Energieverbrauch von Ethereum",
+ "page-ethereum-vs-bitcoin-future-outlook-title": "Wie sieht die Zukunft aus?",
+ "page-ethereum-vs-bitcoin-future-outlook-1": "Bitcoin wird zunehmend als Wertspeicher und Reserve-Asset angenommen. Es ist unwahrscheinlich, dass es sich wesentlich ändern wird, und diese Stabilität ist Teil seiner Anziehungskraft.",
+ "page-ethereum-vs-bitcoin-future-outlook-2": "Ethereum positioniert sich als Anwendungsplattform in der neuen digitalen Wirtschaft. Mit dem Wachstum von Layer-2-Netzwerken und laufenden Upgrades zielt es darauf ab, Anwendungen, Infrastruktur und Vermögenswerte im globalen Maßstab zu unterstützen.",
+ "page-ethereum-vs-bitcoin-future-outlook-3": "Für viele Nutzer stehen die beiden Netzwerke nicht in direktem Wettbewerb. Sie dienen unterschiedlichen Zwecken und können sich in einem diversifizierten Ansatz für digitale Vermögenswerte gegenseitig ergänzen.",
+ "page-ethereum-vs-bitcoin-future-outlook-4": "Erfahren Sie mehr über die Roadmap von Ethereum"
+}
\ No newline at end of file
diff --git a/src/intl/de/page-founders.json b/src/intl/de/page-founders.json
new file mode 100644
index 00000000000..efab4756fc2
--- /dev/null
+++ b/src/intl/de/page-founders.json
@@ -0,0 +1,65 @@
+{
+ "page-founders-accelerators-alliance-description": "Alliance ist der führende Krypto-Accelerator und die führende Gründer-Community. Jetzt werden auch KI-Startups angenommen.",
+ "page-founders-accelerators-alliance-highlight-1": "500.000 $ Finanzierung",
+ "page-founders-accelerators-base-description": "Base Batches ist ein globales Programm für Entwickler, die die nächste Welle von On-Chain-Apps erstellen.",
+ "page-founders-accelerators-base-highlight-1": "Bis zu 1 Mio. $ Finanzierung",
+ "page-founders-accelerators-growth-label": "Accelerators und Wachstum",
+ "page-founders-accelerators-kernel-description": "Bei Kernel geht es darum, langsam aufzubauen, durch wiederholte Interaktionen mit Gleichgesinnten.",
+ "page-founders-accelerators-kernel-highlight-1": "Über 2.200 Fellows",
+ "page-founders-accelerators-kernel-highlight-2": "Über 150 aktive Projekte",
+ "page-founders-apply-h2": "Unterstützung beantragen",
+ "page-founders-apply-p1": "Wählen Sie Ihren Weg und werden Sie zum relevantesten nächsten Schritt weitergeleitet.",
+ "page-founders-cta-explore-name": "{name} entdecken",
+ "page-founders-cta-visit-name": "{name} besuchen",
+ "page-founders-description": "Ein dedizierter Hub für Unternehmer, um auf Programme, Mentoring und Sichtbarkeit im gesamten Ethereum-Ökosystem zuzugreifen und Gründern in jeder Phase die Unterstützung zu geben, die sie benötigen.",
+ "page-founders-funding-arbitrum-description": "Die Mission ist es, Entwickler und Unternehmer zu befähigen, wirkungsvolle Dapps zu erstellen, die die Fähigkeiten des Arbitrum-Netzwerks nutzen.",
+ "page-founders-funding-arbitrum-highlight-1": "Über 300 unterstützte Projekte",
+ "page-founders-funding-base-description": "Builder Grants sind fortlaufende Experimente, um Base-Entwickler anzuerkennen.",
+ "page-founders-funding-base-highlight-1": "Zuschüsse von 1-5 ETH",
+ "page-founders-funding-esp-description": "Ressourcen für kritische Projekte bereitstellen, eine geschätzte Stimme innerhalb des Ethereum-Ökosystems sein und Ethereum gegenüber der Außenwelt vertreten.",
+ "page-founders-funding-esp-highlight-1": "Über 2.000 unterstützte Projekte",
+ "page-founders-funding-label": "Finanzierung",
+ "page-founders-funding-optimism-description": "Unterstützung für einzelne Entwickler und Teams, die On-Chain-Apps, Tooling und Infrastruktur erstellen, um die Superchain voranzubringen.",
+ "page-founders-funding-optimism-highlight-1": "19 förderfähige Chains",
+ "page-founders-funding-optimism-highlight-2": "Über 700 unterstützte Projekte",
+ "page-founders-funding-polygon-description": "Ein Community-Zuschussprogramm zur Unterstützung von Entwicklern, Teams und Erstellern, die sich dem Wachstum von Polygon verschrieben haben.",
+ "page-founders-funding-polygon-highlight-1": "Entwicklung auf oder Migration zu Polygon",
+ "page-founders-funding-unichain-description": "Eine Reihe von Programmen und Ressourcen, die zur Unterstützung der aufstrebenden Entwickler-Community von Unichain entwickelt wurden.",
+ "page-founders-funding-unichain-highlight-1": "Neuartige DeFi-Mechanismen",
+ "page-founders-get-in-touch-cta": "Unterstützung anfordern",
+ "page-founders-get-in-touch-h2": "Ethereum Foundation Founder Success Team",
+ "page-founders-get-in-touch-p1": "Founder Success ist für Entwickler mit kühnen Ideen, Unternehmer, die Ethereum als Grundlage für Produkte und Unternehmen sehen, die die Zukunft gestalten können.",
+ "page-founders-metadata-description": "Stärkung von Gründern auf Ethereum mit Programmen, Mentoring und Ressourcen. Entdecken Sie, wie das Ethereum-Ökosystem Unternehmer von der Idee bis zum Wachstum unterstützt.",
+ "page-founders-metadata-title": "Gründerunterstützung",
+ "page-founders-partnerships-devconnect-description": "Devconnect ARG ist die Weltausstellung von Ethereum: Ein Schaufenster für Apps und eine Veranstaltung zum Vernetzen, Entwickeln und Beschleunigen der Ethereum-Einführung.",
+ "page-founders-partnerships-ef-founder-support-cta": "Einführung vereinbaren",
+ "page-founders-partnerships-ef-founder-support-description": "Koordination von Umsatzbeteiligung, Liquidität und Partnerschaften. Das EF Founder Success Team hilft dabei, die richtigen Teams zu vernetzen, um dies zu ermöglichen.",
+ "page-founders-partnerships-ef-founder-support-subtitle": "Vorstellungen bei DeFi-Protokollen/Teams",
+ "page-founders-partnerships-ens-description": "Das Programm zielt darauf ab, Projekte zu fördern, die sowohl für Entwickler als auch für Benutzer einen außergewöhnlichen Nutzen und eine große Wirkung gezeigt haben.",
+ "page-founders-partnerships-ens-highlight-1": "Kleine Zuschüsse bis zu 2 ETH",
+ "page-founders-partnerships-ens-highlight-2": "Große Zuschüsse bis zu 50.000 USDC",
+ "page-founders-partnerships-ethglobal-description": "Globale Veranstaltungen, die ein Weltklasse-Ökosystem von Ethereum-Entwicklern und -Unternehmern fördern.",
+ "page-founders-partnerships-label": "Partnerschaften & Integrationen",
+ "page-founders-partnerships-protocol-guild-description": "Unabhängige Finanzierungsorganisation für Ethereum-Kernentwickler. Wir finanzieren proaktiv Betreuer, deren Arbeit für das Ökosystem unerlässlich ist.",
+ "page-founders-partnerships-protocol-guild-highlight-1": "28 Mio. $ für Kernentwickler gesammelt",
+ "page-founders-partnerships-unichain-description": "Eine Reihe von Programmen und Ressourcen, die zur Unterstützung der aufstrebenden Entwickler-Community von Unichain entwickelt wurden.",
+ "page-founders-partnerships-unichain-highlight-1": "Neuartige DeFi-Mechanismen",
+ "page-founders-story-dith-p1": "Der EF Founder Support war ausgezeichnet, er war ein großartiger, unparteiischer Denkpartner und Berater für uns, als wir unsere erste Finanzierungsrunde abschlossen. Ich empfehle anderen EVM-Gründern ohne zu zögern, sich an sie zu wenden.",
+ "page-founders-story-fahim-p1": "Das Founder Success Team ist eine enorme Bereicherung für das Ethereum-Ökosystem. Ihnen liegt wirklich daran, Teams zum Erfolg zu verhelfen, und ihre tatkräftige Unterstützung und ihr aufrichtiges Engagement, Teams wie Optimism zu helfen, sind deutlich zu erkennen. Ich freue mich darauf, weiterhin mit ihnen zusammenzuarbeiten und gemeinsam unser Ökosystem zu stärken.",
+ "page-founders-story-kedian-p1": "Unser Ansprechpartner bei der EF war entscheidend für unsere Orientierung, nicht nur durch das Teilen wertvoller Einblicke in unser bevorstehendes Feature, sondern auch dadurch, dass er uns wichtigen L2s im Ethereum-Ökosystem vorgestellt hat.",
+ "page-founders-story-kedian-p2": "Dank ihres Feedbacks zu unserer GTM-Strategie haben wir die Entscheidungsfindung beschleunigt, den Zeitaufwand für die Recherche reduziert und uns direkt auf die Ausführung konzentriert.",
+ "page-founders-succeed-h2": "Wie andere erfolgreich waren",
+ "page-founders-succeed-p1": "Sie müssen nicht alleine bauen, dieses Ökosystem steht hinter Ihnen.",
+ "page-founders-support-tag-accelerator": "Accelerator",
+ "page-founders-support-tag-active": "Aktiv",
+ "page-founders-support-tag-audit-grants": "Audit-Zuschüsse",
+ "page-founders-support-tag-ecosystem-events": "Ökosystem-Veranstaltungen",
+ "page-founders-support-tag-events": "Ereignisse",
+ "page-founders-support-tag-fundraising": "Fundraising",
+ "page-founders-support-tag-grant-program": "Zuschussprogramm",
+ "page-founders-support-tag-mentorship": "Mentoring",
+ "page-founders-support-tag-networking": "Networking",
+ "page-founders-support-tag-public-goods": "Öffentliche Güter",
+ "page-founders-support-tag-tooling-infra": "Tooling & Infra",
+ "page-founders-title": "Stärkung von Gründern auf Ethereum"
+}
diff --git a/src/intl/de/page-gas.json b/src/intl/de/page-gas.json
index bcde05bec16..d38ff9f82c0 100644
--- a/src/intl/de/page-gas.json
+++ b/src/intl/de/page-gas.json
@@ -1,5 +1,5 @@
{
- "page-gas-meta-title": "Spritgebühren auf Ethereum: Wie funktionieren sie?",
+ "page-gas-meta-title": "Ethereum-Gebühren: Was ist Gas und wie zahlt man weniger?",
"page-gas-meta-description": "Erfahren Sie mehr über Sprit auf Ethereum: Wie er funktioniert und wie man weniger Spritgebühren zahlt",
"page-gas-hero-title": "Spritgebühren",
"page-gas-hero-header": "Netzwerkgebühren",
@@ -33,7 +33,7 @@
"page-gas-why-do-we-need-gas-header": "Warum benötigen wir Sprit?",
"page-gas-why-do-we-need-gas-text": "Sprit ist ein entscheidendes Element, um Ethereum sicher zu halten und Transaktionen zu verarbeiten. Sprit hilft in vielerlei Hinsicht:",
"page-gas-benefits-1-description": "Dank Gas ist Ethereum nicht für Sybil anfällig, indem böswillige Akteure davon abgehalten werden, das Netzwerk mit betrügerischen Aktivitäten zu überlasten.",
- "page-gas-benefits-2-description": "Da für Rechenleistung Sprit nötig ist, werden die finalziellen Anreize für das Spamming mit teuren Transaktionen auf Ethereum entzogen, ob versehentlich oder mit bösartigen Absichten.",
+ "page-gas-benefits-2-description": "Da Rechenleistung Gas kostet, wird das Spammen von Ethereum mit teuren Transaktionen – ob versehentlich oder böswillig – finanziell unattraktiv gemacht.",
"page-gas-benefits-3-description": "Eine feste Obergrenze für die Menge an Rechenleistung, die zu einem bestimmten Zeitpunkt durchgeführt werden kann, verhindert, dass Ethereum überlastet wird, und trägt dazu bei, dass das Netzwerk immer zugänglich bleibt.",
"page-gas-how-is-gas-calculated-header": "Wie wird der Sprit berechnet?",
"page-gas-advanced": "Fortgeschritten",
@@ -53,7 +53,7 @@
"page-gas-faq-header": "Häufig gestellte Fragen",
"page-gas-faq-question-1-q": "Wer erhält die Spritgebühr in meiner Transaktion?",
"page-gas-faq-question-1-a-1": "Der Hauptteil der Gasgebühr – die Basisgebühr – wird durch das Protokoll zerstört (verbrannt). Die Prioritätsgebühr, die ggf. in Ihrer Transaktion inbegriffen ist, wird dem Validator übergeben, der Ihre Transaktion vorgeschlagen hat.",
- "page-gas-faq-question-1-a-2": "Eine detaillierte Beschreibung des Prozesses finden Sie in den Sprit-Entwicklerdokumenten.",
+ "page-gas-faq-question-1-a-2": "Eine detaillierte Beschreibung des Prozesses finden Sie in den Sprit-Entwicklerdokumenten.",
"page-gas-faq-question-2-q": "Muss ich Sprit in ETH bezahlen?",
"page-gas-faq-question-2-a-1": "Ja. Alle Spritgebühren auf Ethereum müssen in der nativen ETH-Währung bezahlt werden.",
"page-gas-faq-question-2-a-2": "Mehr zu ETH",
diff --git a/src/intl/de/page-get-eth.json b/src/intl/de/page-get-eth.json
index 7b08f3d8e17..e3e80fd2518 100644
--- a/src/intl/de/page-get-eth.json
+++ b/src/intl/de/page-get-eth.json
@@ -21,7 +21,7 @@
"page-get-eth-daos-link-desc": "Mehr über DAOs",
"page-get-eth-cex-link-desc": "Hier eine Liste von Börsen",
"page-get-eth-staking-link-desc": "Mehr über Staking erfahren",
- "page-get-eth-dexs": "Dezentralisierte Börsen (DEX)",
+ "page-get-eth-dexs": "Dezentrale Börsen (DEX)",
"page-get-eth-dexs-desc": "Dezentralisierte Börsen sind offene Marktplätze für ETH und andere Token. Sie verbinden Käufer und Verkäufer direkt.",
"page-get-eth-dexs-desc-2": "Anstatt einen vertrauenswürdigen Dritten zu verwenden, um Geldmittel bei der Transaktion zu schützen, verwenden sie Code. Das ETH des Verkäufers wird erst überwiesen, wenn die Zahlung garantiert ist. Diese Art von Code wird als Smart Contract bezeichnet.",
"page-get-eth-dexs-desc-3": "Das heißt, es gibt weniger geographische Einschränkungen als bei zentralen Alternativen. Wenn jemand das anbietet, was Sie suchen, und eine Zahlungsmethode akzeptiert, die Sie nutzen können, steht Ihrem Kauf nichts im Wege.",
@@ -74,6 +74,6 @@
"page-get-eth-your-address-desc": "Wenn Sie eine Wallet herunterladen, wird sie eine öffentliche ETH-Adresse für Sie erstellen. So sieht sie aus:",
"page-get-eth-your-address-desc-3": "Stellen Sie es sich wie Ihre E-Mail-Adresse vor, aber anstatt E-Mails kann man ETH empfangen. Wenn Sie ETH von einer Börse zu Ihrer Wallet überweisen wollen, benutzen Sie Ihre Adresse als Ziel. Überprüfen Sie Ihre Angaben vor dem Abschicken immer zweimal!",
"page-get-eth-your-address-wallet-link": "Schauen Sie sich Wallets an",
- "listing-policy-raise-issue-link": "Problem ansprechen",
+ "listing-policy-raise-issue-link": "Thema erstellen",
"page-find-wallet-last-updated": "Zuletzt aktualisiert"
}
diff --git a/src/intl/de/page-history.json b/src/intl/de/page-history.json
index aab238cfed7..20f11dd6b1d 100644
--- a/src/intl/de/page-history.json
+++ b/src/intl/de/page-history.json
@@ -1,7 +1,7 @@
{
"page-history-slot-number": "Slot-Nummer",
"page-history-block-number": "Blocknummer",
- "page-history-epoch-number": "Epoche-Nummer",
- "page-history-ethereum-org-wayback": "ethereum.org in waybackmachine",
+ "page-history-epoch-number": "Epochennummer",
+ "page-history-ethereum-org-wayback": "ethereum.org auf waybackmachine",
"page-history-eth-price": "ETH-Preis"
}
diff --git a/src/intl/de/page-layer-2-learn.json b/src/intl/de/page-layer-2-learn.json
new file mode 100644
index 00000000000..93f6c198b53
--- /dev/null
+++ b/src/intl/de/page-layer-2-learn.json
@@ -0,0 +1,55 @@
+{
+ "page-layer-2-learn-meta-title": "Was ist Layer 2? | ethereum.org",
+ "page-layer-2-learn-title": "Was ist Ebene 2?",
+ "page-layer-2-learn-description": "Skalierung von Ethereum für die Massenanwendung",
+ "page-layer-2-learn-button-1-label": "Was ist Ebene 2?",
+ "page-layer-2-learn-button-2-label": "Ebene 2 verwenden",
+ "page-layer-2-learn-what-is-layer-2-title": "Was ist Ebene 2?",
+ "page-layer-2-learn-what-is-layer-2-1": "Layer 2 (L2) ist ein Sammelbegriff, um bestimmte Skalierungslösungen für Ethereum zu beschreiben. Eine Layer 2 ist eine separate Blockchain, die Ethereum erweitert und die Sicherheitsgarantien von Ethereum erbt.",
+ "page-layer-2-learn-what-is-layer-2-2": "Gehen wir nun etwas tiefer in die Materie ein. Dazu müssen wir zunächst die Ebene 1 (L1) erklären.",
+ "page-layer-2-learn-what-is-layer-1-title": "Was ist Ebene 1?",
+ "page-layer-2-learn-what-is-layer-1-1": "Layer-1-Blockchains, wie Ethereum und Bitcoin, sind die zugrundeliegende Basis, auf der Layer-2-Projekte aufbauen. Beispiele für Layer-2-Projekte sind Zero-Knowledge-Rollups und Optimistic Rollups auf Ethereum sowie das Lightning Network auf Bitcoin.",
+ "page-layer-2-learn-what-is-layer-1-2": "Ethereum fungiert auch als Datenverfügbarkeitsschicht (Data Availability Layer) für Layer-2-Lösungen, und wenn es Streitigkeiten über frühere Transaktionen gibt, werden die dafür benötigten Daten von Ethereum bereitgestellt.",
+ "page-layer-2-learn-layer-1-list-title": "Ethereum als Ebene 1 umfasst:",
+ "page-layer-2-learn-layer-1-list-1": "ein Netzwerk von Knoten-Betreibern zur Sicherung und Validierung des Netzwerks",
+ "page-layer-2-learn-layer-1-list-2": "ein Netzwerk von Blockproduzenten",
+ "page-layer-2-learn-layer-1-list-3": "die Blockchain selbst und der Verlauf der Transaktionsdaten",
+ "page-layer-2-learn-layer-1-list-4": "der Konsensmechanismus für das Netzwerk",
+ "page-layer-2-learn-why-do-we-need-layer-2-title": "Warum brauchen wir Ebene 2?",
+ "page-layer-2-learn-why-do-we-need-layer-2-1": "Die drei wünschenswerten Eigenschaften einer Blockchain sind Dezentralisierung, Sicherheit und Skalierbarkeit. Das Blockchain-Trilemma besagt, dass eine einfache Blockchain-Architektur nur zwei dieser drei Eigenschaften gleichzeitig erreichen kann. Wollen Sie eine sichere und dezentrale Blockchain? Dann müssen Sie Skalierbarkeit opfern. Hier kommen Layer-2-Netzwerke ins Spiel.",
+ "page-layer-2-learn-why-do-we-need-layer-2-2": "Ethereum hat die derzeitige Kapazität des Netzwerks mit über 1 Million Transaktionen pro Tag erreicht, wobei jede dieser Transaktionen stark nachgefragt wird. Der Erfolg von Ethereum und die Nachfrage nach seiner Nutzung haben die Gaspreise erheblich steigen lassen. Daher hat auch der Bedarf an Skalierungslösungen seinen Höhepunkt erreicht.",
+ "page-layer-2-learn-why-do-we-need-layer-2-scalability": "Skalierbarkeit",
+ "page-layer-2-learn-why-do-we-need-layer-2-scalability-1": "Das Hauptziel der Skalierbarkeit ist es, die Transaktionsgeschwindigkeit (schnellere Endgültigkeit) und den Transaktionsdurchsatz (hohe Transaktionen pro Sekunde) zu erhöhen, ohne Dezentralisierung oder Sicherheit zu opfern.",
+ "page-layer-2-learn-why-do-we-need-layer-2-scalability-2": "Die Ethereum-Community hat klar Stellung bezogen, dass sie weder Dezentralisierung noch Sicherheit opfern wird, um Skalierbarkeit zu erreichen. Bis Sharding implementiert ist, wird das Ethereum-Mainnet (Layer 1) nur etwa 15 Transaktionen pro Sekunde verarbeiten können. Bei hoher Nutzungsnachfrage führt dies zu Netzwerküberlastung, steigenden Transaktionsgebühren und schließt diejenigen von der Nutzung aus, die sich diese Gebühren nicht leisten können, bis die Gebühren wieder sinken. Hier kommen Layer-2-Lösungen ins Spiel, um Ethereum bereits heute zu skalieren.",
+ "page-layer-2-learn-layer2Cards-1-title": "Geringere Gebühren",
+ "page-layer-2-learn-layer2Cards-1-description": "Durch die Bündelung mehrerer Transaktionen zu einer einzigen Transaktion auf Layer 1 werden die Transaktionsgebühren massiv reduziert, wodurch Ethereum für alle zugänglicher wird.",
+ "page-layer-2-learn-layer2Cards-2-title": "Aufrechterhaltung der Sicherheit",
+ "page-layer-2-learn-layer2Cards-2-description": "Layer-2-Blockchains verrechnen ihre Transaktionen auf dem Ethereum-Mainnet, sodass Nutzer, die sie verwenden, von der Sicherheit des Ethereum-Netzwerks profitieren.",
+ "page-layer-2-learn-layer2Cards-3-title": "Erweiterung der Anwendungsmöglichkeiten",
+ "page-layer-2-learn-layer2Cards-3-description": "Dank des höheren Transaktionsdurchsatzes, geringerer Gebühren und neuer Technologien werden sich die Projekte auf neue und benutzerfreundlichere Anwendungen ausweiten.",
+ "page-layer-2-learn-how-does-layer-2-work-title": "Wie funktioniert Layer 2?",
+ "page-layer-2-learn-how-does-layer-2-work-1": "Wie oben erwähnt, ist Ebene 2 ein Sammelbegriff für Ethereum-Skalierungslösungen, die Transaktionen außerhalb der Ebene 1 von Ethereum verarbeiten, während sie gleichzeitig von der soliden dezentralen Sicherheit der Ebene 1 von Ethereum profitieren. Eine Ebene 2 ist eine eigenständige Blockchain, die Ethereum erweitert. Wie funktioniert das?",
+ "page-layer-2-learn-how-does-layer-2-work-2": "Es gibt verschiedene Arten von Ebene 2, die jeweils ihre eigenen Kompromisse und Sicherheitsmodelle haben. Die Ebene 2-Lösungen nehmen die Transaktionslast von der Ebene 1 weg. Dadurch ist diese weniger überlastet und alles wird skalierbarer.",
+ "page-layer-2-learn-how-does-layer-2-work-rollups-title": "Gruppierungen (Rollups)",
+ "page-layer-2-learn-how-does-layer-2-work-rollups-1": "Rollups bündeln (oder „rollen“) Hunderte von Transaktionen zu einer einzigen Transaktion auf Layer 1. Dadurch verteilen sich die L1-Transaktionsgebühren auf alle im Rollup, was es für jeden Nutzer günstiger macht.",
+ "page-layer-2-learn-how-does-layer-2-work-rollups-2": "Die Transaktionsdaten im Rollup werden an Layer 1 übermittelt, aber die Ausführung erfolgt separat durch den Rollup. Durch die Übermittlung von Transaktionsdaten an Layer 1 erben Rollups die Sicherheit von Ethereum. Sobald die Daten auf Layer 1 hochgeladen werden, kann eine Rollup-Transaktion nur noch rückgängig gemacht werden, wenn Ethereum rückgängig gemacht wird. Es gibt zwei verschiedene Ansätze für Rollups: Optimistic und Zero-Knowledge – sie unterscheiden sich vor allem darin, in welcher Form diese Transaktionsdaten an die L1 übermittelt werden.",
+ "page-layer-2-learn-rollupCards-optimistic-title": "Optimistische Gruppierungen (Optimistic Rollups)",
+ "page-layer-2-learn-rollupCards-optimistic-description": "Optimistic Rollups verwenden Fehlernachweise (Fault Proofs), bei denen Transaktionen als gültig angenommen werden, aber angefochten werden können, wenn eine ungültige Transaktion vermutet wird. Bei Verdacht auf eine ungültige Transaktion wird ein Fehlernachweis durchgeführt, um dies zu überprüfen.",
+ "page-layer-2-learn-rollupCards-optimistic-childSentence": "Weitere Informationen zu Optimistic-Rollups",
+ "page-layer-2-learn-rollupCards-zk-title": "Zero Knowledge Rollups",
+ "page-layer-2-learn-rollupCards-zk-description": "Zero-Knowledge-Rollups verwenden Gültigkeitsnachweise (Validity Proofs), bei denen Transaktionsberechnungen Off-Chain durchgeführt werden, und diese Daten dann zusammen mit einem Nachweis ihrer Gültigkeit an das Ethereum-Mainnet übermittelt werden.",
+ "page-layer-2-learn-rollupCards-zk-childSentence": "Mehr zu ZK-Rollups",
+ "page-layer-2-learn-dyor-title": "Eigenrecherche: Risiken von Layer 2",
+ "page-layer-2-learn-dyor-1": "Da Layer-2-Ketten ihre Sicherheit von Ethereum erben, sind sie in einer idealen Welt so sicher wie L1-Ethereum. Allerdings sind viele der Projekte noch jung und gewissermaßen experimentell. Nach Jahren der Forschung und Entwicklung gingen viele der L2-Technologien, die Ethereum skalieren sollen, 2021 live. Das bedeutet nicht, dass diese L2s nicht sicher sind, sondern nur, dass keine Layer-2-Lösung so erprobt ist wie das Ethereum-Mainnet. Führen Sie stets Ihre eigene Recherche durch und entscheiden Sie, ob Sie mit den damit verbundenen Risiken einverstanden sind.",
+ "page-layer-2-learn-dyor-2": "Für weitere Informationen zur Technologie, den Risiken und Vertrauensannahmen von Layer-2-Lösungen empfehlen wir L2BEAT, das einen umfassenden Risikobewertungsrahmen für jedes Projekt bietet.",
+ "page-layer-2-learn-dyor-link": "Wechsel zu L2BEAT",
+ "page-layer-2-learn-note-on-alt-l1-title": "Ein Hinweis zu alternativen L1s, Sidechains und Validiums",
+ "page-layer-2-learn-note-on-alt-l1-1": "Alternative Layer-1-Blockchains (Alt L1s) haben einen höheren Durchsatz und niedrigere Transaktionsgebühren als Ethereum. Diese Alt L1s mussten bei Sicherheit oder Dezentralisierung Kompromisse eingehen, um höhere Transaktionen pro Sekunde und niedrigere Gebühren zu erreichen. Die Ethereum-Community ist fest davon überzeugt, dass Layer-2-Skalierung der einzige Weg ist, das Skalierungstrilemma zu lösen und dabei dezentralisiert und sicher zu bleiben.",
+ "page-layer-2-learn-note-on-alt-l1-2": "Sidechains und Validiums sind Blockchains, die es ermöglichen, Vermögenswerte von einer Blockchain über eine kettenübergreifende Brücke auf eine andere zu übertragen und dort zu nutzen. Sidechains und Validiums verlaufen parallel zur Hauptkette und interagieren über kettenübergreifende Brücken mit der Hauptkette, beziehen aber ihre Sicherheit oder Datenverfügbarkeit nicht von der Hauptkette. Sie skalieren ähnlich wie Layer-2-Lösungen, haben jedoch andere Vertrauensannahmen. Sie bieten niedrigere Transaktionsgebühren und einen höheren Transaktionsdurchsatz. Mehr zu Sidechains und Validiums.",
+ "page-layer-2-learn-callout-1-title": "Was sind die Vorteile?",
+ "page-layer-2-learn-callout-1-description": "Erkunden Sie die praktischen Auswirkungen von Layer-2-Lösungen auf die Benutzererfahrung.",
+ "page-layer-2-learn-learn-more": "Mehr erfahren",
+ "page-layer-2-learn-callout-2-title": "Erkunden Sie unterschiedliche Netzwerke",
+ "page-layer-2-learn-callout-2-description": "Lernen Sie, wie sich die Netzwerke voneinander unterscheiden und wie weit sie in ihrer Entwicklung sind.",
+ "page-layer-2-learn-explore-networks": "Netzwerk erkunden"
+}
diff --git a/src/intl/de/page-layer-2-networks.json b/src/intl/de/page-layer-2-networks.json
new file mode 100644
index 00000000000..a19ddde6745
--- /dev/null
+++ b/src/intl/de/page-layer-2-networks.json
@@ -0,0 +1,85 @@
+{
+ "page-layer-2-networks-hero-description": "Die heutige Nutzung von Ethereum bedeutet die Interaktion mit Hunderten von verschiedenen Netzwerken und Apps. Alle werden von Ethereum als grundlegendem Rückgrat unterstützt.",
+ "page-layer-2-networks-meta-title": "Ethereum Layer 2: Netzwerke erkunden",
+ "page-layer-2-networks-more-advanced-title": "Suchen Sie nach einem fortgeschritteneren Überblick?",
+ "page-layer-2-networks-more-advanced-descripton-1": "Viele der Projekte sind",
+ "page-layer-2-networks-more-advanced-descripton-2": "noch jung und etwas experimentell.",
+ "page-layer-2-networks-more-advanced-descripton-3": "Für weitere Informationen zur Technologie, den Risiken und Vertrauensannahmen dieser Netzwerke empfehlen wir L2BEAT, das einen umfassenden Risikobewertungsrahmen für jedes Projekt bietet, sowie growthepie für die allgemeine Datenanalyse.",
+ "page-layer-2-networks-more-advanced-link-1": "Besuchen Sie l2beat.com",
+ "page-layer-2-networks-more-advanced-link-2": "Besuchen Sie growthepie.com",
+ "page-layer-2-networks-callout-1-title": "Was sind die Vorteile?",
+ "page-layer-2-networks-callout-1-description": "Die Stärke und Sicherheit von Ethereum bieten eine Plattform, auf der andere Netzwerke aufbauen können.",
+ "page-layer-2-networks-callout-2-title": "Sind Sie an mehr Details interessiert?",
+ "page-layer-2-networks-callout-2-description": "Neugierig auf die Technologie und die Gründe für diesen Skalierungsansatz? Erfahren Sie mehr über die zugrunde liegenden Überlegungen und die verschiedenen technologischen Ansätze.",
+ "page-layer-2-networks-n/a-label": "N/V",
+ "page-layer-2-networks-n/a-description": "Nicht auf das Ethereum Mainnet anwendbar.",
+ "page-layer-2-networks-robust-label": "Robust",
+ "page-layer-2-networks-robust-description": "Vollständig dezentralisiertes und sicheres Netzwerk, das von keiner Einzelperson oder Gruppe, einschließlich seiner Ersteller, manipuliert oder gestoppt werden kann.\n\nDies ist ein Netzwerk, das die Vision von Ethereum der Dezentralisierung erfüllt.",
+ "page-layer-2-networks-maturing-label": "Reifend",
+ "page-layer-2-networks-maturing-description": "Ein Netzwerk, das sich im Übergang zur Dezentralisierung befindet. Eine Gruppe von Akteuren kann das Netzwerk in extremen Situationen möglicherweise noch anhalten.",
+ "page-layer-2-networks-developing-label": "In Entwicklung",
+ "page-layer-2-networks-developing-description": "Ein zentralisierter Betreiber betreibt das Netzwerk, fügt aber ausfallsichere Funktionen hinzu, um die Risiken der Zentralisierung zu verringern.",
+ "page-layer-2-networks-emerging-label": "Aufstrebend",
+ "page-layer-2-networks-emerging-description": "Ein zentralisierter Betreiber betreibt das Netzwerk. Die Daten sind auf Ethereum öffentlich einsehbar, um zu überprüfen, ob der Betreiber ehrlich ist.",
+ "page-layer-2-networks-network-maturity": "Netzwerkreife",
+ "page-layer-2-networks-network-maturity-with-colon": "Netzwerkreife:",
+ "page-layer-2-networks-network-maturity-description": "Betrachtet die Entwicklungsphase, die mit der Nutzung des Netzwerks verbundenen Risiken und die Größe des Ökosystems des Netzwerks.",
+ "page-layer-2-networks-summary-metric": "Dies ist eine zusammenfassende Metrik, die auf einer Risikoanalyse von",
+ "page-layer-2-networks-no-results-title": "Keine Ergebnisse",
+ "page-layer-2-networks-no-results-description": "Es gibt keine Netzwerke, die Ihren Kriterien entsprechen. Versuchen Sie, einige Filter hinzuzufügen.",
+ "page-layer-2-networks-reset-filters": "Filter zurücksetzen",
+ "page-layer-2-networks-age": "Alter",
+ "page-layer-2-networks-show-how-long": "Zeigt, wie lange das Netzwerk bereits in Betrieb ist.",
+ "page-layer-2-networks-data-from": "Daten von",
+ "page-layer-2-networks-period": ".",
+ "page-layer-2-networks-wallet-support": "Wallet-Support",
+ "page-layer-2-networks-how-many-wallet-support": "Gibt an, wie viele Wallet-Apps die Nutzung des Netzwerks unterstützen.",
+ "page-layer-2-networks-active-address": "Aktive Adressen",
+ "page-layer-2-networks-active-address-weekly": "Aktive Adressen (wöchentlich)",
+ "page-layer-2-networks-active-address-number": "Anzahl der aktiven Adressen im Netzwerk in den letzten 7 Tagen.",
+ "page-layer-2-networks-fee-token": "Gebühren-Token",
+ "page-layer-2-networks-token-used-to-pay": "Der Token, der zur Bezahlung von Transaktionen und zur Nutzung des Netzwerks verwendet wird.",
+ "page-layer-2-networks-network-usage": "Netzwerknutzung",
+ "page-layer-2-networks-network-usage-overview": "Ein Überblick über die Netzwerknutzung. Misst die Anzahl der Transaktionen in den jeweiligen Bereichen innerhalb der letzten 30 Tage.",
+ "page-layer-2-networks-no-data-available": "Keine Daten verfügbar",
+ "page-layer-2-networks-links": "Links",
+ "page-layer-2-networks-official-website": "Offizielle Website",
+ "page-layer-2-networks-risk-analysis": "Risikoanalyse",
+ "page-layer-2-networks-assessment-by-l2beat": "Bewertung durch L2BEAT",
+ "page-layer-2-networks-detailed-analytics": "Detaillierte Analysen",
+ "page-layer-2-networks-assessment-by-growthepie": "Bewertung durch growthepie",
+ "page-layer-2-networks-bridge-to": "Brücke zu",
+ "page-layer-2-networks-view-apps": "Apps ansehen",
+ "page-layer-2-networks-select-wallet": "Wallet auswählen",
+ "page-layer-2-networks-search-wallets": "Wallets suchen...",
+ "page-layer-2-networks-no-wallet-found": "Keine Wallets gefunden",
+ "page-layer-2-networks-robust-description-1": "Vollständig dezentralisiertes und sicheres Netzwerk, das von keiner Einzelperson oder Gruppe, einschließlich seiner Ersteller, manipuliert oder gestoppt werden kann.",
+ "page-layer-2-networks-robust-description-2": "Dies ist ein Netzwerk, das die Vision von Ethereum der Dezentralisierung erfüllt.",
+ "page-layer-2-networks-developing-description-1": "Ein einzelner Betreiber betreibt das Netzwerk mit öffentlicher Dateneinsicht zur Gewährleistung von Transparenz.",
+ "page-layer-2-networks-emerging-description-1": "Ein einzelner Betreiber betreibt das Netzwerk privat und arbeitet auf Transparenz hin.",
+ "page-layer-2-networks-networks-showing": "Angezeigte Netzwerke",
+ "page-layer-2-networks-market-share": "Marktanteil",
+ "page-layer-2-networks-market-share-description": "Gesamtwert, der in Treuhandverträgen auf Ethereum gesperrt ist.",
+ "page-layer-2-networks-avg-transaction-fee": "Durchschn. Transaktionsgebühr",
+ "page-layer-2-networks-transaction-fee": "Transaktionsgebühr",
+ "page-layer-2-networks-transaction-fee-description": "Die durchschnittlichen Transaktionskosten für Überweisungen, Swaps, Minting und andere Aktivitäten.",
+ "page-layer-2-networks-transaction-see-networks": "Netzwerke ansehen",
+ "page-layer-2-network-maturity-component-1": "Wir überprüfen den Fortschritt des Netzwerks in Richtung",
+ "page-layer-2-network-maturity-component-2": "Ausrichtung auf Ethereum",
+ "page-layer-2-network-maturity-component-3": "gesperrter Gesamtwert (TVL)",
+ "page-layer-2-network-maturity-component-4": "Zeit im Produktivbetrieb",
+ "page-layer-2-network-maturity-component-5": "und Risikoerwägungen",
+ "page-layer-2-network-maturity-component-6": "Diese Stufen helfen, die Entwicklung des Netzwerks zu verfolgen und bieten der Community eine standardisierte Möglichkeit, den Fortschritt zu bewerten.",
+ "page-layer-2-network-maturity-component-7": "Technischer Fortschritt allein reicht nicht aus, Nutzerakzeptanz und Alter sind ein wesentlicher Bestandteil der Gesamtstärke und Reife eines jeden Netzwerks.",
+ "page-layer-2-network-maturity-component-8": "Reife",
+ "page-layer-2-network-maturity-component-9": "Voraussetzungen",
+ "page-layer-2-network-maturity-component-10": "• Stufe 2",
+ "page-layer-2-network-maturity-component-11": "• Mindestens 1 Mrd. $ TVL",
+ "page-layer-2-network-maturity-component-12": "• Stufe 1",
+ "page-layer-2-network-maturity-component-13": "• Mindestens 150 Mio. $ TVL",
+ "page-layer-2-network-maturity-component-14": "• 6+ Monate im Produktivbetrieb",
+ "page-layer-2-network-maturity-component-15": "• Stufe 0",
+ "page-layer-2-network-maturity-component-16": "• Risikobewertung: 3/5 (L2beat)",
+ "page-layer-2-network-maturity-component-17": "• Risikobewertung: 2/5 (L2beat)",
+ "page-layer-2-network-maturity-component-18": "• Mindestens 150 Mio. $ TVL oder 6+ Monate im Produktivbetrieb"
+}
diff --git a/src/intl/de/page-layer-2.json b/src/intl/de/page-layer-2.json
new file mode 100644
index 00000000000..fdec84185e8
--- /dev/null
+++ b/src/intl/de/page-layer-2.json
@@ -0,0 +1,61 @@
+{
+ "page-layer-2-hero-title": "Ebene 2",
+ "page-layer-2-hero-header": "Ethereum-Netzwerke",
+ "page-layer-2-hero-description": "Nutzen Sie Ethereum zu einem Bruchteil der Kosten.",
+ "page-layer-2-hero-button-2-content": "Mehr erfahren",
+ "page-layer-2-period": ".",
+ "page-layer-2-calloutCard-1-title": "$0.01 Gebühren",
+ "page-layer-2-calloutCard-1-description": "Sie können handeln, weltweit Geld senden oder Anwendungen nutzen, ohne sich über hohe Kosten Sorgen zu machen.",
+ "page-layer-2-calloutCard-2-title": "Fast sofortige Transaktionen",
+ "page-layer-2-calloutCard-2-description": "Ob Sie eine schnelle Zahlung tätigen oder Dezentralisierte Finanzen (DeFi) nutzen, alle Transaktionen werden in nur wenigen Sekunden abgeschlossen.",
+ "page-layer-2-calloutCard-3-title": "Durch Ethereum gestützt",
+ "page-layer-2-calloutCard-3-description": "Die bewährte und dezentrale Ethereum-Blockchain dient als Abwicklungsschicht für andere, neuere Netzwerke.",
+ "page-layer-2-meta-title": "Einführung in Ethereum Layer 2: Vorteile und Nutzen",
+ "page-layer-2-meta-description": "Lernen Sie über Ethereum Layer-2-Netzwerke",
+ "page-layer-2-powered-by-ethereum-title": "Unterstützt durch Ethereum",
+ "page-layer-2-powered-by-ethereum-description-1": "Ethereum ist nicht länger nur ein einzelnes Netzwerk.",
+ "page-layer-2-powered-by-ethereum-description-2": "Mit Hunderten von Blockchains, die mittlerweile darauf aufgebaut sind, ist Ethereum kostengünstiger, schneller und zugänglicher für den täglichen Gebrauch geworden.",
+ "page-layer-2-powered-by-ethereum-description-3": "Gestalten Sie die Zukunft mit, indem Sie einem der vielen Netzwerke beitreten, die von Ethereum betrieben werden!",
+ "page-layer-2-man-and-dog-alt": "Mann und Hund spielen",
+ "page-layer-2-blockchain-transaction-cost": "Durchschnittliche Transaktionskosten auf der Ethereum-Blockchain",
+ "page-layer-2-networks-transaction-cost": "Durchschnittliche Transaktionskosten auf Ethereum, gestützt von Netzwerken",
+ "page-layer-2-network-of-networks-title": "Das Netzwerk der Netzwerke",
+ "page-layer-2-network-of-networks-description": "Die Stärke und Sicherheit von Ethereum bietet eine Plattform, auf die andere Netzwerke bauen können. Mit einem einzelnen Konto ist alles kompatibel und nahtlos verbunden. ",
+ "page-layer-2-ethereum-logo-alt": "Ethereum",
+ "page-layer-2-ready-to-start-title": "Sind Sie startklar?",
+ "page-layer-2-ready-to-start-description": "Werfen Sie einen Blick auf alle verschiedenen Netzwerke, die für Sie verfügbar sind.",
+ "page-layer-2-ready-to-start-button": "Netzwerk erkunden",
+ "page-layer-2-go": "Go",
+ "page-layer-2-walking-alt": "Gehen",
+ "page-layer-2-why-do-we-need-multiple-networks-1": "Warum benötigen wir mehrere Netzwerke auf Ethereum?",
+ "page-layer-2-why-do-we-need-multiple-networks-2": "Warum gibt es all diese Netzwerke und nicht nur ein Ethereum-Netzwerk?",
+ "page-layer-2-faq-title": "Häufig gestellte Fragen",
+ "page-layer-2-faq-ExpandableCard-1-title": "Woher weiß ich, dass ein Netzwerk Teil von Ethereum ist?",
+ "page-layer-2-faq-ExpandableCard-1-description-1": "Es gibt viele verschiedene Möglichkeiten, Netzwerke in Bezug auf Ethereum zu kategorisieren. Zahlreiche Netzwerke beanspruchen, Ethereum zu skalieren, um an Bekanntheit zu gewinnen. Eine klare Perspektive besteht jedoch darin, ob das Netzwerk seine Daten auf dem Ethereum-Hauptnetz speichert. Dies erhöht die Sicherheit der Nutzer erheblich und unterstützt Ethereums visionäres Ziel eines genehmigungsfreien Netzwerks. Solche Projekte werden häufig als ‚Rollups‘ bezeichnet. Wenn Daten an anderer Stelle gespeichert werden, handelt es sich bei dem Projekt nicht um eine direkte Erweiterung von Ethereum, sondern eher um ein unabhängiges Netzwerk. Werfen Sie einen Blick auf einige der beliebtesten",
+ "page-layer-2-faq-ExpandableCard-1-description-2": "Manche Branchen brauchen vielleicht nicht so eine enge direkte Beziehung, wie zum Beispiel Gaming oder nicht-finanzielle Anwendungen, wo andere Technologien besser passen.",
+ "page-layer-2-faq-ExpandableCard-2-title": "Sind diese Netzwerke sicher?",
+ "page-layer-2-faq-ExpandableCard-2-description-1": "Während sie zwar grundsätzlich mit robusten Sicherheitsfunktionen ausgestattet sind, hängt ihre Sicherheit von der zugrunde liegenden Technologie, der Sicherheit der Smart Contracts und",
+ "page-layer-2-faq-ExpandableCard-2-link": "der Reife des Netzwerks ab",
+ "page-layer-2-faq-ExpandableCard-2-description-2": "Anwender sollten eine sorgfältige Prüfung vornehmen, zunächst mit kleineren Transaktionen beginnen und sich kontinuierlich über aktuelle Entwicklungen informieren, um eine sichere Nutzung zu gewährleisten.",
+ "page-layer-2-faq-ExpandableCard-3-title": "Warum kann Ethereum seine eigene Blockchain nicht skalieren, anstatt auf diese Netzwerke angewiesen zu sein?",
+ "page-layer-2-faq-ExpandableCard-3-description": "Ethereum kann sein eigenes Hauptnetzwerk nicht ohne Weiteres skalieren, da es sicher und dezentral bleiben muss. Eine Beschleunigung des Hauptnetzwerks könnte die Sicherheit verringern und zu stärkerer Zentralisierung führen. Ethereum-Netzwerke tragen dazu bei, indem sie Transaktionen außerhalb des Hauptnetzwerks verarbeiten und dieses lediglich zur Absicherung nutzen. Auf diese Weise kann Ethereum mehr Transaktionen bewältigen, ohne Sicherheit oder Dezentralisierung einzubüßen.",
+ "page-layer-2-faq-ExpandableCard-4-title": "Warum gibt es keine 'offiziellen' Ethereum-Netzwerke?",
+ "page-layer-2-faq-ExpandableCard-4-description": "So wie es keinen „offiziellen“ Ethereum-Client gibt, wird es für Ethereum auch keinen „offiziellen“ Layer 2 geben. Ethereum ist frei zugänglich. Aus technischer Sicht kann daher jeder einen Layer 2 erstellen! So wird es von den verschiedensten Teams jeweils spezifische Layer-2-Versionen mit unterschiedlichen Designansätzen geben, die für individuelle Anwendungsfälle optimiert sind. Davon kann das Ökosystem insgesamt nur profitieren. Genauso wie es verschiedene Ethereum-Clients von den verschiedensten Teams gibt, die im Netzwerk für Diversität sorgen, wird in Zukunft auch eine große Vielfalt an Layer 2 entstehen.",
+ "page-layer-2-callout-1-title": "Erkunden Sie unterschiedliche Netzwerke",
+ "page-layer-2-callout-1-description": "Lernen Sie, wie sich die Netzwerke voneinander unterscheiden und wie weit sie in ihrer Entwicklung sind.",
+ "page-layer-2-callout-2-title": "Sind Sie an mehr Details interessiert?",
+ "page-layer-2-callout-2-description": "Neugierig auf die Technologie und die Gründe für diesen Skalierungsansatz? Erfahren Sie mehr über die zugrunde liegenden Überlegungen und die verschiedenen technologischen Ansätze.",
+ "page-layer-2-arbitrum-description": "Arbitrum One ist ein universell einsetzbares Optimistic Rollup, entwickelt von Offchain Labs und verwaltet durch das Arbitrum DAO.",
+ "page-layer-2-base-description": "Base ist ein Optimistic Rollup, das mit dem OP Stack entwickelt wurde. Es bietet eine kostengünstige und entwicklerfreundliche Möglichkeit, dass jeder – überall – Onchain-Anwendungen erstellen kann.",
+ "page-layer-2-optimism-description": "OP Mainnet ist ein EVM-äquivalentes Optimistic Rollup. Es zielt darauf ab, schnell, einfach und sicher zu sein.",
+ "page-layer-2-blast-description": "Blast ist ein EVM-kompatibles Optimistic Rollup, das native Renditen unterstützt.",
+ "page-layer-2-zksync2-description": "ZKsync Era ist ein universell einsetzbares ZK-Rollup mit vollständiger Kompatibilität zur EVM.",
+ "page-layer-2-linea-description": "Linea ist ein ZK-Rollup auf Basis der Consensys zkEVM, das zur Skalierung des Ethereum-Netzwerks entwickelt wurde.",
+ "page-layer-2-scroll-description": "Scroll ist ein ZK-Rollup, das die Fähigkeiten von Ethereum durch ZK-Technologie und EVM-Kompatibilität erweitert.",
+ "page-layer-2-starknet-description": "Starknet ist ein universell einsetzbares ZK-Rollup, das auf STARKs und der Cairo VM basiert.",
+ "page-layer-2-mode-description": "Mode ist ein Optimistic Rollup auf Basis des OP Stack, das die AIFi-Ökonomie („Artificial Intelligence Finance“) durch Künstliche Intelligenz (KI) aufbaut.",
+ "page-layer-2-taiko-description": "Taiko ist ein dezentrales, Ethereum-äquivalentes ZK-EVM-Rollup, das nahtlose kettenübergreifende Kommunikation ermöglicht.",
+ "page-layer-2-unichain-description": "Unichain ist ein DeFi-nativer Ethereum L2, der als Heimat für Liquidität über verschiedene Chains hinweg entwickelt wurde.",
+ "page-layer-2-ink-description": "Ink ist eine Ethereum OP Stack Layer-2-Blockchain, die als Zuhause von DeFi für die Superchain konzipiert ist; eine leistungsstarke Basisschicht für die Bereitstellung innovativer DeFi-Protokolle.",
+ "page-layer-2-zircuit-description": "Zircuit ist ein EVM-kompatibler ZK-Rollup mit KI-gestützter Sicherheit auf Sequencer-Ebene, um bösartige Transaktionen zu erkennen und zu verhindern."
+}
diff --git a/src/intl/de/page-learn.json b/src/intl/de/page-learn.json
index 9f94a96b2fe..b4f0f585ab3 100644
--- a/src/intl/de/page-learn.json
+++ b/src/intl/de/page-learn.json
@@ -1,4 +1,5 @@
{
+ "about-ethereum-video-series": "Videoserie über Ethereum",
"toc-learn-hub": "Lernhub",
"toc-what-is-crypto-ethereum": "Was ist Ethereum?",
"toc-how-do-i-use-ethereum": "Wie nutze ich Ethereum?",
@@ -10,6 +11,7 @@
"hero-header": "Mehr über Ethereum erfahren",
"hero-subtitle": "Ihr Bildungshandbuch zur Welt von Ethereum. Hier können Sie erfahren, wie Ethereum funktioniert und wie Sie eine Verbindung dazu herstellen. Auf dieser Seite finden Sie sowohl technische als auch nicht-technische Artikel, Anleitungen und Ressourcen.",
"hero-button-lets-get-started": "Los geht's",
+ "page-learn-meta-title": "Ethereum: Ein umfassender Lernleitfaden",
"what-is-crypto-1": "Sie haben vielleicht bereits von Kryptowährungen, Bitcoin und Blockchain gehört. Über die Links unten gelangen Sie zu Informationen, um mehr darüber zu erfahren, worum es sich konkret handelt und wie Ethereum damit zusammenhängt.",
"what-is-crypto-2": "Kryptowährungen wie Bitcoin ermöglichen es jeder Person, weltweit Geld zu überweisen. Ethereum kann das auch, aber es kann auch einen Code ausführen, mithilfe dessen sich Anwendungen und Organisationen kreieren lassen. Es ist sowohl widerstandsfähig als auch flexibel: Jedes Computerprogramm kann auf Ethereum laufen. Erfahren Sie mehr und finden Sie heraus, wie Sie anfangen können:",
"what-is-ethereum-card-title": "Was ist Ethereum?",
@@ -33,16 +35,16 @@
"find-a-wallet-card-title": "Finden Sie eine Wallet",
"find-a-wallet-card-description": "Durchsuchen Sie die Geldbörsen nach den für Sie wichtigen Funktionen.",
"find-a-wallet-button": "Liste der Wallets",
- "crypto-security-basics-card-title": "Grundlagen zur Sicherheit",
- "crypto-security-basics-card-description": "Lernen Sie, wie Sie Betrugsversuche erkennen und die häufigsten Tricks vermeiden können.",
- "crypto-security-basics-card-button": "Bleiben Sie sicher",
+ "ethereum-networks-card-title": "Ethereum-Netzwerke",
+ "ethereum-networks-card-description": "Sparen Sie Geld, indem Sie günstigere und schnellere Ethereum-Erweiterungen verwenden.",
+ "ethereum-networks-card-button": "Netzwerk auswählen",
"things-to-consider-banner-title": "Was Sie bei der Nutzung von Ethereum beachten sollten",
"things-to-consider-banner-1": "Jede Ethereum-Transaktion erfordert eine Gebühr in Form von ETH, selbst wenn Sie verschiedene Token bewegen müssen, die auf Ethereum aufgebaut sind, wie zum Beispiel die Stablecoins USDC oder DAI.",
"things-to-consider-banner-2": "Gebühren können hoch sein, abhängig von der Anzahl der Personen, die Ethereum nutzen möchten, daher empfehlen wir die Verwendung von",
"things-to-consider-banner-layer-2": "Layer 2",
"additional-reading-more-on-using-ethereum": "Mehr zur Verwendung von Ethereum",
- "additional-reading-how-to-create-an-ethereum-account": "So erstellen Sie ein Ethereum-Konto",
- "additional-reading-how-to-use-a-wallet": "So verwenden Sie eine Wallet",
+ "additional-reading-how-to-create-an-ethereum-account": "So erstellst du ein Ethereum-Konto",
+ "additional-reading-how-to-use-a-wallet": "So verwendest du eine Wallet",
"additional-reading-layer-2": "Layer 2: Senkung der Transaktionsgebühren",
"what-is-ethereum-used-for-1": "Durch Ethereum wurden neue Produkte und Dienstleistungen geschaffen, die verschiedene Bereiche unseres Lebens verbessern können. Wir befinden uns noch in den frühen Phasen, aber es gibt viele spannende Entwicklungen, auf die man sich freuen kann.",
"defi-card-title": "Dezentrale Finanzen (DeFi)",
@@ -57,9 +59,9 @@
"dao-card-title": "Dezentralisierte Autonome Organisationen (DAO)",
"dao-card-description": "Sie eröffnen neue Möglichkeiten, Arbeit ohne Vorgesetzte zu organisieren.",
"dao-card-button": "Was sind DAOs?",
- "dapp-card-title": "Dezentralisierte Anwendungen (dApps)",
+ "dapp-card-title": "Ethereum-Anwendungen",
"dapp-card-description": "Erzeugen eine digitale Ökonomie von Peer-to-Peer-Diensten.",
- "dapp-card-button": "Entdecken Sie dApps",
+ "dapp-card-button": "Was sind Apps?",
"emerging-use-cases-title": "Neue Anwendungsfälle",
"emerging-use-cases-description": "Es gibt auch andere bedeutende Branchen, die durch Ethereum entstehen oder verbessert werden:",
"play-to-earn": "Spiele um Geld zu verdienen (P2E)",
@@ -85,7 +87,7 @@
"ethereum-whitepaper-card-button": "Lesen Sie das Whitepaper",
"more-on-ethereum-protocol-title": "Mehr zum Ethereum-Protokoll",
"more-on-ethereum-protocol-ethereum-for-developers": "Ethereum für Entwickler",
- "more-on-ethereum-protocol-consensus": "Ethereums Proof-of-Stake-basierter Konsensmechanismus.",
+ "more-on-ethereum-protocol-consensus": "Ethereums Proof of Stake basierter Konsensmechanismus",
"more-on-ethereum-protocol-evm": "Ethereums integrierter Computer (Die EVM)",
"more-on-ethereum-protocol-nodes-and-clients": "Ethereums Nodes und Clients",
"ethereum-community-description": "Der Erfolg von Ethereum ist der unglaublich engagierten Community zu verdanken. Tausende von inspirierenden und engagierten Menschen tragen dazu bei, die Vision von Ethereum voranzutreiben, und sorgen gleichzeitig für die Sicherheit des Netzwerks durch Staking und Governance. Schließen Sie sich uns an und seien Sie dabei.",
@@ -116,6 +118,8 @@
"zeroknowledge-description": "Taucht tief ein in die Technologie, die das entstehende dezentrale Web antreiben wird, und die Gemeinschaft, die daran arbeitet",
"green-pill-title": "Green Pill",
"green-pill-description": "Erläutert die kryptoökonomischen Systeme, die positive externe Effekte für die Welt schaffen",
+ "ethereum-basics-title": "Ethereum-Grundlagen",
+ "ethereum-basics-description": "Lernen Sie die Grundlagen der Ethereum-Netzwerkarchitektur mit einer leicht verständlichen Videoserie.",
"unchained-title": "Unchained",
"unchained-description": "Taucht tief ein in die Menschen, die das dezentralisierte Internet aufbauen, die Details dieser Technologie, die unsere Zukunft unterstützen könnte, und einige der kniffligsten Themen in der Kryptowelt wie Regulierung, Sicherheit und Privatsphäre",
"the-daily-gwei-title": "The Daily Gwei",
diff --git a/src/intl/de/page-resources.json b/src/intl/de/page-resources.json
new file mode 100644
index 00000000000..23f3b836056
--- /dev/null
+++ b/src/intl/de/page-resources.json
@@ -0,0 +1,97 @@
+{
+ "page-resources-network-title": "Das Netzwerk",
+ "page-resources-using-title": "Ethereum verwenden",
+ "page-resources-scaling-title": "Ethereum zu skalieren",
+ "page-resources-resilience-title": "Die Widerstandsfähigkeit von Ethereum",
+ "page-resources-privacy-security-title": "Datenschutz & Sicherheit",
+ "page-resources-network-layer2-title": "Ethereum-Netzwerk - Layer 2",
+ "page-resources-network-layer2-chart-label": "Mittlere Transaktionskosten auf Ethereum-Netzwerken",
+ "page-resources-network-layer2-l2beat-description": "L2BEAT wurde entwickelt, um transparente und überprüfbare Einblicke in neue Layer 2 (L2) Technologien zu geben, die im Einklang mit dem rollup-fokussierten Ethereum-Skalierungsplan stehen und die Skalierung mit Ethereum unterstützen sollen.",
+ "page-resources-network-layer2-growthepie-description": "growthepie visualisiert die Nutzung und das Wachstum des Ethereum-Mainnets und von Layer 2s. Echtzeit-Gebühren, Wirtschaftsdaten, Anwendungsnutzung, Stablecoin-Daten, datengestützte Artikel und vieles mehr.",
+ "page-resources-block-explorers-title": "Block Explorer",
+ "page-resources-block-explorers-chart-label": "Zeit bis zum nächsten Block",
+ "page-resources-block-explorers-blockscout-description": "Open-Source Block-Explorer von Blockscout mit vollständigen Blockchain-Data und APIs für Ethereum-Netzwerken.",
+ "page-resources-block-explorers-etherscan-description": "Etherscan ist ein Block-Explorer und eine Analyseplattform für Ethereum, eine dezentrale Smart-Contract Plattform.",
+ "page-resources-block-explorers-beaconchain-description": "Open-Source Explorer für Ethereum, der das Ethereum-Mainnet darstellt",
+ "page-resources-block-explorers-txcity-description": "Ein witziges Tool zur Visualisierung von Ethereum-Blöcken in Echtzeit.",
+ "page-resources-block-explorers-panda-ops-description": "Live-Dashboard für die Blockproduktion der Ethereum Beacon-Chain, bereitgestellt von ethPandaOps. ",
+ "page-resources-block-explorers-otterscan-description": "Ein blitzschneller, lokaler, selbst gehosteter Ethereum-Block-Explorer",
+ "page-resources-eth-asset-title": "ETH als Wertanlage",
+ "page-resources-eth-asset-etherealize-description": "Ethereum ist die größte, sicherste und transparenteste Blockchain der Welt. Und Ethereum ist bereit für Ihr Business.",
+ "page-resources-eth-asset-ultrasound-description": "Ultra Sound Money ist ein Ethereum-Meme, das die wahrscheinliche Verringerung des ETH-Angebots thematisiert.",
+ "page-resources-eth-asset-ethismoney-description": "ETH is money bezeichnet eine Community von Überzeugten, die ETH als Geld halten, staken und verbreiten.",
+ "page-resources-gas-title": "Ressourcen",
+ "page-resources-gas-etherscan-description": "Verfolgen Sie alle KPIs zum Gas.",
+ "page-resources-gas-ethgastracker-description": "Überwachen Sie die Gaspreise auf Ethereum und L2s.",
+ "page-resources-gas-blocknative-description": "Die präziseste Gasgebühren-Prognose im gesamten Web3.",
+ "page-resources-gas-gasfees-description": "Daten-Tracker für Gaskosten in Ethereum-Netzwerken.",
+ "page-resources-defi-title": "DeFi",
+ "page-resources-defi-defillama-description": "DefiLlama ist der größte TVL-Aggregator für DeFi (Decentralized Finance).",
+ "page-resources-defi-eigenphi-description": "Wollen Sie DeFi-Transaktionen und Handelsstrategien verstehen?",
+ "page-resources-defi-defiscan-description": "Verifizierbare Einblicke in die Entwicklung und Risiken von DeFi.",
+ "page-resources-stablecoins-title": "Stablecoins",
+ "page-resources-stablecoins-stablecoinswtf-description": "Die Website verfolgt das Ziel, Degens über Stablecoins aufzuklären.",
+ "page-resources-stablecoins-visa-description": "Das Visa Onchain Analytics Dashboard veranschaulicht, wie fiat-gestützte Stablecoins weltweit über öffentliche Blockchains bewegt werden.",
+ "page-resources-stablecoins-rwa-description": "Erkunden Sie die Aktivitäten hinter Krypto- und Asset-gestützten Stablecoins.",
+ "page-resources-nft-title": "NFT",
+ "page-resources-nft-etherscan-description": "Die besten NFT-Verträge",
+ "page-resources-nft-nftgo-description": "Echtzeitdaten zum globalen NFT-Markt.",
+ "page-resources-applications-title": "Anwendungen",
+ "page-resources-applications-ecosystem-description": "Tauchen Sie ein in das Ethereum-Ökosystem und lernen Sie Hunderte von beliebten Apps und Tools kennen.",
+ "page-resources-applications-farcaster-description": "Nutzungsdaten von Farcaster.",
+ "page-resources-applications-dappradar-description": "Stöbern Sie durch die besten Blockchain-Dapps, NFTs, Spiele, DeFi-Projekte, Tokens und Airdrops. Verfolgen Sie Rankings, erkunden Sie Markttrends, finden Sie angesagt Projekte und sichern Sie sie Belohnungen mit dem weltweiten Dapp-Store.",
+ "page-resources-adoption-title": "Ethereum-Adoption",
+ "page-resources-adoption-ethereumadoption-description": "Eine Liste der wichtigsten Akteure, die auf Ethereum bauen.",
+ "page-resources-adoption-cryptowerk-description": "Analysen zur Ethereum-Adoption basierend auf der Cryptwerk-Händlerdatenbank - Karte, Länder, Unternehmen, Geschäfte, Kategorien, Rating.",
+ "page-resources-adoption-reserves-description": "Ein Dashboard für die Strategic Ethereum Reserve-Initiative.",
+ "page-resources-roadmap-title": "Ethereum-Roadmap",
+ "page-resources-roadmap-metric-label": "Neuestes Upgrade",
+ "page-resources-roadmap-ethroadmap-description": "Detaillierte Visualisierung der Ethereum-Roadmap und des nächsten Netzwerk-Upgrades.",
+ "page-resources-blobs-title": "Blobs",
+ "page-resources-blobs-metric-total-label": "Blobs insgesamt",
+ "page-resources-blobs-metric-fee-label": "Durchschnittliche Blob-Gebühr",
+ "page-resources-blobs-blobscan-description": "Umfassender Blob-Scanner.",
+ "page-resources-blobs-blobsguru-description": "Ethereum Blobs Explorer: Analysieren Sie L2-Transaktionen & EIP-4844-Daten.",
+ "page-resources-nodes-title": "Nodes",
+ "page-resources-nodes-nodewatch-description": "Nodes-Übersicht.",
+ "page-resources-nodes-ethernodes-description": "Statistiken zum Ethereum-Mainnet.",
+ "page-resources-nodes-etherscan-description": "Täglich.",
+ "page-resources-nodes-luckystaker-description": "Tägliche Wahrscheinlichkeit, dass ein Vorschlag einen Block erhält.",
+ "page-resources-nodes-pectrified-description": "Statistiken zum Ethereum Pectra-Fork für Validatoren.",
+ "page-resources-nodes-validatorqueue-description": "Dashboard zur Anzeige der Ein- und Austrittswarteschlange des Ethereum-Validator inklusive der geschätzten Wartezeit.",
+ "page-resources-network-resilience-title": "Netzwerk Widerstandsfähigkeit",
+ "page-resources-network-resilience-neutralitywatch-description": "Ethereum-Zensur-Monitor.",
+ "page-resources-network-resilience-sunshine-description": "Dashboard zur Messung der Gesundheit der Ethereum-Dezentralisierung.",
+ "page-resources-network-resilience-clientdiversity-description": "Stärken Sie die Resilienz von Ethereum, indem Sie einen weniger genutzten Client einsetzen.",
+ "page-resources-network-resilience-supermajority-description": "Risiken von Supermajority-Clients im Ethereum Execution Layer, insbesondere die Client-Nutzung von Staking-Diensten.",
+ "page-resources-attestations-title": "Beglaubigungen",
+ "page-resources-attestations-eas-description": "EAS ermöglicht es jedem, Onchain und Offchain Attestierungen auf Ethereum zu erstellen und zu validieren.",
+ "page-resources-relays-title": "Relays",
+ "page-resources-relays-beaconchain-description": "Validatoren können Relays nutzen, um ihre Blockproduktion an spezialisierte Entitäten auszulagern, die zusätzliche Einnahmen generieren.",
+ "page-resources-relays-ratednetwork-description": "Marktanteile von MEV-Relay, weitergeleiteter Gesamtwert, Wert pro Block und andere Statistiken für das Ethereum-Netzwerk. ",
+ "page-resources-relays-relayscan-description": "MEV-Boost Analysen.",
+ "page-resources-mev-title": "MEV",
+ "page-resources-mev-mevboost-description": "Die Website verfolgt das Ziel, Degens über Stablecoins aufzuklären.",
+ "page-resources-mev-mevwatch-description": "Einige MEV-Boost-Relays werden gemäß OFAC reguliert und können bestimmte Transaktionen zensieren. Mit diesem Tool können Sie sehen, welche Auswirkungen dies auf Ethereum-Blöcke hat.",
+ "page-resources-wallets-title": "Wallets",
+ "page-resources-wallets-wallet-beat-description": "Ein benutzerfreundliches Dashboard und Tool für Ethereum-Wallets",
+ "page-resources-wallets-bundlebear-description": "Dashboards und Analysen für ERC-4337 und EIP-7702 Smart-Accounts.",
+ "page-resources-zk-adoption-title": "ZK-Adoption",
+ "page-resources-zk-adoption-ethproofs-description": "SNARKS, die Ethereum skalieren.",
+ "page-resources-zk-adoption-l2beat-description": "Der ZK-Katalog von L2BEAT ist eine von der Community gepflegten Ressource, die detaillierte Einblicke in die ZK-Technologie bietet, die von verschiedenen Blockchain-Projekten eingesetzt wird.",
+ "page-resources-mempool-title": "Mempool",
+ "page-resources-mempool-mempool-description": "Ausgewählte Vergleichsvisualisierung des Ethereum-Mempools.",
+ "page-resources-meta-title": "Ethereum-Ressourcen-Dashboard",
+ "page-resources-meta-description": "Entdecken Sie eine Liste von Community geprüften Ressourcen, um stets über die wichtigsten Entwicklungen im Ethereum-Ökosystem informiert zu sein.",
+ "page-resources-hero-title": "Ressourcen",
+ "page-resources-hero-header": "Ethereum-Dashboards",
+ "page-resources-hero-description": "Entdecken Sie eine Liste von Community geprüften Ressourcen, um stets über die wichtigsten Entwicklungen im Ethereum-Ökosystem informiert zu sein.",
+ "page-resources-find-more": "Weitere großartige Ressourcen finden Sie unter ",
+ "page-resources-contribute-title": "Mitwirken",
+ "page-resources-contribute-description": "Dieses Dashboard ist eine lebendige Seite, die regelmäßig aktualisiert werden muss. Helfen Sie mit, die besten Ressourcen zu finden, um eine Übersicht über das Ethereum-Ökosystems zu geben. ",
+ "page-resources-suggest-resource": "Schlagen Sie eine Ressource vor",
+ "page-resources-found-bug": "Finden Sie einen Bug",
+ "page-resources-whats-on-this-page": "Was gibt's auf dieser Seite",
+ "page-resources-banner-notification-message": "Das Ressourcen-Dashboard ist neu!",
+ "page-resources-share-feedback": "Bitte teilen Sie uns Ihr Feedback mit."
+}
diff --git a/src/intl/de/page-roadmap-vision.json b/src/intl/de/page-roadmap-vision.json
index f2a221f1246..f80c648505a 100644
--- a/src/intl/de/page-roadmap-vision.json
+++ b/src/intl/de/page-roadmap-vision.json
@@ -14,7 +14,7 @@
"page-roadmap-vision-problems": "Aktuelle Probleme",
"page-roadmap-vision-scalability": "Skalierbarkeit",
"page-roadmap-vision-scalability-desc": "Ethereum muss mehr Transaktionen pro Sekunde verarbeiten können, ohne die Größe der Knoten im Netzwerk zu erhöhen. Knoten sind wichtige Netzwerkteilnehmer, die die Blockchain speichern und betreiben. Eine Vergrößerung der Knoten ist nicht praktikabel, da das nur diejenigen mit leistungsstarken und teuren Computern tun könnten. Für eine Skalierung benötigt Ethereum mehr Transaktionen pro Sekunde, gepaart mit mehr Knoten. Mehr Knoten bedeuten mehr Sicherheit.",
- "page-roadmap-vision-scalability-desc-3": "Layer-2-Rollups skalieren Ethereum, indem sie Transaktionen von der Chain nehmen und nur zusammengefasste Daten auf Ethereum posten. Durch diese Bündelung wird der Durchsatz von Ethereum erhöht, während die Kosten für Benutzer drastisch reduziert werden.",
+ "page-roadmap-vision-scalability-desc-3": "Layer-2-Rollups skalieren Ethereum, indem sie Transaktionen off-chain verarbeiten und nur Zusammenfassungsdaten auf Ethereum veröffentlichen. Diese Bündelung erhöht den Durchsatz von Ethereum und reduziert gleichzeitig die Kosten für Nutzer erheblich.",
"page-roadmap-vision-scalability-desc-4": "Rollups benötigen kostengünstigen Speicherplatz auf Layer 1, um Transaktionen für Benutzer so günstig wie möglich zu gestalten. Dies wird in Form von Blobs bereitgestellt, die an Ethereum-Blöcke angehängt werden. Im Laufe der Zeit werden viele Blobs an Ethereum-Blöcke angehängt, wodurch kostengünstiger Speicherplatz für viele Rollups bereitgestellt wird.",
"page-roadmap-vision-security": "Sicherheit",
"page-roadmap-vision-security-desc": "Die geplanten Upgrades verbessern Ethereums Sicherheit gegen koordinierte Angriffe.",
@@ -22,7 +22,7 @@
"page-roadmap-vision-security-desc-5": "Es ist jedoch auch wichtig, dass bald Upgrades implementiert werden, die Validatoren vor Denial-of-Service-Angriffen schützen, ihre Anonymität verbessern und das Erstellen von Blöcken von der Verbreitung von Blöcken trennen. Diese Upgrades schützen einzelne Validatoren und das gesamte Netzwerk vor Angriffen auf die Verfügbarkeit und Zensur.",
"page-roadmap-vision-security-desc-5-link": "Mehr über Proof-of-Stake",
"page-roadmap-vision-security-desc-10": "Staking bedeutet auch, dass Sie nicht in hochwertige Hardware investieren müssen, um direkt am Konsens teilzunehmen. Dies sollte mehr Menschen dazu ermutigen, Validator zu werden, was die Dezentralisierung des Netzwerks erhöht und die Angriffsfläche verkleinert.",
- "page-roadmap-vision-security-staking": "Stake ETH",
+ "page-roadmap-vision-security-staking": "ETH-Staking",
"page-roadmap-vision-security-validator": "Sie können Validator werden, indem Sie Ihre ETH staken.",
"page-roadmap-vision-staking-lower": "Mehr zum Staking",
"page-roadmap-vision-subtitle": "Lassen wir Ethereum wachsen, bis es mächtig genug ist, um der gesamten Menschheit zu helfen.",
diff --git a/src/intl/de/page-roadmap.json b/src/intl/de/page-roadmap.json
new file mode 100644
index 00000000000..25fcefb7e5c
--- /dev/null
+++ b/src/intl/de/page-roadmap.json
@@ -0,0 +1,102 @@
+{
+ "page-roadmap-title": "Ethereum-Roadmap",
+ "page-roadmap-meta-title": "Die Ethereum-Roadmap | ethereum.org",
+ "page-roadmap-meta-description": "Der Weg zu mehr Skalierbarkeit, Sicherheit und Nachhaltigkeit für Ethereum.",
+ "page-roadmap-banner-notification": "Die Weiterentwicklung von Ethereum wird von der Community gesteuert und unterliegt möglichen Änderungen.",
+ "page-roadmap-changes-coming-title": "Welche Veränderungen stehen bei Ethereum an?",
+ "page-roadmap-changes-coming-description": "Ethereum ist bereits eine leistungsstarke Plattform, wird jedoch kontinuierlich weiterentwickelt. Ein ehrgeiziges Paket an Verbesserungen soll Ethereum von seiner derzeitigen Form zu einer vollständig skalierbaren und maximal widerstandsfähigen Plattform aufwerten.",
+ "page-roadmap-cheaper-transactions-title": "Günstigere Transaktionen",
+ "page-roadmap-cheaper-transactions-description": "Rollups sind derzeit zu teuer und stützen sich auf zentralisierte Komponenten, wodurch Nutzer gezwungen sind, ihren Betreibern zu viel Vertrauen entgegenzubringen. Die Ethereum-Roadmap sieht Lösungen für beide Probleme vor.",
+ "page-roadmap-cheaper-transactions-button": "Mehr zum Thema Gebührenreduzierung",
+ "page-roadmap-extra-security-title": "Extra Sicherheit",
+ "page-roadmap-extra-security-description": "Ethereum ist bereits sehr sicher, kann jedoch noch weiter gestärkt werden, um auch in Zukunft allen Arten von Angriffen standzuhalten.",
+ "page-roadmap-extra-security-button": "Weiteres zur Sicherheit",
+ "page-roadmap-better-user-experience-title": "Bessere Benutzererfahrung",
+ "page-roadmap-better-user-experience-description": "Mehr Unterstützung für Smart-Contract-Wallets und leichtgewichtige Clients wird die Nutzung von Ethereum einfacher und sicherer machen.",
+ "page-roadmap-better-user-experience-button": "Mehr zum Thema Benutzererfahrung",
+ "page-roadmap-future-proofing-title": "Zukunftssicherung",
+ "page-roadmap-future-proofing-description": "Ethereum-Forscher und -Entwickler lösen schon heute die Probleme von morgen und machen das Netzwerk fit für kommende Generationen.",
+ "page-roadmap-future-proofing-button": "Mehr zum Thema Zukunftssicherheit",
+ "page-roadmap-why-need-title": "Warum braucht Ethereum eine Roadmap?",
+ "page-roadmap-why-need-description": "Ethereum erhält regelmäßige Upgrades, die seine Skalierbarkeit, Sicherheit oder Nachhaltigkeit verbessern. Eine der größten Stärken von Ethereum ist seine Fähigkeit, sich neuen Ideen aus Forschung und Entwicklung anzupassen. Diese Anpassungsfähigkeit verschafft Ethereum die Flexibilität, auf neue Herausforderungen zu reagieren und mit den neuesten technologischen Fortschritten Schritt zu halten.",
+ "page-roadmap-how-defined-title": "Wie die Roadmap definiert wird",
+ "page-roadmap-how-defined-p1": "Die Roadmap ist vor allem das Ergebnis jahrelanger Arbeit von Forschern und Entwicklern - da das Protokoll sehr technisch ist - aber jede motivierte Person kann sich daran beteiligen.",
+ "page-roadmap-how-defined-p2": "Ideen entstehen meist zunächst in Diskussionen auf Foren wie ethresear.ch, Ethereum Magicians oder im Eth R\\&D Discord-Server. Sie können Reaktionen auf neu entdeckte Sicherheitslücken sein, Vorschläge von Organisationen, die in der Anwendungsschicht arbeiten (wie dApps und Börsen), oder bekannte Probleme für Endnutzer betreffen (etwa Kosten oder Transaktionsgeschwindigkeiten).",
+ "page-roadmap-how-defined-p3": "Wenn diese Ideen ausgereift sind, können sie als Ethereum Improvement Proposals eingebracht werden. Der gesamte Prozess findet öffentlich statt, sodass sich jederzeit jedes Mitglied der Community einbringen kann.",
+ "page-roadmap-governance-button": "Mehr zur Ethereum-Verwaltung",
+ "page-roadmap-hero-alt": "Ethereum-Roadmap",
+ "page-roadmap-technical-upgrades-title": "Welche technischen Verbesserungen stehen bei Ethereum an?",
+ "page-roadmap-danksharding-title": "Danksharding",
+ "page-roadmap-danksharding-description": "Danksharding macht L2-Rollups für Nutzer wesentlich kostengünstiger, indem es Ethereum-Blöcken Datenblöcke hinzufügt.",
+ "page-roadmap-single-slot-finality-title": "Einzelplatzfinalität (single slot finality)",
+ "page-roadmap-single-slot-finality-description": "Anstatt fünfzehn Minuten zu warten, könnten Blöcke im selben Zeitfenster vorgeschlagen und finalisiert werden, was für Apps bequemer und schwerer anzugreifen ist.",
+ "page-roadmap-account-abstraction-title": "Kontoabstraktion",
+ "page-roadmap-account-abstraction-description": "Account Abstraction ist eine Reihe von Upgrades, die Smart-Contract-Wallets nativ auf Ethereum unterstützen, ohne dass dafür komplexe Middleware erforderlich ist.",
+ "page-roadmap-statelessness-title": "Zustandslosigkeit",
+ "page-roadmap-statelessness-description": "Zustandslose Clients werden neue Blöcke verifizieren können, ohne große Datenmengen speichern zu müssen. Damit lassen sich alle Vorteile eines Knotens nutzen – bei nur einem Bruchteil der heutigen Kosten.",
+ "page-roadmap-learn-more": "Mehr erfahren",
+ "page-roadmap-timeline-title": "Wie sieht der Zeitplan für diese Upgrades aus?",
+ "page-roadmap-blocks-alt": "Ethereum-Blöcke",
+ "page-roadmap-faq-1-title": "Wird sich die Roadmap von Ethereum im Laufe der Zeit ändern?",
+ "page-roadmap-faq-1-p1": "Ja - ganz sicherlich.",
+ "page-roadmap-faq-1-p1-continued": "Die Roadmap ist der aktuelle Plan für die Weiterentwicklung von Ethereum und umfasst sowohl kurzfristige als auch langfristige Vorhaben. Wir rechnen damit, dass sich die Roadmap ändern wird, sobald neue Informationen und Technologien verfügbar sind.",
+ "page-roadmap-faq-1-p2": "Denken Sie sich die Roadmap von Ethereum als eine Reihe von Intentionen zur Verbesserung der Plattform. Sie stellt die beste Hypothese der wichtigsten Forscher und Entwickler über den optimalen Weg in die Zukunft von Ethereum dar.",
+ "page-roadmap-faq-2-title": "Wann wird die Roadmap fertiggestellt sein?",
+ "page-roadmap-faq-2-p1": "Einige Upgrades haben eine niedrigere Priorität und werden wahrscheinlich in den nächsten 5–10 Jahren nicht implementiert (z. B. Quantenresistenz).",
+ "page-roadmap-faq-2-p1-strong": "Es ist kompliziert, den genauen Zeitpunkt jedes Upgrades anzugeben",
+ "page-roadmap-faq-2-p1-continued": "Es ist schwer vorherzusagen, da viele Punkte der Roadmap parallel bearbeitet und mit unterschiedlicher Geschwindigkeit entwickelt werden. Auch die Dringlichkeit eines Upgrades kann sich im Laufe der Zeit ändern – abhängig von externen Faktoren (z. B. könnte ein plötzlicher Leistungssprung und eine breitere Verfügbarkeit von Quantencomputern die Einführung quantenresistenter Kryptografie dringlicher machen).",
+ "page-roadmap-faq-2-p2": "Eine Möglichkeit, die Entwicklung von Ethereum zu betrachten, ist der Vergleich mit der biologischen Evolution. Ein Netzwerk, das sich neuen Herausforderungen anpassen und seine Leistungsfähigkeit bewahren kann, hat größere Erfolgschancen als eines, das sich Veränderungen widersetzt, auch wenn mit zunehmender Leistungsfähigkeit, Skalierbarkeit und Sicherheit des Netzwerks immer weniger Änderungen am Protokoll erforderlich sein werden.",
+ "page-roadmap-faq-3-title": "Muss ich irgendetwas tun, um mich auf diese Upgrades vorzubereiten?",
+ "page-roadmap-faq-3-p1": "Upgrades wirken sich in der Regel nicht auf die Endbenutzer aus, außer dass sie eine bessere Benutzererfahrung, ein sichereres Protokoll und vielleicht mehr Optionen für die Interaktion mit Ethereum bieten. Reguläre Benutzer müssen weder aktiv an einem Upgrade teilnehmen noch etwas tun, um ihre Vermögenswerte zu sichern. Node-Betreiber müssen ihre Clients aktualisieren, um sich auf ein Upgrade vorzubereiten. Einige Upgrades können zu Änderungen für Anwendungsentwickler führen. Zum Beispiel können Upgrades, die den Ablauf der Historie betreffen, dazu führen, dass Anwendungsentwickler historische Daten aus neuen Quellen abrufen.",
+ "page-roadmap-faq-4-title": "Wie verhält es sich mit Sharding?",
+ "page-roadmap-faq-4-p1": "Sharding ist die Aufteilung der Ethereum-Blockchain, sodass Teilmengen von Validatoren nur für einen Bruchteil der Gesamtdaten verantwortlich sind. Dies war ursprünglich als Mittel zur Skalierung von Ethereum gedacht. Layer-2-Rollups haben sich jedoch viel schneller als erwartet entwickelt und bieten bereits eine hohe Skalierung, die nach der Implementierung von Proto-Danksharding noch erheblich zunehmen wird. Das bedeutet, dass „Shard Chains“ nicht mehr benötigt werden und aus der Roadmap gestrichen wurden.",
+ "page-roadmap-release-status-prod": "In der Produktion",
+ "page-roadmap-release-status-soon": "Demnächst",
+ "page-roadmap-release-status-dev": "In Entwicklung",
+ "page-roadmap-release-main-features": "Hauptfunktionen",
+ "page-roadmap-release-learn-more": "Mehr erfahren",
+ "page-roadmap-release-forkcast": "Änderungen verfolgen",
+ "page-roadmap-paris-pos-title": "Übergang zum Proof of Stake",
+ "page-roadmap-paris-pos-item-1": "Ersetzte das energieintensive Mining durch einen auf Staking basierenden Konsens",
+ "page-roadmap-paris-pos-item-2": "Reduzierte den Energieverbrauch von Ethereum um ~99,95 %",
+ "page-roadmap-paris-beacon-title": "Beacon Chain-Integration",
+ "page-roadmap-paris-beacon-item-1": "Führte die Beacon Chain mit dem Ethereum-Mainnet zusammen",
+ "page-roadmap-paris-beacon-item-2": "Ermöglichte den vollständigen Übergang zum PoS-Konsensmechanismus",
+ "page-roadmap-paris-difficulty-title": "Entfernung des Schwierigkeitssprengers",
+ "page-roadmap-paris-difficulty-item-1": "Entfernte den Schwierigkeitssprenger, der die Mining-Schwierigkeit erhöhte",
+ "page-roadmap-paris-difficulty-item-2": "Sorgte für einen reibungslosen Übergang zum neuen Konsensmechanismus",
+ "page-roadmap-shapella-withdrawals-title": "Staking-Auszahlungen",
+ "page-roadmap-shapella-withdrawals-item-1": "Ermöglichte es Validatoren, ihre gestaketen ETH und Belohnungen abzuheben",
+ "page-roadmap-shapella-withdrawals-item-2": "Führte Möglichkeiten für teilweise und vollständige Abhebungen ein",
+ "page-roadmap-shapella-eip4895-title": "EIP-4895: Push-Abhebungen der Beacon Chain",
+ "page-roadmap-shapella-eip4895-item-1": "Fügte eine neue Operation auf Systemebene für Abhebungen hinzu",
+ "page-roadmap-shapella-eip4895-item-2": "Stellte die sichere und effiziente Verarbeitung von Abhebungsanfragen sicher",
+ "page-roadmap-shapella-eip3651-title": "EIP-3651: Warm COINBASE",
+ "page-roadmap-shapella-eip3651-item-1": "Reduzierte Gasgebühren für den Zugriff auf die COINBASE-Adresse",
+ "page-roadmap-shapella-eip3651-item-2": "Verbesserte die Effizienz bestimmter Smart-Contract-Operationen",
+ "page-roadmap-dencun-danksharding-title": "Proto-Danksharding (EIP-4844)",
+ "page-roadmap-dencun-danksharding-item-1": "Führte Blob-Transaktionen ein, um die Transaktionskosten von Rollups erheblich zu reduzieren",
+ "page-roadmap-dencun-danksharding-item-2": "Fügte einen neuen Transaktionstyp hinzu, der Daten temporär und kostengünstig speichert",
+ "page-roadmap-dencun-eip1153-title": "EIP-1153: Transiente Speicher-Opcodes",
+ "page-roadmap-dencun-eip1153-item-1": "Fügte TSTORE- und TLOAD-Opcodes für die temporäre Speicherung während der Transaktionsausführung hinzu",
+ "page-roadmap-dencun-eip1153-item-2": "Ermöglicht effizientere Smart-Contract-Muster und reduziert die Gasgebühren",
+ "page-roadmap-dencun-eip4788-title": "EIP-4788: Beacon-Block-Root im EVM",
+ "page-roadmap-dencun-eip4788-item-1": "Stellt Informationen der Konsens-Ebene für Smart Contracts zur Verfügung",
+ "page-roadmap-dencun-eip4788-item-2": "Ermöglicht neue vertrauensminimierte Anwendungen und kettenübergreifende Brücken",
+ "page-roadmap-pectra-eoa-title": "Erweiterung von EOA-Wallets um Smart-Contract-Funktionalität",
+ "page-roadmap-pectra-eoa-item-1": "Benutzer können ihre Adresse so einstellen, dass sie durch den Code eines bestehenden Smart Contracts repräsentiert wird, und von Vorteilen wie Transaktionsbündelung, Sponsoring von Transaktionsgebühren oder besseren Wiederherstellungsmechanismen profitieren",
+ "page-roadmap-pectra-balance-title": "Erhöhung des maximalen effektiven Guthabens",
+ "page-roadmap-pectra-balance-item-1": "Staker können jetzt einen beliebigen Betrag an ETH zum Staken auswählen und für jeden 1 ETH über dem Minimum Belohnungen erhalten",
+ "page-roadmap-pectra-blob-title": "Blob-Durchsatzerhöhung",
+ "page-roadmap-pectra-blob-item-1": "Die Anzahl der Blobs wird von 3 auf 6 Zielwerte erhöht, mit einem Maximum von 9, was zu günstigeren Gebühren bei Ethereum-Rollups führt",
+ "page-roadmap-fusaka-peerdas-title": "PeerDAS (Peer-to-Peer Data Availability Sampling)",
+ "page-roadmap-fusaka-peerdas-item-1": "Ermöglicht eine effizientere Datenverfügbarkeit für Rollups",
+ "page-roadmap-fusaka-peerdas-item-2": "Macht den Betrieb eines Nodes zugänglicher, während die Dezentralisierung erhalten bleibt",
+ "page-roadmap-fusaka-additional-title": "Potenzielle zusätzliche Funktionen",
+ "page-roadmap-fusaka-additional-item-1": "Unterstützung für sichere Enklaven auf mobilen Geräten zur Verbesserung der UX",
+ "page-roadmap-fusaka-additional-item-2": "Verbesserungen am Blob-Gebührenmarkt",
+ "page-roadmap-fusaka-additional-item-3": "Weitere Verbesserungen der Validator-Effizienz und der Netzwerkleistung",
+ "page-roadmap-glamsterdam-discussed-title": "Geplant für Glamsterdam",
+ "page-roadmap-glamsterdam-discussed-item-1": "Verankerte Proposer-Builder-Trennung (ePBS)",
+ "page-roadmap-glamsterdam-discussed-item-2": "Zugriffslisten auf Blockebene (BALs)"
+}
diff --git a/src/intl/de/page-run-a-node.json b/src/intl/de/page-run-a-node.json
index 546dde6e465..10c6dc8179c 100644
--- a/src/intl/de/page-run-a-node.json
+++ b/src/intl/de/page-run-a-node.json
@@ -111,6 +111,7 @@
"page-run-a-node-sovereignty-1": "Eine Ethereum-Wallet macht es möglich, Ihre digitalen Vermögenswerte vollständig zu verwahren und zu kontrollieren, indem Sie die privaten Schlüssel zu ihren Adressen besitzen. Jedoch geben Ihnen diese Schlüssel keinen Aufschluss über den aktuellen Stand der Blockchain, wie z. B. Ihr Wallet-Guthaben.",
"page-run-a-node-sovereignty-2": "Standardmäßig greifen Ethereum-Wallets auf einen Knotenpunkt eines Drittanbieters wie Infura oder Alchemy zu, wenn sie ihren Kontostand abfragen. Wenn Sie Ihren eigenen Knotenpunkt betreiben, haben Sie Ihre eigene Kopie der Ethereum-Blockchain.",
"page-run-a-node-title": "Einen Knotenpunkt betreiben",
+ "page-run-a-node-meta-title": "Wie man einen Ethereum-Knoten betreibt",
"page-run-a-node-voice-your-choice-title": "Geben Sie Ihre Entscheidung bekannt",
"page-run-a-node-voice-your-choice-preview": "Geben Sie im Falle einer Netzwerkspaltung nicht die Kontrolle auf.",
"page-run-a-node-voice-your-choice-1": "Im Falle einer Netzwerkspaltung (Chain Fork), bei der zwei Ketten mit zwei verschiedenen Regelwerken entstehen, garantiert der Betrieb Ihres eigenen Knotenpunktes, dass Sie wählen können, welches Regelwerk Sie unterstützen. Es liegt an Ihnen, ob Sie auf neue Regeln umsteigen und die vorgeschlagenen Änderungen unterstützen oder nicht.",
diff --git a/src/intl/de/page-stablecoins.json b/src/intl/de/page-stablecoins.json
index 475738e55eb..8de2cdf4ba9 100644
--- a/src/intl/de/page-stablecoins.json
+++ b/src/intl/de/page-stablecoins.json
@@ -1,5 +1,8 @@
{
- "page-stablecoins-accordion-borrow-crypto-collateral": "Krypto-Sicherheit",
+ "page-stablecoins-accordion-borrow-crypto-collateral": "Krypto-Sicherheiten",
+ "page-stablecoins-usdc-banner-body": "USDC ist der größte, in den USA regulierte und durch Fiatwährung gedeckte Stablecoin. Sein Wert ist an den US-Dollar gekoppelt, er wird von Circle ausgegeben und ist weit verbreitet.",
+ "page-stablecoins-usdc-banner-learn-button": "Weitere Infos über USDC",
+ "page-stablecoins-usdc-banner-swap-button": "USDC erwerben",
"page-stablecoins-accordion-borrow-crypto-collateral-copy": "Mit Ethereum können Sie direkt von anderen Benutzern leihen, ohne Ihr ETH zu verlieren. Dies kann als Hebelwirkung dienen – einige tun dies, um mehr ETH anzuhäufen.",
"page-stablecoins-accordion-borrow-crypto-collateral-copy-p2": "Da der Preis von ETH jedoch volatil ist, müssen Sie sich überbesichern. Wenn Sie sich also 100 Stablecoins leihen wollen, brauchen Sie wahrscheinlich mindestens ETH im Wert von 150 USD. Dies schützt das System und die Kreditgeber.",
"page-stablecoins-accordion-borrow-crypto-collateral-link": "Mehr zu kryptogestützten Stablecoins",
@@ -23,10 +26,9 @@
"page-stablecoins-accordion-buy-text-preview": "Viele Börsen und Wallets erlauben den direkten Kauf von Stablecoins. Dabei gelten geografische Einschränkungen.",
"page-stablecoins-accordion-buy-title": "Kaufen",
"page-stablecoins-accordion-buy-warning": "Zentralisierte Börsen führen wahrscheinlich nur von Papiergeld unterstützte Stablecoins wie USDC, Tether und ähnliche. Möglicherweise können Sie sie dort nicht direkt erwerben, allerdings sollten Sie sie mit ETH oder anderen Kryptowährungen handeln können, die Sie auf diesen Plattformen kaufen können.",
- "page-stablecoins-accordion-earn-project-1-description": "Hauptsächlich technische Arbeit für die Open-Source-Software-Bewegung.",
+ "page-stablecoins-accordion-earn-project-1-description": "Aktuelle & anstehende Hackathons. Das Portal für alle Builder, um die neue digitale Welt zu erforschen.",
"page-stablecoins-accordion-earn-project-2-description": "Technologien, Inhalte und andere Produkte für die MakerDao-Community (das Team, das uns Dai gebracht hat).",
"page-stablecoins-accordion-earn-project-3-description": "Wenn Sie wirklich Ahnung haben, dann finden Sie Bugs, um Dai zu verdienen.",
- "page-stablecoins-accordion-earn-project-bounties": "Gitcoin-Prämien",
"page-stablecoins-accordion-earn-project-bug-bounties": "Konsensebene Fehlerprämie",
"page-stablecoins-accordion-earn-project-community": "MakerDao-Community",
"page-stablecoins-accordion-earn-projects-copy": "Diese Plattformen zahlen Ihnen Stablecoins für Ihre Arbeit.",
@@ -36,8 +38,6 @@
"page-stablecoins-accordion-earn-requirements-description": "Stablecoins sind eine großartige Zahlungsmethode für Arbeit und Dienstleistungen, da der Wert stabil bleibt. Sie benötigen jedoch eine Wallet, um bezahlt zu werden.",
"page-stablecoins-accordion-earn-text-preview": "Sie können Stablecoins verdienen, indem Sie an Projekten innerhalb des Ökosystems Ethereum arbeiten.",
"page-stablecoins-accordion-earn-title": "Verdienen",
- "page-stablecoins-accordion-less": "Weniger",
- "page-stablecoins-accordion-more": "Mehr",
"page-stablecoins-accordion-requirements": "Was Sie brauchen",
"page-stablecoins-accordion-swap-dapp-intro": "Wenn Sie bereits über ETH und eine Wallet verfügen, können Sie diese DApps zum Tauschen gegen Stablecoins verwenden.",
"page-stablecoins-accordion-swap-dapp-link": "Mehr über dezentralisierte Börsen",
@@ -47,7 +47,7 @@
"page-stablecoins-accordion-swap-editors-tip-copy": "Besorgen Sie sich eine Wallet, mit der Sie direkt ETH kaufen und es für andere Tokens eintauschen können, inklusive Stablecoins.",
"page-stablecoins-accordion-swap-pill": "Empfohlen",
"page-stablecoins-accordion-swap-requirement-1": "Eine Ethereum-Wallet",
- "page-stablecoins-accordion-swap-requirement-1-description": "Sie brauchen eine Wallet, um einen Austausch zu autorisieren und Ihre Coins aufzubewahren",
+ "page-stablecoins-accordion-swap-requirement-1-description": "Du benötigst eine Wallet, um den Tauschvorgang zu autorisieren und deine Coins aufzubewahren",
"page-stablecoins-accordion-swap-requirement-2": "Ether (ETH)",
"page-stablecoins-accordion-swap-requirement-2-description": "Um für den Austausch zu bezahlen",
"page-stablecoins-accordion-swap-text-preview": "Die meisten Stablecoins können Sie auf dezentralisierten Börsen finden. So können Sie die Token, die Sie haben, gegen jegliche Stablecoins eintauschen.",
@@ -56,7 +56,6 @@
"page-stablecoins-algorithmic-con-1": "Sie müssen dem Algorithmus vertrauen (oder ihn lesen können).",
"page-stablecoins-algorithmic-con-2": "Ihr Guthaben an Coins ändert sich je nach Gesamtangebot.",
"page-stablecoins-algorithmic-description": "Diese Stablecoins sind nicht durch einen anderen Vermögenswert gedeckt. Stattdessen wird ein Algorithmus Token verkaufen, wenn der Preis unter den gewünschten Wert fällt, und Token liefern, wenn der Wert über den gewünschten Betrag hinausgeht. Da sich die Anzahl dieser Token im Umlauf regelmäßig ändert, wird sich die Anzahl der Token, die Sie besitzen, ändern, aber immer Ihren Anteil widerspiegeln.",
- "page-stablecoins-algorithmic-disclaimer": "Bei algorithmischen Stablecoins handelt es sich um experimentelle Technologie. Sie sollte sich der Risiken bewusst sein, bevor Sie sie verwenden.",
"page-stablecoins-algorithmic-pro-1": "Keine Sicherheiten notwendig.",
"page-stablecoins-algorithmic-pro-2": "Kontrolliert durch einen öffentlichen Algorithmus.",
"page-stablecoins-bank-apy": "0,05 %",
@@ -69,16 +68,11 @@
"page-stablecoins-crypto-backed": "Krypto-unterstützt",
"page-stablecoins-crypto-backed-con-1": "Weniger stabil als von Papiergeld unterstützte Stablecoins.",
"page-stablecoins-crypto-backed-con-2": "Sie müssen den Wert der Krypto-Sicherheiten im Auge behalten.",
- "page-stablecoins-crypto-backed-description": "Diese Stablecoins sind durch andere Krypto-Vermögenswerte, wie ETH, abgesichert. Ihr Preis hängt vom Wert des zugrunde liegenden Vermögenswerts (oder der Sicherheit) ab, der volatil sein kann. Da der Wert von ETH schwanken kann, sind diese Stablecoins überbesichert, um sicherzustellen, dass der Preis so stabil wie möglich bleibt. Das bedeutet, dass ein Stablecoin im Wert von 1 USD, der mit Kryptowährungen unterlegt ist, einen zugrundeliegenden Krypto-Vermögenswert im Wert von mindestens 2 USD hat. Wenn also der Preis von ETH fällt, muss mehr ETH verwendet werden, um den Stablecoin zu unterlegen, sonst verlieren die Stablecoins ihren Wert.",
+ "page-stablecoins-crypto-backed-description": "Diese Art von Stablecoins ist nicht durch echtes Geld wie Euro oder Dollar gedeckt, sondern durch andere Kryptowährungen, zum Beispiel ETH. Der Preis des Stablecoins hängt also direkt vom Wert der hinterlegten Kryptowährung ab – und dieser Wert kann stark schwanken.\n\nDamit der Stablecoin trotzdem stabil bleibt, gibt es einen Trick: die Überbesicherung.\n\nDas funktioniert so: Um einen Stablecoin im Wert von 1 € zu schaffen, werden Sicherheiten in Form von Krypto-Assets im Wert von zum Beispiel 2 € hinterlegt. Dieser zusätzliche Wert dient als Puffer. Wenn der Wert von ETH also fällt, kann dieser Puffer den Verlust ausgleichen und der Stablecoin bleibt stabil. Würde der Wert der Sicherheit zu stark fallen und der Puffer nicht mehr ausreichen, würde auch der Stablecoin an Wert verlieren.\n\nWichtig zu wissen: Einige dieser Stablecoins, wie zum Beispiel DAI, nutzen als Teil ihrer Sicherheit auch andere, zentralisierte Stablecoins.",
"page-stablecoins-crypto-backed-pro-1": "Transparent und vollständig dezentralisiert.",
"page-stablecoins-crypto-backed-pro-2": "Schnell in andere Krypto-Assets umwandelbar.",
"page-stablecoins-crypto-backed-pro-3": "Keine externen Verwalter – alle Vermögenswerte werden von Ethereum-Konten kontrolliert.",
- "page-stablecoins-dai-banner-body": "Dai ist wahrscheinlich der berühmteste dezentralisierte Stablecoin. Sein Wert beträgt ungefähr einen Dollar und wird weithin auf diversen dApps akzeptiert.",
- "page-stablecoins-dai-banner-learn-button": "Weitere Infos über Dai",
- "page-stablecoins-dai-banner-swap-button": "ETH gegen Dai eintauschen",
- "page-stablecoins-dai-banner-title": "Dai",
- "page-stablecoins-dai-logo": "Das Dai-Logo",
- "page-stablecoins-editors-choice": "Auswahl des Editors",
+ "page-stablecoins-editors-choice": "Favoriten des Teams",
"page-stablecoins-editors-choice-intro": "Dies sind momentan wahrscheinlich die bekanntesten Beispiele für Stablecoins und die Coins, die wir bei der Verwendung von dApps als nützlich empfunden haben.",
"page-stablecoins-explore-dapps": "Entdecken Sie dApps",
"page-stablecoins-fiat-backed": "Von Papiergeld unterstützt",
@@ -101,7 +95,7 @@
"page-stablecoins-precious-metals": "Edelmetalle",
"page-stablecoins-precious-metals-con-1": "Zentralisiert – jemand muss die Token herausgeben.",
"page-stablecoins-precious-metals-con-2": "Sie müssen dem Token-Herausgeber und den Edelmetallreserven vertrauen.",
- "page-stablecoins-precious-metals-description": "Wie von Papiergeld gestützte Münzen verwenden diese Stablecoins stattdessen Ressourcen wie Gold, um ihren Wert zu erhalten.",
+ "page-stablecoins-precious-metals-description": "Diese Stablecoins sind mit Fiat-gedeckten Coins vergleichbar, nutzen zur Wertabsicherung jedoch physische Rohstoffe wie Gold. „Stabil“ sind sie deshalb, weil ihr Preis fest an den Wert eines anderen Vermögenswertes gebunden ist. Man kann sie sich im Grunde wie einen digitalen Eigentumsnachweis für reale Vermögenswerte vorstellen, der auf der Blockchain geführt wird",
"page-stablecoins-precious-metals-pro-1": "Sicher vor Krypto-Volatilität.",
"page-stablecoins-prices": "Stablecoin-Preise",
"page-stablecoins-prices-definition": "Stablecoins sind Kryptowährungen ohne die Volatilität. Sie teilen viele der gleichen Kräfte wie ETH, aber ihr Wert ist beständig, eher wie eine traditionelle Währung. So haben Sie Zugang zu stabilem Geld, das Sie auf Ethereum verwenden können. ",
@@ -118,6 +112,7 @@
"page-stablecoins-stablecoins-dapp-description-2": "Verleihen Sie Stablecoins und verdienen Sie Zinsen und $COMP, Compounds eigenes Token.",
"page-stablecoins-stablecoins-dapp-description-3": "Eine Handelsplattform, auf der Sie Zinsen auf Ihre Dai und USDC verdienen können.",
"page-stablecoins-stablecoins-dapp-description-4": "Eine App zum Speichern von Dai.",
+ "page-stablecoins-stablecoins-dapp-description-5": "Ein Protokoll zum Leihen und Verleihen auf Ethereum mit einer großen Auswahl an Stablecoins.",
"page-stablecoins-stablecoins-feature-1": "Stablecoins sind global und können über das Internet versendet werden. Sie können sie ganz einfach empfangen oder versenden, sobald Sie über ein Ethereum-Konto verfügen.",
"page-stablecoins-stablecoins-feature-2": "Die Nachfrage nach Stablecoins ist hoch, Sie können also Zinsen durch das Verleihen verdienen. Stellen Sie sicher, dass Sie sich der Risiken bewusst sind, bevor Sie etwas verleihen.",
"page-stablecoins-stablecoins-feature-3": "Stablecoins können gegen ETH- und andere Ethereum-Token eingetauscht werden. Viele DApps basieren auf Stablecoins.",
@@ -125,43 +120,76 @@
"page-stablecoins-stablecoins-meta-description": "Eine Einführung in Ethereum-Stablecoins: was sie sind, wie man sie bekommt und warum sie wichtig sind.",
"page-stablecoins-stablecoins-table-header-column-1": "Währung",
"page-stablecoins-stablecoins-table-header-column-2": "Marktkapitalisierung",
- "page-stablecoins-stablecoins-table-header-column-3": "Sicherheitstyp",
+ "page-stablecoins-stablecoins-table-header-column-3": "Sicherheitentyp",
+ "page-stablecoins-stablecoins-table-header-column-4": "Zusammengeklammert",
"page-stablecoins-stablecoins-table-type-crypto-backed": "Krypto",
"page-stablecoins-stablecoins-table-type-fiat-backed": "Fiat",
"page-stablecoins-stablecoins-table-type-precious-metals-backed": "Edelmetalle",
"page-stablecoins-table-error": "Stablecoins konnten nicht geladen werden. Versuchen Sie, die Seite zu aktualisieren.",
"page-stablecoins-title": "Stablecoins",
- "page-stablecoins-top-coins": "Top-Stablecoins nach Marktkapitalisierung",
+ "page-stablecoins-meta-title": "Stablecoins erklärt: Wofür sind sie da?",
+ "page-stablecoins-top-coins": "Die größten Stablecoins nach Marktkapitalisierung",
"page-stablecoins-top-coins-intro": "Marktkapitalisierung ist",
"page-stablecoins-top-coins-intro-code": "die Gesamtzahl der vorhandenen Token multipliziert mit dem Wert pro Token. Diese Liste ist dynamisch, und die hier aufgeführten Projekte werden nicht unbedingt vom ethereum.org-Team unterstützt.",
"page-stablecoins-types-of-stablecoin": "So funktionieren sie: Arten von Stablecoins",
- "page-stablecoins-usdc-banner-body": "USDC ist wahrscheinlich der berühmteste durch Fiatgeld gestützte Stablecoin. Er ist ungefähr einen Dollar wert und ist ein von Circle und Coinbase finanziertes Projekt.",
- "page-stablecoins-usdc-banner-learn-button": "Weitere Infos über USDC",
- "page-stablecoins-usdc-banner-swap-button": "ETH gegen USDC eintauschen",
- "page-stablecoins-usdc-banner-title": "USDC",
"page-stablecoins-usdc-logo": "Das USDC-Logo",
+ "page-stablecoins-usdt-banner-body": "Tether USD (USDT) ist der nach Marktkapitalisierung größte, durch Fiatwährung gedeckte Stablecoin. Sein Wert ist im Verhältnis 1: 1 an den US-Dollar gekoppelt und seine Reserven werden von Tether Limited verwaltet.",
+ "page-stablecoins-usdt-banner-swap-button": "ETH gegen USDC eintauschen",
+ "page-stablecoins-usdt-banner-learn-button": "Weitere Infos über USDT",
+ "page-stablecoins-usdt-logo": "Das USDT-Logo",
+ "page-stablecoins-usds-banner-body": "USDS ist der Nachfolger von Dai, vollständig durch Krypto gedeckt und für On-Chain-Sparen sowie Belohnungen konzipiert. Es ist in DeFi weit verbreitet, wobei die Nutzer die volle Kontrolle über ihre Gelder behalten.",
+ "page-stablecoins-usds-banner-swap-button": "ETH in USDS tauschen",
+ "page-stablecoins-usds-banner-learn-button": "Weitere Infos über USDS",
+ "page-stablecoins-usds-logo": "Das USDS-Logo",
+ "page-stablecoins-gho-banner-body": "GHO ist ein von Aave geschaffener, dezentraler Multikollateral-Stablecoin. Er nutzt ein hybrides Modell, das eine krypto-besicherte Deckung mit einem Community-Governance-Ansatz kombiniert.",
+ "page-stablecoins-gho-banner-swap-button": "ETH gegen GHO eintauschen",
+ "page-stablecoins-gho-banner-learn-button": "Weitere Infos über GHO",
+ "page-stablecoins-gho-logo": "Das GHO-Logo",
+ "page-stablecoins-glo-banner-body": "Glo Dollar (USDGLO) ist ein Stablecoin, der alle seine Gewinne an gemeinnützige Zwecke und Wohltätigkeitsorganisationen spendet. Indem Sie Glo Dollar halten oder verwenden, unterstützen Sie Anliegen wie die Bekämpfung von Armut und die Förderung von Open-Source – und das ohne zusätzliche Kosten für Sie.",
+ "page-stablecoins-glo-banner-swap-button": "Kauf GLO",
+ "page-stablecoins-glo-banner-learn-button": "Weitere Infos über GLO",
+ "page-stablecoins-glo-logo": "Das USDGLO-Logo",
+ "page-stablecoins-hai-banner-title": "HAI",
+ "page-stablecoins-hai-banner-body": "HAI ist ein dezentraler, ETH-gestützter Stablecoin von Let's Get HAI, dessen Fokus auf Zensurresistenz und öffentlichen Gütern liegt. Er ist mit minimaler Governance konzipiert und priorisiert Stabilität, ohne bei den Werten der Dezentralisierung Kompromisse einzugehen.",
+ "page-stablecoins-hai-banner-swap-button": "HAI mit ETH minten",
+ "page-stablecoins-hai-banner-learn-button": "Weitere Infos über HAI",
+ "page-stablecoins-hai-logo": "Das HAI-Logo",
+ "page-stablecoins-lusd-banner-title": "LUSD",
+ "page-stablecoins-lusd-banner-body": "LUSD ist ein dezentraler Stablecoin von Liquity, der ausschließlich durch ETH besichert ist und eine minimale Besicherungsquote von 110 % aufweist. Er zeichnet sich durch zinsfreies Leihen, algorithmische Liquidationen und eine minimale Governance aus, was ihn äußerst zensurresistent macht.",
+ "page-stablecoins-lusd-banner-swap-button": "ETH in LUSD tauschen",
+ "page-stablecoins-lusd-banner-learn-button": "Weitere Infos über LUSD",
+ "page-stablecoins-lusd-logo": "Das LUSD-Logo",
"page-stablecoins-why-stablecoins": "Wieso Stablecoins?",
"page-stablecoins-how-they-work-button": "Wie sie funktionieren",
"page-stablecoins-why-stablecoins-body": "ETH, wie auch Bitcoin, hat einen volatilen Preis, weil es eine neue Technologie ist. Daher möchten Sie es vielleicht nicht regelmäßig ausgeben. Stablecoins spiegeln den Wert traditioneller Währungen, um Ihnen Zugang zu stabilem Geld zu geben, das Sie auf Ethereum verwenden können.",
"page-stablecoins-more-defi-button": "Mehr zu dezentralisierten Finanzen (DeFi)",
"page-stablecoins-tools-title": "Erfahren Sie mehr über Stablecoins",
"page-stablecoins-tools-stablecoinswtf-description": "Stablecoins.wtf bietet ein Dashboard mit historischen Marktdaten, Statistiken und Bildungsinhalten für die bekanntesten Stablecoins.",
- "page-apps-ready-button": "Los",
+ "page-stablecoins-tools-stablepulse-description": "Bietet eine klare, präzise und möglichst ungefilterte Sicht auf das Stablecoin-Ökosystem mit Analysen über Tokens und Chains hinweg.",
+ "page-stablecoins-tools-stablesinfo-description": "Eine Live-Stablecoin-Bestenliste und ein Dashboard, das das Angebot und die On-Chain-Daten für alle wichtigen Stablecoins und Chains verfolgt.",
+ "page-stablecoins-tools-dune-description": "Dashboard, das Echtzeit-Einblicke in das Angebot, die Liquidität, das Handelsvolumen und die Akzeptanz von Stablecoins über verschiedene Blockchains hinweg liefert.",
+ "page-stablecoins-tools-visa-description": "Dashboard, das Echtzeit-Einblicke in das Angebot, die Liquidität, das Handelsvolumen und die Akzeptanz von Stablecoins über verschiedene Blockchains hinweg liefert.",
+ "page-stablecoins-tools-stablewars-description": "Eine Analyse-Bestenliste und ein Dashboard, das Salden, Transfers und Ranglisten für Stablecoins über mehrere Blockchains hinweg verfolgt.",
+ "page-apps-ready-button": "Go",
"pros": "Vorteile",
"cons": "Nachteile",
"1inch-logo": "1inch-Logo",
"aave-logo": "Aave-Logo",
"binance-logo": "Binance-Logo",
"bittrex-logo": "Bittrex-Logo",
+ "buidlbox-logo": "Buidlbox-Logo",
"coinbase-logo": "Coinbase-Logo",
"coinmama-logo": "Coinmama-Logo",
"compound-logo": "Compound-Logo",
"example-projects": "Beispielprojekte",
+ "page-stablecoins-filter-by-type": "Nach Typ filtern",
+ "page-stablecoins-reset-list": "Liste zurücksetzen",
+ "page-stablecoins-show-more": "Mehr anzeigen",
+ "page-stablecoins-no-results": "Keine Stablecoins entsprechen den aktuellen Filtern",
"gemini-logo": "Gemini-Logo",
- "gitcoin-logo": "Gitcoin-Logo",
- "loopring-logo": "Loopring-Logo",
"makerdao-logo": "MakerDao-Logo",
"matcha-logo": "Matcha-Logo",
+ "sparkfi-logo": "Spark-Protokoll-Logo",
"summerfi-logo": "Summer.fi-Logo",
"uniswap-logo": "Uniswap-Logo",
"page-stablecoins-go-to": "Gehe zu"
diff --git a/src/intl/de/page-staking-deposit-contract.json b/src/intl/de/page-staking-deposit-contract.json
index e44f17d94a9..421ab8d59b4 100644
--- a/src/intl/de/page-staking-deposit-contract.json
+++ b/src/intl/de/page-staking-deposit-contract.json
@@ -8,7 +8,7 @@
"page-staking-deposit-contract-confirm-address": "Bestätigen, um die Adresse anzuzeigen",
"page-staking-deposit-contract-copied": "Adresse kopiert",
"page-staking-deposit-contract-copy": "Adresse kopieren",
- "page-staking-deposit-contract-blockexplorer": "Vertrag auf Etherscan anzeigen",
+ "page-staking-deposit-contract-blockexplorer": "Vertrag auf Blockscout ansehen",
"page-staking-deposit-contract-h2": "Staken findet woanders statt",
"page-staking-deposit-contract-launchpad": "Mit dem Launchpad staken",
"page-staking-deposit-contract-launchpad-2": "Launchpad nutzen",
diff --git a/src/intl/de/page-staking.json b/src/intl/de/page-staking.json
index cc428972df9..c2415b85f9d 100644
--- a/src/intl/de/page-staking.json
+++ b/src/intl/de/page-staking.json
@@ -10,11 +10,11 @@
"comp-withdrawal-comparison-new-link": "Besuchen Sie das Staking Launchpad",
"comp-withdrawal-credentials-placeholder": "Validatorindex",
"comp-withdrawal-credentials-error": "Oh! Überprüfen Sie die Validator-Indexnummer und versuchen Sie es noch einmal.",
- "comp-withdrawal-credentials-upgraded-1": "Validator-Index {validatorIndex} ist bereit, Belohnungen zu erhalten!",
+ "comp-withdrawal-credentials-upgraded-1": "Der Validator-Index {validatorIndex} ist bereit, Belohnungen zu erhalten!",
"comp-withdrawal-credentials-upgraded-2": "Auszahlungsdaten verknüpft mit der Ausführungsadresse:",
"comp-withdrawal-credentials-not-upgraded-1": "Dieser {network}-Validator muss aktualisiert werden.",
"comp-withdrawal-credentials-not-upgraded-2": "Anweisungen zur Aktualisierung finden Sie derzeit unter Staking Launchpad",
- "comp-withdrawal-credentials-verify": "Auf {network} überprüfen",
+ "comp-withdrawal-credentials-verify": "Auf {network} verifizieren",
"page-staking-withdrawals-when": "Versendet!",
"page-staking-image-alt": "Bild des Nashorn-Maskottchens für das Staking-Launchpad.",
"page-staking-benefits-1-title": "Verdienen Sie Belohnungen",
@@ -28,7 +28,7 @@
"page-staking-hero-title": "Wie man sein ETH einsetzt",
"page-staking-hero-header": "Verdienen Sie Belohnungen, während Sie Ethereum sichern",
"page-staking-hero-subtitle": "Jeder Benutzer mit beliebig viel ETH kann zur Sicherung des Netzwerks beitragen und dabei Belohnungen verdienen.",
- "page-staking-dropdown-home": "Staking-Home",
+ "page-staking-dropdown-home": "Staking-Startseite",
"page-staking-dropdown-solo": "Home-Staking",
"page-staking-more-on-solo": "Mehr über das Home-Staking",
"page-staking-learn-more-solo": "Lernen Sie mehr über Solo-Staking",
@@ -49,7 +49,7 @@
"page-staking-guide-title-somer-esat": "Somer Esat",
"page-staking-guide-title-rocket-pool": "Rocket Pool – Node-Betreiber",
"page-staking-guide-title-stakewise": "StakeWise-Knotenbetreiber",
- "page-staking-guide-title-lido-csm":"Lido CSM – Node-Betreiber",
+ "page-staking-guide-title-lido-csm": "Lido CSM-Knotenbetreiber",
"page-staking-guide-description-linux": "Linux (CLI)",
"page-staking-guide-description-mac-linux": "Linux, macOS (CLI)",
"page-staking-guide-description-mac-linux-windows": "Linux, Windows, MacOS (CLI)",
@@ -151,10 +151,10 @@
"page-staking-how-solo-works-item-3": "Synchronisieren Sie einen Client der Konsensebene",
"page-staking-how-solo-works-item-4": "Generieren Sie Ihre Schlüssel und laden Sie diesen in Ihren Validator-Client",
"page-staking-how-solo-works-item-5": "Überwachen und warten Sie Ihren Node",
- "page-staking-launchpad-widget-start": "Beginne auf dem {network} zu staken",
"page-staking-launchpad-widget-mainnet-label": "Hauptnetz (Mainnet)",
+ "page-staking-launchpad-widget-start": "Beginnen Sie mit dem Staking auf {network}",
"page-staking-launchpad-widget-span": "Netzwerk auswählen",
- "page-staking-launchpad-widget-p1": "Von Solo-Validatoren wird erwartet, dass sie ihre Konfiguration und ihre operativen Fähigkeiten auf dem Hoodi-Testnetz überprüfen, bevor Geldmittel riskiert werden. Vergessen Sie nicht, dass es wichtig ist, einen Minderheits-Client auszuwählen, da dies die Netzwerksicherheit erhöht und Ihre Risiken begrenzt.",
+ "page-staking-launchpad-widget-p1": "Von Solo-Validatoren wird erwartet, dass sie ihre Konfiguration und ihre operativen Fähigkeiten auf dem {{network}}-Testnetz überprüfen, bevor Geldmittel riskiert werden. Vergessen Sie nicht, dass es wichtig ist, einen Minderheits-Client auszuwählen, da dies die Netzwerksicherheit erhöht und Ihre Risiken begrenzt.",
"page-staking-launchpad-widget-p2": "Wenn Sie sich damit sicher fühlen, können Sie alles Nötige von der Kommandozeile aus erledigen, indem sie den Staking-Launchpad nutzen.",
"page-staking-launchpad-widget-p3": "Um die Dinge zu erleichtern, schauen Sie sich einige der Tools und Anleitungen unten an, die Ihnen neben dem Staking-Launchpad helfen können, um Ihre Clients so schnell wie möglich einzurichten.",
"page-staking-launchpad-widget-link": "Software-Tools und -Anleitungen",
@@ -165,7 +165,7 @@
"page-staking-stats-box-metric-1": "Gesamtes Staking-ETH",
"page-staking-stats-box-metric-2": "Gesamtanzahl von Validatoren",
"page-staking-stats-box-metric-3": "Aktuelle APR",
- "page-staking-stats-box-metric-1-tooltip": "Summe von ETH, der auf der Beacon Chain eingesetzt wird, ohne Guthaben über 32 ETH",
+ "page-staking-stats-box-metric-1-tooltip": "Summe der anrechenbaren ETH im Staking auf der Beacon Chain.",
"page-staking-stats-box-metric-2-tooltip": "Anzahl der derzeit auf der Beacon Chain aktivierten Validator-Konten",
"page-staking-stats-box-metric-3-tooltip": "Durchschnittliche hochgerechnete jährliche Rendite pro Validator im letzten 24-Stunden-Zeitraum",
"page-staking-section-comparison-subtitle": "Es gibt keine Musterlösung für das Staking, denn es ist bei jedem anders. Hier werden wir einige der Risiken, Belohnungen, und Anforderungen der verschiedenen Wege des Staking vergleichen.",
@@ -175,7 +175,7 @@
"page-staking-section-comparison-solo-rewards-li3": "Option, einen Liquid-Staking-Token gegen Ihren Home-Konoten zu prägen, der in DeFi verwendet werden soll",
"page-staking-section-comparison-saas-rewards-li1": "Das beinhaltet gewöhnlich volle Protokoll-Belohnungen minus der monatlichen Gebühr für den Node-Betrieb",
"page-staking-section-comparison-saas-rewards-li2": "Dashboards sind oft verfügbar, um Ihren Validator-Client ganz leicht zu überwachen",
- "page-staking-section-comparison-pools-rewards-li1": "Gepoolte Staker sammeln Belohnungen auf andere Weise, abhängig von der Methode, die vom gewählten Staking-Pool genutzt wird",
+ "page-staking-section-comparison-pools-rewards-li1": "Gepoolte Staker erhalten Belohnungen auf unterschiedliche Weise, je nachdem, welche Methode des Pool-Stakings gewählt wird.",
"page-staking-section-comparison-pools-rewards-li2": "Viele gepoolte Einsatzdienste bieten einen oder mehrere Liquiditätstoken an, die Ihre eingesetzte ETH plus Ihren Anteil an den Validator-Belohnungen repräsentieren",
"page-staking-section-comparison-pools-rewards-li3": "Liquiditätstoken können in Ihrem eigenen Wallet aufbewahrt, in DeFi verwendet und verkauft werden, wenn Sie sich für einen Ausstieg entscheiden",
"page-staking-section-comparison-risks-title": "Risiken",
@@ -190,7 +190,7 @@
"page-staking-section-comparison-requirements-title": "Anforderungen",
"page-staking-section-comparison-solo-requirements-li1": "Sie müssen 32 ETH einzahlen",
"page-staking-section-comparison-solo-requirements-li2": "Pflegen Sie Hardware, die sowohl einen Ethereum-Ausführungs-Client als auch einen Konsens-Client ausführt, während die Verbindung besteht in das Internet",
- "page-staking-section-comparison-solo-requirements-li3": "",
+ "page-staking-section-comparison-solo-requirements-li3": "Das Staking Launchpad erklärt Ihnen den Prozess sowie die Hardware-Anforderungen.",
"page-staking-section-comparison-saas-requirements-li1": "Zahlen Sie 32 ETH ein und generieren Sie Ihre Schlüssel mit Unterstützung",
"page-staking-section-comparison-saas-requirements-li2": "Verwahren Sie Ihre Schlüssel sicher",
"page-staking-section-comparison-saas-requirements-li3": "Für den Rest ist gesorgt, allerdings variieren dabei spezifische Dienste",
@@ -202,7 +202,7 @@
"page-staking-faq-2-answer": "Ein Validator hat die Möglichkeit, Blöcke für das Netzwerk vorzuschlagen und zu attestieren. Um unehrliches Verhalten zu verhindern, müssen für die Benutzer ihre Geldmittel auf dem Spiel stehen. Dies gestattet es dem Protokoll, böswillige Akteure zu bestrafen. Staking ist ein Mittel, damit Sie ehrlich bleiben, da Ihre Handlungen finanzielle Folgen haben werden.",
"page-staking-faq-3-question": "Kann ich „Eth2\" kaufen?",
"page-staking-faq-3-answer-p1": "Es gibt keinen „Eth2\"-Token, der zu diesem Protokoll gehört, da der heimische Coin Ether (ETH) nicht verändert wurde, als Ethereum zu Proof-of-Stake wechselte.",
- "page-staking-faq-3-answer-p2": "Es gibt allerdings abgeleitete Token/Ticker, die eingesetztes ETH repräsentieren (z. B. rETH von Rocket Pool, stETH von Lido, ETH2 von Coinbase). Erfahren Sie mehr über Staking-Pools",
+ "page-staking-faq-3-answer-p2": "Es gibt abgeleitete Token/Ticker, die eingesetztes ETH repräsentieren können (z. B. rETH von Rocket Pool, stETH von Lido, ETH2 von Coinbase). Erfahren Sie mehr über Staking-Pools.",
"page-staking-faq-4-question": "Ist Staking bereits verfügbar?",
"page-staking-faq-4-answer-p1": "Ja. Staking wurde am 1. Dezember 2020 aktiviert",
"page-staking-faq-4-answer-p2": "Das bedeutet, dass das Staking derzeit für Benutzer verfügbar ist, um ihr ETH zu hinterlegen, einen Validator-Client auszuführen und mit dem Verdienen von Belohnungen zu beginnen.",
@@ -232,9 +232,9 @@
"page-staking-meta-title": "Ethereum-Staking: Wie funktioniert es?",
"page-staking-withdrawals-important-notices": "Wichtige Hinweise",
"page-staking-withdrawals-important-notices-desc": "Auszahlungen sind noch nicht verfügbar. Bitte lesen Sie die Eth2 Merge und Post-Merge FAQ für weitere Informationen.",
- "page-upgrades-merge-btn": "Mehr zum Zusammenschluss",
+ "page-upgrades-merge-btn": "Mehr zur Zusammenführung",
"subscribe-to-ef-blog": "Abonnieren Sie den EF-Blog, um per E-Mail über die neuesten Protokollankündigungen informiert zu werden.",
"page-staking-comparison-with-other-options": "Vergleiche mit anderen Optionen",
"page-staking-any-amount": "Jeder Betrag",
- "page-staking-network-testnet": "{network} testnet"
+ "page-staking-network-testnet": "{network}-Testnetz"
}
diff --git a/src/intl/de/page-start.json b/src/intl/de/page-start.json
new file mode 100644
index 00000000000..5e822d40e3d
--- /dev/null
+++ b/src/intl/de/page-start.json
@@ -0,0 +1,38 @@
+{
+ "page-start-meta-title": "Starte mit Krypto",
+ "page-start-meta-description": "Dein Tor zur Welt von Ethereum",
+ "page-start-hero-alt": "Starte mit Krypto",
+ "page-start-title": "Erste Schritte mit Ethereum",
+ "page-start-subtitle": "Ethereum ist so viel mehr als nur der Handel mit Tokens auf einer Börse. Tauche selbst in die neue Welt ein und lerne in nur wenigen Schritten alle Grundlagen.",
+ "page-start-share-section-title": "Kennst du jemanden, der Hilfe beim Einstieg braucht?",
+ "page-start-share-section-description": "Milliarden Menschen können kein Bankkonto eröffnen oder nicht frei über ihr Geld verfügen. Das Finanzsystem von Ethereum ist immer offen und unvoreingenommen.",
+ "page-start-man-doge-alt": "Man Doge",
+ "page-start-share-modal-trigger": "Teile diese Seite",
+ "page-start-share-modal-title": "Teile diese Seite",
+ "page-start-share-modal-description": "Teile diese Seite mit deinen Freunden und deiner Familie.",
+ "page-start-share-modal-copied": "Kopiert!",
+ "page-start-share-modal-share": "Teilen",
+ "page-start-share-modal-twitter": "Twitter",
+ "page-start-share-modal-tweet-text": "Ich habe mich auf ethereum.org mit Ethereum verbunden! Probier es selbst unter {url} aus",
+ "page-start-download-wallet-title": "Lade eine Wallet herunter",
+ "page-start-download-wallet-description": "Eine Wallet ist eine App, mit der du Kryptowährungen empfangen und senden und dein Ethereum-Konto verwalten kannst.",
+ "page-start-download-wallet-checkbox": "Ich habe eine Wallet.",
+ "page-start-download-wallet-continue": "Weiter",
+ "page-start-download-wallet-get-wallet": "Wallet holen",
+ "page-start-connect-wallet-title": "Verbinde deine Wallet",
+ "page-start-connect-wallet-description": "Du kannst deine neue Wallet als einziges Konto in allen Apps und Projekten auf Ethereum verwenden. Es sind keine separaten Konten erforderlich.",
+ "page-start-connect-wallet-account-message": "Das ist dein Konto",
+ "page-start-connect-wallet-continue": "Weiter geht's",
+ "page-start-connect-wallet-finance-alt": "Finanzen",
+ "page-start-apps-title": "Lass uns ein paar Apps ausprobieren",
+ "page-start-apps-description": "Es ist an der Zeit, onchain zu gehen und von dem breiten Ökosystem an Projekten zu profitieren, die dir zur Verfügung stehen.",
+ "page-start-apps-explore-more": "Mehr entdecken",
+ "page-start-apps-go": "Go",
+ "page-start-apps-socials-tag": "SOZIALES",
+ "page-start-apps-finance-tag": "FINANZEN",
+ "page-start-apps-collectibles-tag": "SAMMELOBJEKTE",
+ "page-start-apps-farcaster-description": "Die soziale und Community-Plattform für Krypto.",
+ "page-start-apps-aave-description": "Verleihen Sie Ihre Token, um Zinsen zu erhalten, und heben Sie sie jederzeit wieder ab.",
+ "page-start-apps-uniswap-description": "Tausche deine Tokens weltweit gegen andere ein.",
+ "page-start-apps-opensea-description": "Kaufen, verkaufen, entdecken und handeln Sie Waren mit limitierter Auflage."
+}
diff --git a/src/intl/de/page-trillion-dollar-security.json b/src/intl/de/page-trillion-dollar-security.json
new file mode 100644
index 00000000000..5ee5f12a2a7
--- /dev/null
+++ b/src/intl/de/page-trillion-dollar-security.json
@@ -0,0 +1,196 @@
+{
+ "page-trillion-dollar-security-meta-title": "Trillion-Dollar-Sicherheitsprojekt – Bericht über die Übersicht der Sicherheitsherausforderungen",
+ "page-trillion-dollar-security-meta-description": "Das 1TS-Projekt ist eine ökosystemweite Anstrengung zur Verbesserung der Sicherheit von Ethereum. Dieser Bericht untersucht die bestehenden Sicherheitsherausforderungen, denen das Ökosystem gegenübersteht.",
+ "page-trillion-dollar-security-subtitle": "Trillion-Dollar-Sicherheitsprojekt",
+ "page-trillion-dollar-security-title": "Übersicht der Sicherheitsherausforderungen",
+ "page-trillion-dollar-security-hero-paragraph-1": "Ethereum ist das sicherste, widerstandsfähigste und vertrauenswürdigste Blockchain-Ökosystem. In den letzten 10 Jahren hat das Ethereum-Ökosystem die Technologie, die Standards und das Wissen entwickelt, die heute ein von Millionen genutztes Ökosystem unterstützen, das mehr als 600 Milliarden US-Dollar an Kapital beherbergt.",
+ "page-trillion-dollar-security-hero-paragraph-2": "Damit Ethereum in der nächsten Phase der globalen Einführung erfolgreich sein kann, müssen jedoch noch viele Verbesserungen vorgenommen werden. Um die Ambitionen unserer Community zu verwirklichen, muss Ethereum zu einem Ökosystem heranwachsen, in dem:",
+ "page-trillion-dollar-security-hero-paragraph-3": "Milliarden von Einzelpersonen fühlen sich wohl dabei, jeweils mehr als 1.000 USD auf der Chain zu halten, was insgesamt Billionen von Dollar auf Ethereum sichert.",
+ "page-trillion-dollar-security-hero-paragraph-4": "Unternehmen, Institutionen und Regierungen fühlen sich wohl dabei, Werte von mehr als 1 Billion Dollar in einem einzigen Vertrag oder einer einzigen Anwendung zu speichern, und sie fühlen sich wohl dabei, Transaktionen in vergleichbarer Höhe durchzuführen.",
+ "page-trillion-dollar-security-hero-paragraph-5": "Das Projekt Trillion Dollar Security (1TS) ist eine ökosystemweite Anstrengung, die Sicherheit von Ethereum zu verbessern. Dieser Bericht ist das erste Ergebnis des 1TS-Projekts. Im letzten Monat haben wir Feedback von Nutzern, Entwicklern, Sicherheitsexperten und Institutionen darüber gesammelt, wo sie die größten Herausforderungen und Verbesserungsmöglichkeiten sehen. Vielen Dank an die Hunderten von Menschen und Dutzenden von Organisationen, die sich die Zeit genommen haben, ihre Erkenntnisse mit uns zu teilen.",
+ "page-trillion-dollar-security-hero-paragraph-6": "Dieser Bericht fasst unsere Ergebnisse zusammen und deckt 6 verschiedene Bereiche ab:",
+ "page-trillion-dollar-security-report-card-title": "Sicherheitsübersichtsbericht des Ethereum-Ökosystems",
+ "page-trillion-dollar-security-download-report": "PDF herunterladen",
+ "page-trillion-dollar-security-divider-heading": "Sicherheitsübersichtsbericht des Ethereum-Ökosystems",
+ "page-trillion-dollar-security-sticky-info": "Dies ist eine Sticky-Section-Info für {section}. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque euismod, urna eu tincidunt consectetur.",
+ "page-trillion-dollar-security-content-overview-title": "Übersicht",
+ "page-trillion-dollar-security-user-experience-title": "Benutzererfahrung (UX)",
+ "page-trillion-dollar-security-user-experience-description": "Probleme, die die Fähigkeit der Benutzer beeinträchtigen, private Schlüssel sicher zu verwalten, mit On-Chain-Anwendungen zu interagieren und Transaktionen zu signieren.",
+ "page-trillion-dollar-security-smart-contract-title": "Sicherheit von Smart Contracts",
+ "page-trillion-dollar-security-smart-contract-description": "Die Sicherheit der Smart-Contract-Komponenten von Ethereum-Anwendungen und der Lebenszyklus der Softwareproduktion, der sie prägt.",
+ "page-trillion-dollar-security-infrastructure-title": "Infrastruktur- und Cloud-Sicherheit",
+ "page-trillion-dollar-security-infrastructure-description": "Probleme mit der Infrastruktur (sowohl krypto-spezifisch als auch veraltet), von der Ethereum-Apps abhängen, wie L2-Chains, RPCs, Cloud-Hosting-Dienste und mehr.",
+ "page-trillion-dollar-security-consensus-title": "Konsensprotokoll",
+ "page-trillion-dollar-security-consensus-description": "Die Sicherheitseigenschaften des Kernprotokolls, das die Ethereum-Blockchain selbst vor Angriffen oder Manipulationen schützt.",
+ "page-trillion-dollar-security-incident-title": "Überwachung, Reaktion auf Vorfälle und Abwehr",
+ "page-trillion-dollar-security-incident-description": "Die Herausforderungen, denen Benutzer und Organisationen bei der Reaktion auf Sicherheitsverletzungen gegenüberstehen, insbesondere bei der Wiederbeschaffung von Geldern oder der Bewältigung der Nachwirkungen.",
+ "page-trillion-dollar-security-social-title": "Soziale Ebene und Governance",
+ "page-trillion-dollar-security-social-description": "Die Open-Source-Governance, die Community und das Ökosystem der Organisationen von Ethereum.",
+ "page-trillion-dollar-security-hero-closing-paragraph-1": "Dieser erste Bericht konzentriert sich auf die Identifizierung und Abbildung der verbleibenden Probleme und Herausforderungen. Der nächste Schritt wird darin bestehen, die Themen mit der höchsten Priorität auszuwählen, Lösungen zu identifizieren und mit dem Ökosystem zusammenzuarbeiten, um sie anzugehen.",
+ "page-trillion-dollar-security-hero-closing-paragraph-2": "Da das Ethereum-Ökosystem dezentralisiert ist, kann die Sicherung von Ethereum nicht von einer einzigen Entität durchgeführt werden. Der Technologie-Stack von Ethereum wird von unabhängigen Organisationen auf der ganzen Welt aufgebaut und gewartet, von Wallets über Infrastruktur bis hin zu Entwickler-Tools. Während das 1TS-Projekt von der Ethereum Foundation koordiniert wird, brauchen wir Ihre Hilfe, um Ethereum zu sichern.",
+ "page-trillion-dollar-security-hero-closing-paragraph-3": "Sie können zum 1TS-Sicherheitsprojekt beitragen, indem Sie Ihr Feedback und Ihre Ideen teilen:",
+ "page-trillion-dollar-security-feedback-question-1": "Gibt es Probleme in der Ethereum-Sicherheit, die Sie sehen und die nicht in diesem Bericht enthalten sind?",
+ "page-trillion-dollar-security-feedback-question-2": "Was sind Ihrer Meinung nach die höchsten Prioritäten der unten untersuchten Themen?",
+ "page-trillion-dollar-security-feedback-question-3": "Welche Ideen oder Lösungen haben Sie, um diese Probleme anzugehen?",
+ "page-trillion-dollar-security-contact-paragraph": "Wir freuen uns, von Ihnen unter trilliondollarsecurity@ethereum.org zu hören.",
+ "page-trillion-dollar-security-section-1-intro": "Sicherheit beginnt bei der Schnittstelle, die Menschen zur Interaktion mit Ethereum nutzen. Diese Grenze zwischen den Benutzern und der Blockchain selbst ist eine ständige Quelle für Sicherheitsherausforderungen.",
+ "page-trillion-dollar-security-section-1-paragraph-1": "Ein entscheidendes Merkmal von Blockchains ist die atomare Natur von Transaktionen: Sobald eine Aktualisierung in die Blockchain eingetragen ist, gibt es keine Möglichkeit mehr, einzugreifen oder sie rückgängig zu machen. Dies bietet starke Garantien für Konsistenz und Sicherheit auf Protokollebene, setzt Benutzer jedoch einem erhöhten operativen Risiko aus: Ein einziger Fehler, ein kompromittierter Schlüssel oder eine überstürzte Genehmigung können zu einem irreversiblen Verlust führen.",
+ "page-trillion-dollar-security-section-1-paragraph-2": "Infolgedessen liegt eine erhebliche Sicherheitslast beim Benutzer. Um Ethereum sicher zu nutzen, müssen Einzelpersonen und Organisationen Schlüssel sicher aufbewahren und verwalten, mit On-Chain-Anwendungen interagieren und ihre Schlüssel verwenden, um Transaktionen zur Übertragung von Vermögenswerten zu signieren oder den Zustand von Ethereum anderweitig zu aktualisieren.",
+ "page-trillion-dollar-security-section-1-paragraph-3": "Jede dieser Anforderungen birgt Risiken wie die Kompromittierung oder den Verlust von Schlüsseln, übereilte oder uninformierte Genehmigungen oder die Kompromittierung der Wallet-Software, auf die sich Benutzer verlassen, um sie bei der Interaktion mit Ethereum zu informieren und zu leiten.",
+ "page-trillion-dollar-security-section-1-1-title": "1.1 Schlüsselverwaltung",
+ "page-trillion-dollar-security-section-1-1-paragraph-1": "Viele Benutzer sind nicht in der Lage, kryptografische Schlüssel sicher zu verwalten.",
+ "page-trillion-dollar-security-section-1-1-paragraph-2": "Die meisten weit verbreiteten Software-Wallets setzen darauf, dass die Benutzer Seed-Phrasen sicher speichern, die ihren zugrunde liegenden kryptografischen privaten Schlüssel repräsentieren, was sie oft dazu verleitet, unsichere Umgehungen zu verwenden, wie das Speichern von Seed-Phrasen im Klartext, in Cloud-Diensten oder das Aufschreiben auf Papier.",
+ "page-trillion-dollar-security-section-1-1-paragraph-3": "Hardware-Wallets sind eine Alternative, die es Benutzern ermöglicht, einen kryptografischen Schlüssel zu verwalten, der in einem speziellen physischen Gerät gespeichert ist. Hardware-Wallets haben jedoch ihre eigenen Schwachstellen und Angriffsflächen. Hardware-Wallets können verloren gehen, beschädigt oder gestohlen werden. Viele Hardware-Wallets sind nicht Open Source und können undurchsichtige Lieferketten haben, was das Risiko eines Lieferkettenangriffs erhöht, bei dem kompromittierte Geräte auf den Markt gebracht werden.",
+ "page-trillion-dollar-security-section-1-1-paragraph-4": "Unabhängig davon, ob Schlüssel in einer Software- oder Hardware-Wallet verwaltet werden, sind viele Benutzer verständlicherweise nervös, wenn es um die Selbstverwahrung geht, wenn diese durch physischen Diebstahl oder Übergriffe kompromittiert werden kann.",
+ "page-trillion-dollar-security-section-1-1-paragraph-5": "Unternehmens- und institutionelle Nutzer stehen vor zusätzlichen Herausforderungen bei der Schlüsselverwaltung. Wenn einzelne Mitarbeiter Schlüssel halten (z. B. als Teil einer Multisig-Wallet), muss die Organisation in der Lage sein, diese aufgrund von Personalwechseln im Laufe der Zeit zu ersetzen und neue zu erstellen. Compliance-Anforderungen in verschiedenen Branchen und Gerichtsbarkeiten können benutzerdefinierte Workflows oder Audit-Trails erfordern, die von der bestehenden Wallet-Software nicht unterstützt werden. In einigen Fällen wenden sich Unternehmensnutzer an Drittverwahrer für digitale Vermögenswerte, was eine weitere Ebene von Sicherheitsrisiken mit sich bringen kann, die zu berücksichtigen sind.",
+ "page-trillion-dollar-security-section-1-2-title": "1.2 Blindes Signieren & Transaktionsunsicherheit",
+ "page-trillion-dollar-security-section-1-2-paragraph": "Benutzer genehmigen routinemäßig Transaktionen \"blind\", ohne zu verstehen, was sie tun. Wallets präsentieren oft rohe hexadezimale Daten, gekürzte Vertragsadressen oder andere Informationen, die für den Benutzer nicht ausreichen, um die Konsequenzen einer bestimmten Transaktion zu verstehen. Dies macht Benutzer aller Art anfällig für bösartige Smart Contracts, Phishing, Betrug, gefälschte Schnittstellen, Kompromittierungen des Frontends und grundlegende Benutzerfehler.",
+ "page-trillion-dollar-security-section-1-3-title": "1.3 Genehmigungs- und Berechtigungsverwaltung",
+ "page-trillion-dollar-security-section-1-3-paragraph-1": "In vielen Ethereum-Anwendungen ist es üblich, dass Benutzer der zugrunde liegenden Anwendung im Rahmen der normalen Nutzung bestimmte Berechtigungen erteilen. Beispielsweise könnte ein Benutzer einer dezentralisierten Börse wie Uniswap die Erlaubnis erteilen, seine Tokens zu bewegen, um sie gegen ETH zu tauschen.",
+ "page-trillion-dollar-security-section-1-3-paragraph-2": "Diese Genehmigungen können betragsmäßige Beschränkungen haben, aber viele Wallets gewähren standardmäßig unbegrenzte Genehmigungen ohne Ablaufdatum. Es gibt für Benutzer keine Möglichkeit, ihre ausstehenden Genehmigungen in den meisten Wallets zu verwalten oder zu überprüfen.",
+ "page-trillion-dollar-security-section-1-3-paragraph-3": "Dies kann Benutzer bösartigen Apps oder kompromittierten Frontends aussetzen, da das Standardmuster für viele Benutzer darin besteht, unbegrenzte Genehmigungen zu erteilen, die zum Abziehen ihrer Gelder verwendet werden können. Selbst wenn ein Benutzer eine Genehmigung für einen legitimen Smart Contract erteilt, könnte der kompromittierte Vertrag die Gelder des Benutzers abziehen, wenn dieser Vertrag später kompromittiert wird, während die Genehmigung bestehen bleibt.",
+ "page-trillion-dollar-security-section-1-3-paragraph-4": "Dies ist gleichermaßen ein Risiko für organisationale Nutzer. Beispielsweise könnte eine Organisation aus betrieblichen Gründen einem DEX-Router eine unbegrenzte USDC-Genehmigung erteilen, was sie dann Risiken aussetzt, wenn der Router-Vertrag aktualisiert wird.",
+ "page-trillion-dollar-security-section-1-4-title": "1.4 Kompromittierte Weboberflächen",
+ "page-trillion-dollar-security-section-1-4-paragraph-1": "Die meisten Benutzer interagieren nicht direkt mit einem Smart Contract, sondern über eine Weboberfläche auf ihrem mobilen Gerät oder Webbrowser.",
+ "page-trillion-dollar-security-section-1-4-paragraph-2": "Diese Frontends können durch bekannte Mittel wie DNS-Hijacking, bösartige JavaScript-Injektionen, unsicheres Hosting oder verschiedene Abhängigkeiten von Drittanbietern anfällig für Angriffe sein. Eine kompromittierte App-UX kann Benutzer aller Art zu bösartigen Smart Contracts umleiten oder sie dazu verleiten, irreführende Transaktionen zu unterzeichnen.",
+ "page-trillion-dollar-security-section-1-5-title": "1.5 Datenschutz",
+ "page-trillion-dollar-security-section-1-5-paragraph-1": "Datenschutz kann Sicherheitsrisiken für Nutzer aller Art mindern oder verstärken.",
+ "page-trillion-dollar-security-section-1-5-paragraph-2": "Schwächere Datenschutzmaßnahmen setzen einzelne Benutzer einer Vielzahl von gezielten Bedrohungen wie Phishing, Ausbeutung, Betrug oder physischen Angriffen aus. Viele gängige UX-Muster setzen Benutzer Risiken aus, z. B. durch die Wiederverwendung von Adressen, KYC-Daten und andere Metadaten-Lecks.",
+ "page-trillion-dollar-security-section-1-5-paragraph-3": "Für Institutionen und Unternehmen ist der Datenschutz oft eine grundlegende Geschäftsanforderung aus Compliance-Gründen oder für bestimmte Anwendungsfälle. Zusätzlich zu diesen Problemen kann er eine Anfälligkeit für spezifische Sicherheitsrisiken schaffen. Beispielsweise kann ein Benutzer eines auf Ethereum basierenden Lieferkettensystems starke Datenschutzgarantien benötigen, um geistiges Eigentum zu schützen, das kompromittiert werden könnte, wenn das System transparent wäre.",
+ "page-trillion-dollar-security-section-1-6-title": "1.6 Fragmentierung",
+ "page-trillion-dollar-security-section-1-6-paragraph-1": "Es mangelt an Konsistenz, wie verschiedene Wallets Kernverhaltensweisen wie die Anzeige von Transaktionen, die Handhabung von Genehmigungen oder die Kennzeichnung von Verträgen handhaben. Diese Fragmentierung der Benutzererfahrung erschwert es dem Benutzer, den sicheren Umgang mit Wallets zu erlernen, und erhöht die Risiken.",
+ "page-trillion-dollar-security-section-1-6-paragraph-2": "Benutzer können sich beispielsweise nicht auf konsistente UX-Hinweise verlassen, um sich vor Phishing und Spoofing zu schützen, da diese sich zwischen den Wallets unterscheiden. Benutzer können keine verlässlichen Erwartungen darüber bilden, wie Ethereum funktioniert, wenn jedes Werkzeug anders funktioniert.",
+ "page-trillion-dollar-security-section-2-intro": "Smart Contracts sind die On-Chain-Komponenten von Ethereum-Anwendungen: der Code, der Gelder hält, Zugriffskontrollen definiert und die Geschäftslogik der Anwendung durchsetzt. Da Smart Contracts in der Regel transparent und für jedermann zugänglich sind, stellen sie eine kritische Angriffsfläche bei der Betrachtung der Sicherheit im Ethereum-Ökosystem dar.",
+ "page-trillion-dollar-security-section-2-paragraph-1": "Die Sicherheit von Smart Contracts hat sich im Laufe der Geschichte von Ethereum radikal verbessert. Frühe Sicherheitsvorfälle wie der DAO-Hack motivierten das Ökosystem, sich zu professionalisieren und die Sicherheitsvorkehrungen über den gesamten Software-Lebenszyklus zu verbessern, der zur Bereitstellung von Code auf der Chain führt. Zu den wichtigsten Fortschritten gehören:",
+ "page-trillion-dollar-security-section-2-list-1": "Sicherheitsaudits wurden zur Standardpraxis, wobei mehrere Sicherheitsfirmen in das Ökosystem eintraten und Expertise entwickelten.",
+ "page-trillion-dollar-security-section-2-list-2": "Tooling-, Test- und statische Analysesysteme reiften heran und wurden zur Standardpraxis.",
+ "page-trillion-dollar-security-section-2-list-3": "Bibliotheken mit vorab geprüften gängigen Komponenten gaben Entwicklern standardmäßig sichere Bausteine an die Hand.",
+ "page-trillion-dollar-security-section-2-list-4": "Formale Verifizierungstechniken wurden übernommen, insbesondere für kettenübergreifende Brücken, Staking-Systeme und Verträge mit hohem Wert.",
+ "page-trillion-dollar-security-section-2-list-5": "Die Sicherheitskultur und die bewährten Praktiken des Ökosystems haben sich verbessert.",
+ "page-trillion-dollar-security-section-2-list-6": "Die Schaffung bedeutender Kopfgeldprogramme, die die App-Ebene gehärtet haben.",
+ "page-trillion-dollar-security-section-2-paragraph-2": "Dennoch gibt es in diesem Bereich weiterhin Schwachstellen und Verbesserungspotenzial.",
+ "page-trillion-dollar-security-section-2-1-title": "2.1 Vertragsschwachstellen",
+ "page-trillion-dollar-security-section-2-1-paragraph": "Trotz der Fortschritte bei der Sicherheit von Smart Contracts gibt es immer noch Schwachstellen, die zu erheblichen Sicherheitsproblemen führen können, darunter:",
+ "page-trillion-dollar-security-section-2-1-list-title-1": "Risiko bei Vertrags-Upgrades",
+ "page-trillion-dollar-security-section-2-1-list-desc-1": "Einige Verträge sind so konzipiert, dass sie nach der Bereitstellung geändert werden können, damit ein Entwicklungsteam eine Anwendung weiterhin aktualisieren und verbessern kann. Dies birgt jedoch Risiken. Upgrades könnten zu neuen Schwachstellen oder zum Totalverlust von Benutzergeldern im Falle eines bösartigen Upgrades führen.",
+ "page-trillion-dollar-security-section-2-1-list-title-2": "Wiedereintritt",
+ "page-trillion-dollar-security-section-2-1-list-desc-2": "wobei Vertrag A einen externen Vertrag B aufruft, bevor er seinen eigenen internen Zustand aktualisiert, und Vertrag B den ursprünglichen Vertrag A zurückruft, bevor der erste Aufruf abgeschlossen ist.",
+ "page-trillion-dollar-security-section-2-1-list-title-3": "Unsichere Verwendung externer Bibliotheken",
+ "page-trillion-dollar-security-section-2-1-list-desc-3": "bei dem ein Vertrag eine externe Bibliothek aufruft, die ungeprüft, bösartig oder aktualisierbar sein kann.",
+ "page-trillion-dollar-security-section-2-1-list-title-4": "Nicht geprüfte Komponenten",
+ "page-trillion-dollar-security-section-2-1-list-desc-4": "Obwohl die Prüfung und Verwendung von Standardbibliotheken verbessert wurde, verlassen sich Entwickler manchmal auf ungeprüfte Komponenten in ihren Anwendungen.",
+ "page-trillion-dollar-security-section-2-1-list-title-5": "Fehler bei der Zugriffskontrolle",
+ "page-trillion-dollar-security-section-2-1-list-desc-5": "bei denen Berechtigungen falsch konfiguriert oder zu weit gefasst sind, was Angreifern erlaubt, bösartige Aktionen durchzuführen.",
+ "page-trillion-dollar-security-section-2-1-list-title-6": "Unbefugter Zugriff",
+ "page-trillion-dollar-security-section-2-1-list-desc-6": "bei dem ein privater Schlüssel, der den Vertrag kontrollieren kann, von einem böswilligen Akteur erlangt wird.",
+ "page-trillion-dollar-security-section-2-1-list-title-7": "Kettenübergreifende Brücken und Cross-Chain-Interaktionen",
+ "page-trillion-dollar-security-section-2-1-list-desc-7": "Kettenübergreifende Brücken und Cross-Chain-Protokolle bringen zusätzliche Komplexität mit sich, und Angreifer können Schwächen bei der Übermittlung oder Validierung von Cross-Chain-Nachrichten ausnutzen.",
+ "page-trillion-dollar-security-section-2-1-list-title-8": "Delegierung von extern verwalteten Konten (EOA) oder Missbrauch von Signaturen",
+ "page-trillion-dollar-security-section-2-1-list-desc-8": "Bösartige Anwendungen können Benutzer dazu verleiten, die volle Delegierung ihres Kontos an eine andere Partei zu unterzeichnen, was Diebstahl ermöglicht. Bösartige Anwendungen können auch signierte Nachrichten des Benutzers auf unerwartete Weise verwenden, z. B. bei einem Replay-Angriff.",
+ "page-trillion-dollar-security-section-2-1-list-title-9": "Aufkommendes Risiko von Fehlern, die durch KI-Code-Generierung oder automatisierte Refactoring-Tools eingeführt werden",
+ "page-trillion-dollar-security-section-2-2-title": "2.2 Entwicklererfahrung, Tooling und Programmiersprachen",
+ "page-trillion-dollar-security-section-2-2-paragraph": "Schwachstellen landen als Ergebnis von Entwicklerfehlern in bereitgestelltem Code. Verbessertes Entwickler-Tooling hat die Bereitstellung sicherer Smart Contracts erheblich erleichtert. Dennoch bleiben Probleme bestehen.",
+ "page-trillion-dollar-security-section-2-2-list-title-1": "Fehlen sicherer Standardeinstellungen in gängigen Frameworks",
+ "page-trillion-dollar-security-section-2-2-list-desc-1": "Einige Tools priorisieren Flexibilität oder Geschwindigkeit gegenüber Sicherheit und legen unsichere Standardeinstellungen wie unbegrenzte Token-Genehmigungen in der approve()-Funktion fest oder versäumen es, standardmäßig Zugriffskontrollmuster einzubeziehen.",
+ "page-trillion-dollar-security-section-2-2-list-title-2": "Benutzerdefinierter Code für erweiterte Betriebskontrollen",
+ "page-trillion-dollar-security-section-2-2-list-desc-2": "Institutionelle Benutzer mit komplexen betrieblichen Anforderungen müssen oft erforderliche Funktionen von Grund auf neu erstellen, was das Risiko von Schwachstellen erhöht. Es mangelt an standardisierten, sicheren Komponenten oder Frameworks für fortgeschrittene Sicherheits-Workflows.",
+ "page-trillion-dollar-security-section-2-2-list-title-3": "Inkonsistente Testabdeckung",
+ "page-trillion-dollar-security-section-2-2-list-desc-3": "über Tooling-Stacks hinweg sowie ein Mangel an Normen für die Verwendung bewährter Techniken wie Fuzzing oder Invariantenprüfung.",
+ "page-trillion-dollar-security-section-2-2-list-title-4": "Geringe Akzeptanz von formalen Verifikationsmethoden",
+ "page-trillion-dollar-security-section-2-2-list-desc-4": "Formale Verifikationstechniken sind leistungsstark, aber sie sind komplex, kostspielig, erfordern spezielles Fachwissen und sind nicht gut in Standard-Entwickler-Workflows integriert, wo sie viel früher in der Softwareproduktion zur Überprüfung der Sicherheit auf Spezifikationsebene eingesetzt werden könnten.",
+ "page-trillion-dollar-security-section-2-2-list-title-5": "Probleme im Zusammenhang mit der Vertragsverifizierung",
+ "page-trillion-dollar-security-section-2-2-list-desc-5": "Benutzer und Entwickler können die Vertrauenswürdigkeit von bereitgestellten Verträgen, den Umfang ihrer Sicherheitsvalidierung (z. B. Code-Audits) oder das Vorhandensein latenter Risiken nicht einfach bewerten. Obwohl es für diesen Zweck Lösungen gibt, bleiben viele Probleme bestehen. Tooling, das diese Probleme angeht, ist nicht weit verbreitet, die Standards, die die Ansätze vereinheitlichen würden, bleiben fragmentiert, und einige der bestehenden Dienste sind selbst zentralisierte Abhängigkeiten.",
+ "page-trillion-dollar-security-section-2-2-list-title-6": "Compiler-Risiken",
+ "page-trillion-dollar-security-section-2-2-list-desc-6": "Compiler (die Software, die menschenlesbaren Code wie Solidity in den vom EVM selbst verwendeten Bytecode umwandelt) können Fehler aufweisen, die Fehler in Smart Contracts einführen, bevor diese bereitgestellt werden. Das Ethereum-Ökosystem hängt heute hauptsächlich vom solc-Compiler ab, was bedeutet, dass ein Fehler weitreichende Auswirkungen haben könnte.",
+ "page-trillion-dollar-security-section-2-2-list-title-7": "Vielfalt und Tiefe der Programmiersprachen",
+ "page-trillion-dollar-security-section-2-2-list-desc-7": "Obwohl Solidity ein tiefes Tooling-Ökosystem hat, das darauf aufbaut, wünschen sich einige Entwickler modernere Sicherheitsfunktionen, die in anderen Programmiersprachen zu finden sind, wie z. B. Speichersicherheit.",
+ "page-trillion-dollar-security-section-2-3-title": "2.3 Risikobewertung von On-Chain-Code",
+ "page-trillion-dollar-security-section-2-3-paragraph": "Institutionen und Unternehmen haben bestehende Prozesse, Standards und Anforderungen zur Bewertung der Sicherheit von Technologien und Systemen, von denen sie abhängen. Bestehende Frameworks lassen sich jedoch oft nicht sauber auf Smart Contracts abbilden, da sie in der Regel von veränderbarem Code, zentralisierter Änderungskontrolle und klaren Verantwortlichkeiten oder rechtlicher Haftung ausgehen. Systeme, die auf Smart Contracts basieren, können diese Annahmen manchmal durchbrechen, was es für Organisationen schwierig macht, Ethereum zu übernehmen und Risiken angemessen zu managen.",
+ "page-trillion-dollar-security-section-3-intro": "Viele Anwendungsfälle von Ethereum hängen von einer Vielzahl von Infrastrukturanbietern ab, darunter sowohl krypto-spezifische Infrastruktur (z. B. Layer-2-Ketten, RPC-Anbieter) als auch traditionelle Cloud- und Internet-Infrastruktur (z. B. AWS, CDN, DNS).",
+ "page-trillion-dollar-security-section-3-paragraph-1": "Diese Systeme stellen eine Angriffsfläche sowohl für die Wallet- und Anwendungsebene (z. B. RPC-Endpunkte für Wallets) als auch für das Ethereum-Protokoll selbst dar (z. B. werden viele Validatoren in Cloud-Infrastrukturen gehostet). Die Kompromittierung privater Schlüssel, Phishing und ein Mangel an granularen Zugriffskontrollen können zu großflächigen Ausfällen, Diebstahl oder unbefugten Änderungen führen, selbst wenn das zugrundeliegende Blockchain-Protokoll sicher bleibt.",
+ "page-trillion-dollar-security-section-3-1-title": "3.1 Layer-2-Ketten",
+ "page-trillion-dollar-security-section-3-1-paragraph": "Layer-2-Ketten (L2s) dienen als Erweiterungen für Ethereum und ermöglichen schnellere und gebührenärmere Umgebungen, während sie einige der charakteristischen Sicherheitsgarantien des Ethereum-Mainnets beibehalten (abhängig von ihrem spezifischen Design). Sie haben jedoch auch ihre eigenen, ausgeprägten Angriffsflächen, darunter:",
+ "page-trillion-dollar-security-section-3-1-list-title-1": "Komplexität von Multi-Hop-überbrückten Vermögenswerten",
+ "page-trillion-dollar-security-section-3-1-list-desc-1": "Wenn Vermögenswerte zwischen L1 und mehreren L2s reisen, sind sie mehreren Sätzen von Verträgen ausgesetzt, die alle sicher sein müssen. Abweichende Buchführung oder Ausfälle in L2-Ketten können Schwachstellen einführen, die von Angreifern ausgenutzt werden können.",
+ "page-trillion-dollar-security-section-3-1-list-title-2": "Rollup-L2s stützen sich auf Beweissysteme, um die Korrektheit von Zustandsaktualisierungen durchzusetzen.",
+ "page-trillion-dollar-security-section-3-1-list-desc-2": "Fehler oder Fehlkonfigurationen in diesen Systemen können die Finalisierung verzögern oder verhindern oder die Finalisierung falscher Zustandsaktualisierungen ermöglichen, was zum Verlust von Benutzergeldern führt.",
+ "page-trillion-dollar-security-section-3-1-list-title-3": "Sicherheitsräte sind Gruppen von Schlüsselhaltern, die als \"Backup\"-Mechanismus dienen, um L2-Software zu aktualisieren oder auf bestimmte Notfälle zu reagieren",
+ "page-trillion-dollar-security-section-3-1-list-desc-3": "Sicherheitsräte selbst stellen Risiken dar, da Kompromittierung oder Absprachen unter den Mitgliedern die Gelder der Benutzer gefährden oder Vermögenswerte einfrieren könnten.",
+ "page-trillion-dollar-security-section-3-1-paragraph-2": "Siehe L2Beat für ein detailliertes Framework und ein Überwachungs-Dashboard, das die Leistung und Sicherheit von L2 bewertet und vergleicht.",
+ "page-trillion-dollar-security-section-3-2-title": "3.2 RPC- und Node-Infrastruktur",
+ "page-trillion-dollar-security-section-3-2-paragraph-1": "Ethereum-Anwendungen sind für RPC-Zugang, APIs und Node-Dienste von einer kleinen Anzahl von Infrastrukturanbietern abhängig. Dazu gehören krypto-spezifische Infrastrukturanbieter sowie traditionelle Cloud-Dienste, die üblicherweise zum Hosten von Nodes verwendet werden (z. B. AWS, Cloudflare, Hetzner).",
+ "page-trillion-dollar-security-section-3-2-paragraph-2": "Wenn diese Infrastrukturanbieter offline gingen oder versuchten, den Zugang zu zensieren oder zu drosseln, könnten viele Benutzer daran gehindert werden, über ihre Wallet oder Anwendung auf Ethereum zuzugreifen, bis sie zu einem neuen RPC- oder anderen Infrastrukturanbieter migrieren konnten. Einige dieser Anbieter haben in der Vergangenheit Konten im Zusammenhang mit Blockchain-Aktivitäten gesperrt oder geschlossen, was Bedenken hinsichtlich ihrer langfristigen Zuverlässigkeit für dezentralisierte Anwendungen aufwirft.",
+ "page-trillion-dollar-security-section-3-3-title": "3.3 Schwachstellen auf DNS-Ebene",
+ "page-trillion-dollar-security-section-3-3-paragraph": "Das Domain Name System (DNS) ist eine grundlegende Schicht des Internets, aber es ist auch zentralisiert und kann kompromittiert werden. Viele Benutzer greifen über Web-Domains auf Apps zu, die anfällig sind für:",
+ "page-trillion-dollar-security-section-3-3-list-1": "DNS-Hijacking, bei dem ein Angreifer ein bösartiges, falsches Frontend einfügt.",
+ "page-trillion-dollar-security-section-3-3-list-2": "Domain-Beschlagnahme, bei der eine Regierung oder ein Registrar Domains beschlagnahmen kann.",
+ "page-trillion-dollar-security-section-3-3-list-3": "Phishing über ähnlich aussehende Domains, bei denen Angreifer fast identische Namen registrieren, um Benutzer zu verwirren.",
+ "page-trillion-dollar-security-section-3-4-title": "3.4 Software-Lieferkette und Bibliotheken",
+ "page-trillion-dollar-security-section-3-4-paragraph": "Ethereum-Entwickler verlassen sich auf Open-Source-Bibliotheken, die oft direkt von Diensten wie npm, crates.io oder GitHub bezogen werden. Wenn diese Bibliotheken kompromittiert werden, können sie ein Vektor für Angriffe sein wie:",
+ "page-trillion-dollar-security-section-3-4-list-title-1": "Injektion bösartiger Pakete",
+ "page-trillion-dollar-security-section-3-4-list-desc-1": "bei der Angreifer ein weit verbreitetes Paket kompromittieren oder eines unter einem ähnlichen Namen veröffentlichen",
+ "page-trillion-dollar-security-section-3-4-list-title-2": "Übernommene Abhängigkeiten",
+ "page-trillion-dollar-security-section-3-4-list-desc-2": "bei der Maintainer die Kontrolle über ein Projekt verlieren und ein böswilliger Akteur schädlichen Code einfügt",
+ "page-trillion-dollar-security-section-3-4-list-title-3": "Kompromittierung von Entwicklern",
+ "page-trillion-dollar-security-section-3-4-list-desc-3": "bei der installierte Pakete Code enthalten, der dem Angreifer die Kontrolle über den Computer des Entwicklers gibt.",
+ "page-trillion-dollar-security-section-3-5-title": "3.5 Frontend-Bereitstellungsdienste und damit verbundene Risiken",
+ "page-trillion-dollar-security-section-3-5-paragraph": "Viele Ethereum-Anwendungen stellen ihre Frontends über ein Content Delivery Network (CDN) oder eine cloudbasierte Hosting-Plattform (z. B. Vercel, Netlify, Cloudflare) bereit. Wenn diese Dienste kompromittiert werden, können sie ein Vektor für Angriffe wie bösartige JavaScript-Injektionen sein, bei denen Angreifer den Benutzern ein verändertes Frontend bereitstellen.",
+ "page-trillion-dollar-security-section-3-6-title": "3.6 Zensur auf Ebene des Internetdienstanbieters",
+ "page-trillion-dollar-security-section-3-6-paragraph-1": "Internetdienstanbieter (ISPs) oder Nationalstaaten können die Kontrolle über die zugrunde liegende Internetinfrastruktur nutzen, um den Zugang zu Ethereum zu zensieren. Solche Angriffe könnten beispielsweise umfassen:",
+ "page-trillion-dollar-security-section-3-6-list-1": "Blockieren oder Drosseln des Datenverkehrs zu gängigen Ethereum-Ports",
+ "page-trillion-dollar-security-section-3-6-list-2": "Filtern von DNS-Anfragen, die zu Ethereum-bezogenen Diensten auflösen",
+ "page-trillion-dollar-security-section-3-6-list-3": "Geofencing oder IP-Sperren gegen bekannte Ethereum-Nodes",
+ "page-trillion-dollar-security-section-3-6-list-4": "Tiefenpaketinspektion zur Identifizierung und Zensur von Ethereum-Protokoll-bezogenem Datenverkehr",
+ "page-trillion-dollar-security-section-3-6-paragraph-2": "Viele dieser grundlegenden Techniken werden heute bereits von autoritären Regierungen auf der ganzen Welt eingesetzt, um den Zugang zu Informationen, Protestwerkzeugen oder Kryptowährungen zu unterdrücken.",
+ "page-trillion-dollar-security-section-4-intro": "Das Konsensprotokoll von Ethereum definiert, wie das Netzwerk den Zustand der Ethereum-Blockchain aktualisiert und zu einer Einigung kommt. Dieses Protokoll ist die Grundlage dessen, was Ethereum zu einer vertrauenswürdigen Plattform für Geld, Finanzen, Identität, Governance, reale Vermögenswerte und mehr macht.",
+ "page-trillion-dollar-security-section-4-paragraph-1": "Das Konsensprotokoll von Ethereum hat sich in der Praxis als robust erwiesen, mit null Ausfallzeiten seit dem Start im Jahr 2015 und über mehrere Upgrades hinweg. Es gibt jedoch weiterhin langfristige Verbesserungsmöglichkeiten, um das System widerstandsfähiger und sicherer zu machen.",
+ "page-trillion-dollar-security-section-4-1-title": "4.1 Brüchigkeit des Konsenses und Wiederherstellungsrisiken",
+ "page-trillion-dollar-security-section-4-1-paragraph": "Die Fork-Choice- und Finalitätsregeln von Ethereum sind widerstandsfähig, aber nicht unverwundbar. Unter bestimmten Randbedingungen (wie lang andauernde Meinungsverschiedenheiten zwischen Validatoren, Client-Fehler oder Netzwerkpartitionen) könnte der Konsens ins Stocken geraten oder vorübergehend abweichen. Unter extremen Bedingungen könnte dies zu kaskadierenden Strafen für Validatoren durch Inaktivitätslecks oder Slashing führen, was wiederum zu einer Kapitalflucht von Validatoren führen könnte.",
+ "page-trillion-dollar-security-section-4-2-title": "4.2 Client-Diversität",
+ "page-trillion-dollar-security-section-4-2-paragraph": "Die branchenführende Client-Vielfalt von Ethereum schützt das Netzwerk vor Fehlern in einem einzelnen Client. Die Client-Vielfalt könnte jedoch durch eine stärkere Akzeptanz von Minderheits-Clients noch verbessert werden, um diese Risiken weiter zu reduzieren.",
+ "page-trillion-dollar-security-section-4-3-title": "4.3 Zentralisierung des Stakings und Pool-Dominanz",
+ "page-trillion-dollar-security-section-4-3-paragraph": "Ein erheblicher Teil des Validator-Gewichts ist in Liquid-Staking-Protokollen, Depotdiensten und großen Node-Betreibern konzentriert. Diese Konzentration kann zu Risiken führen wie:",
+ "page-trillion-dollar-security-section-4-3-list-1": "Übernahme oder Beeinflussung der Governance. Wenn Entitäten, die große Mengen an Stake kontrollieren (oder Entitäten mit rechtlicher Macht, diese Entitäten zu beeinflussen), koordiniert zusammenarbeiten, könnten sie einen übermäßigen Einfluss darauf haben, welche Blöcke vorgeschlagen und bestätigt werden, was potenziell zur Zensur von Benutzern oder zur Beeinflussung von Protokoll-Upgrades führen könnte.",
+ "page-trillion-dollar-security-section-4-3-list-2": "Homogenität bei der Client-Wahl und dem Infrastrukturaufbau, was das Risiko korrelierter Ausfälle erhöhen kann.",
+ "page-trillion-dollar-security-section-4-4-title": "4.4 Undefiniertes soziales Slashing und Koordinationslücken",
+ "page-trillion-dollar-security-section-4-4-paragraph": "In einigen extremen Fehlermodi würde sich Ethereum auf \"soziales Slashing\" verlassen, um Validatoren zu bestrafen, die böswillig gehandelt haben, um das Netzwerk anzugreifen (siehe Abschnitt 6.1). Die Infrastruktur, Normen und erwarteten Prozesse für diese Art von Slashing sind jedoch unterentwickelt. Es gibt keinen etablierten Mechanismus, den die Community für diesen Prozess nutzen würde.",
+ "page-trillion-dollar-security-section-4-5-title": "4.5 Ökonomische und spieltheoretische Angriffsvektoren",
+ "page-trillion-dollar-security-section-4-5-paragraph": "Viele potenzielle ökonomische Angriffsvektoren sind noch unzureichend untersucht, darunter:",
+ "page-trillion-dollar-security-section-4-5-list-1": "Griefing-Angriffe oder Slash-Griefing. Validatoren können Kosten oder Slashing-Strafen erleiden, die nicht auf eigene Fehler zurückzuführen sind, sondern auf feindseliges Verhalten, das ausschließlich dazu dient, anderen auf Kosten des Angreifers zu schaden.",
+ "page-trillion-dollar-security-section-4-5-list-2": "Strategische Ausstiege oder zeitgesteuerte Inaktivität. Validatoren könnten absichtlich offline gehen oder zu kritischen Zeiten aussteigen, um Gewinne zu maximieren oder den Konsens mit minimalen Strafen zu stören.",
+ "page-trillion-dollar-security-section-4-5-list-3": "Absprachen zwischen Validatoren oder Relays. Koordiniertes Verhalten zwischen Validatoren oder zwischen Relays und Validatoren könnte die Dezentralisierung verringern oder MEV extrahieren.",
+ "page-trillion-dollar-security-section-4-5-list-4": "Ausnutzung von Anreizen in Grenzfällen bei MEV, Trennung von Proposer und Builder oder Liquid-Staking-Design. Akteure können seltene Protokollbedingungen manipulieren, um übermäßige Belohnungen zu erhalten.",
+ "page-trillion-dollar-security-section-4-6-title": "4.6 Quantenrisiko",
+ "page-trillion-dollar-security-section-4-6-paragraph-1": "Die Kernkryptographie von Ethereum (z. B. Signaturen auf elliptischen Kurven wie secp256k1) könnte eines Tages von Quantencomputern gebrochen werden. Obwohl dies kein unmittelbares Risiko ist, könnte eine glaubwürdige Bedrohung bestehende Wallets, Verträge und Staking-Schlüssel sofort anfällig machen. Diese zukünftige Herausforderung schwächt die langfristigen Garantien von Ethereum für die Benutzer.",
+ "page-trillion-dollar-security-section-4-6-paragraph-2": "Migrationspfade zu quantenresistenter Kryptographie (z. B. über Post-Quanten-Signaturschemata) müssen entworfen, getestet und möglicherweise Jahre bevor sie benötigt werden in das Protokoll eingebettet werden. Organisationen im gesamten Ethereum-Ökosystem, einschließlich der Ethereum Foundation, erforschen diese Optionen aktiv und überwachen die Risiken.",
+ "page-trillion-dollar-security-section-5-paragraph-1": "Selbst ein idealisiertes Blockchain-Ökosystem wird Risiken, Angriffe und Schwachstellen aufweisen. Wenn etwas schief geht, müssen effektive Systeme zur Minderung, Erkennung und Reaktion vorhanden sein. Die Herausforderungen hierbei sind:",
+ "page-trillion-dollar-security-section-5-list-title-1": "Das betroffene Team erreichen",
+ "page-trillion-dollar-security-section-5-list-desc-1": "Es kann schwierig sein, mit dem Team in Kontakt zu treten, dessen Anwendung kompromittiert wurde. Dies kann zu stundenlangen Verzögerungen führen und die Fähigkeit der Helfer, Gelder wiederherzustellen, einschränken.",
+ "page-trillion-dollar-security-section-5-list-title-2": "Eskalation von Problemen bei verbundenen Organisationen",
+ "page-trillion-dollar-security-section-5-list-desc-2": "Wenn das Problem eine Plattform betrifft (wie ein soziales Netzwerk oder eine zentralisierte Börse), kann es für Helfer schwierig sein, das Problem zu eskalieren, wenn sie keinen bestehenden Kontakt haben.",
+ "page-trillion-dollar-security-section-5-list-title-3": "Koordinierung der Reaktion",
+ "page-trillion-dollar-security-section-5-list-desc-3": "Es ist oft unklar, wie viele Incident-Response-Teams die betroffene Anwendung unterstützen, was zu Missverständnissen oder verschwendeter Mühe führt, wenn eine gemeinsame Anstrengung effektiver gewesen wäre.",
+ "page-trillion-dollar-security-section-5-list-title-4": "Mangelnde Überwachungsmöglichkeiten",
+ "page-trillion-dollar-security-section-5-list-desc-4": "Es kann schwierig sein, On-Chain- und Off-Chain-Probleme zu überwachen, was eine frühzeitige Warnung ermöglichen und eine schnelle Reaktion auf Bedrohungen sicherstellen würde.",
+ "page-trillion-dollar-security-section-5-list-title-5": "Zugang zu Versicherungen",
+ "page-trillion-dollar-security-section-5-list-desc-5": "Versicherungen sind ein wesentliches Instrument zur Minderung von Verlusten in den meisten traditionellen Systemen, die mit Geld, Finanzsystemen, Identität und anderen wertvollen Informationen zu tun haben. Heute sind jedoch nur wenige Versicherungsoptionen von traditionellen Finanzdienstleistern für das Krypto-Ökosystem verfügbar.",
+ "page-trillion-dollar-security-section-6-intro": "Die \"soziale Ebene\" von Ethereum bezieht sich auf die Gesamtheit der Menschen, Organisationen, Unternehmen, Governance-Prozesse und kulturellen Normen, die das Verhalten des Ethereum-Ökosystems beeinflussen. Diese soziale Ebene ist selbst anfällig für bestimmte Angriffe oder Risiken, die dann die Sicherheit und Zuverlässigkeit von Ethereum beeinflussen können.",
+ "page-trillion-dollar-security-section-6-paragraph-1": "Diese Risiken sind tendenziell eher langfristig orientiert und betreffen Ethereum als Ganzes und nicht die Sicherheit einzelner Benutzer oder Anwendungen.",
+ "page-trillion-dollar-security-section-6-1-title": "6.1 Stake-Zentralisierung",
+ "page-trillion-dollar-security-section-6-1-paragraph-1": "Die Zentralisierung großer Mengen an Stake kann Risiken für Ethereum als Ganzes darstellen, wenn die Entitäten, die diesen Stake kontrollieren, beschließen, zusammenzuarbeiten.",
+ "page-trillion-dollar-security-section-6-1-paragraph-2": "Diese wirtschaftliche Zentralisierung schafft das Potenzial für eine soziale Übernahme der Governance. Wenn eine kleine Gruppe von Validatoren eine Supermehrheit des Stakes kontrolliert, könnten sie:",
+ "page-trillion-dollar-security-section-6-1-list-1": "Forks koordinieren oder sich ihnen widersetzen.",
+ "page-trillion-dollar-security-section-6-1-list-2": "Bestimmte Transaktionen oder Verträge zensieren.",
+ "page-trillion-dollar-security-section-6-1-list-3": "Den Konsens der Community untergraben, indem sie mit einem Austritt oder Widerstand drohen.",
+ "page-trillion-dollar-security-section-6-1-paragraph-3": "Sollte dieses extreme Szenario eintreten, hat die Ethereum-Community vorgeschlagen, dass \"soziales Slashing\" die Antwort sein könnte. Soziales Slashing ist die Nutzung eines Off-Chain-Sozialkonsenses, um zu entscheiden, sich fehlverhaltende Validatoren zu slashen, als Kontrolle ihrer Macht. Aber es gibt keine klaren Normen, Verfahren oder Tools, um solche Maßnahmen zu ergreifen (siehe Abschnitt 4.4).",
+ "page-trillion-dollar-security-section-6-2-title": "6.2 Zentralisierung von Off-Chain-Vermögenswerten",
+ "page-trillion-dollar-security-section-6-2-paragraph-1": "Ethereum beherbergt erhebliche Mengen an realen Vermögenswerten, bei denen die Vermögenswerte außerhalb der Chain in Bankkonten oder anderen Einlagen gehalten werden, die dann auf der Chain über Token gehandelt werden, die einen Anspruch auf die Off-Chain-Vermögenswerte darstellen. Beispielsweise funktionieren viele große Stablecoins auf diese Weise.",
+ "page-trillion-dollar-security-section-6-2-paragraph-2": "Die Institutionen, die die Off-Chain-Einlagen halten, können Einfluss auf das Ethereum-Ökosystem haben. Beispielsweise können große Einleger während eines extremen Szenarios, bei dem es zu einem umstrittenen Fork oder Netzwerk-Upgrade kommt, beeinflussen, welche Kette weithin akzeptiert wird, indem sie sich nur dafür entscheiden, Token auf der einen oder der anderen Kette anzuerkennen.",
+ "page-trillion-dollar-security-section-6-3-title": "6.3 Regulatorischer Angriff oder Druck",
+ "page-trillion-dollar-security-section-6-3-paragraph": "Regierungen und Regulierungsbehörden könnten verschiedene Entitäten, die wichtige Komponenten des Ethereum-Stacks kontrollieren, unter Druck setzen, um das Ethereum-Protokoll zu zensieren oder anderweitig zu stören. Institutionelle Nutzer von Ethereum könnten ebenfalls von diesem Druck betroffen sein, was weitere Konsequenzen für ihre Nutzer hätte (z. B. eine Bank, die aufgrund regulatorischer Verbote bestimmte Kryptoprodukte nicht mehr anbieten kann).",
+ "page-trillion-dollar-security-section-6-4-title": "6.4 Organisatorische Übernahme der Governance",
+ "page-trillion-dollar-security-section-6-4-paragraph-1": "Die Open-Source-Governance- und Entwicklungsprozesse von Ethereum werden von einer vielfältigen und globalen Gruppe von Teams und Unternehmen vorangetrieben, die die Kern-Client-Software, Infrastruktur und Tooling warten.",
+ "page-trillion-dollar-security-section-6-4-paragraph-2": "Verschiedene Formen des Einflusses (Unternehmensübernahmen, Finanzierungsabhängigkeiten, Anstellung von Schlüssel-Mitwirkenden, Interessenkonflikte innerhalb bestehender Organisationen) könnten die Kultur und die Prioritäten der Ethereum-Governance allmählich verschieben. Dies kann zu einer Ausrichtung auf spezifische kommerzielle oder externe Interessen führen, die vom Community-getriebenen Ethos und der etablierten Roadmap abweichen, was die Neutralität und Widerstandsfähigkeit von Ethereum im Laufe der Zeit potenziell schwächen könnte.",
+ "page-trillion-dollar-security-image-alt-hero": "Eine futuristische Visualisierung, die miteinander verbundene Blockchain-Nodes und Sicherheitselemente zeigt und die Billionen-Dollar-Sicherheit im Bereich der digitalen Vermögenswerte darstellt",
+ "page-trillion-dollar-security-image-alt-report": "Titelbild des Berichts „Trillion Dollar Security“, das eine moderne Visualisierung der digitalen Sicherheit mit Blockchain-Elementen und Netzwerkverbindungen zeigt"
+}
diff --git a/src/intl/de/page-upgrades-get-involved.json b/src/intl/de/page-upgrades-get-involved.json
index b3b114b02a6..d042f953e85 100644
--- a/src/intl/de/page-upgrades-get-involved.json
+++ b/src/intl/de/page-upgrades-get-involved.json
@@ -28,12 +28,12 @@
"page-upgrades-get-involved-run-clients-execution-desc": "Diese Clients wurden früher als „Eth1“-Clients bezeichnet, aber dieser Begriff wird zugunsten von „Clients der Ausführungsebene“ nicht mehr verwendet.",
"page-upgrades-get-involved-run-clients-consensus": "Clients der Konsensebene",
"page-upgrades-get-involved-run-clients-consensus-desc": "Diese Clients wurden früher als „Eth2“-Clients bezeichnet, aber dieser Begriff wird zugunsten von „Clients der Konsensebene“ nicht mehr verwendet.",
- "page-upgrades-get-involved-stake": "Eigene ETH staken",
+ "page-upgrades-get-involved-stake": "Ihr ETH staken",
"page-upgrades-get-involved-stake-desc": "Mit dem Staking Ihrer ETH können Sie dabei helfen, die Beacon Chain zu sichern.",
- "page-upgrades-get-involved-stake-eth": "Stake ETH",
+ "page-upgrades-get-involved-stake-eth": "ETH staken",
"page-upgrades-get-involved-subtitle": "Hier finden Sie alle Möglichkeiten, wie Sie bei Ethereum und zukünftigen Upgrade-Bemühungen unterstützen können.",
"page-upgrades-get-involved-title-1": "Einen Client ausführen",
- "page-upgrades-get-involved-title-2": "Eigene ETH staken",
+ "page-upgrades-get-involved-title-2": "Ihr ETH staken",
"page-upgrades-get-involved-title-3": "Fehler finden",
"page-upgrades-get-involved-written-c-sharp": "Geschrieben in C#",
"page-upgrades-get-involved-written-go": "Geschrieben in Go",
diff --git a/src/intl/de/page-upgrades-index.json b/src/intl/de/page-upgrades-index.json
index 46a2eb897f9..5258381b621 100644
--- a/src/intl/de/page-upgrades-index.json
+++ b/src/intl/de/page-upgrades-index.json
@@ -47,7 +47,7 @@
"page-upgrades-dive-desc": "Wie gestalten wir Ethereum skalierbarer, sicherer und nachhaltiger? Unter Beibehaltung der Kernphilosophie von Ethereum: der Dezentralisierung.",
"page-upgrades-docking": "Die Zusammenführung",
"page-upgrades-merge-answer-1": "Die Zusammenführung fand statt, als Ethereum am 15. September 2022 zum Proof-of-Stake-Konsens überging. Die Beacon Chain wurde mit dem Mainnet zusammengeführt, was den Proof-of-Work-Ansatz offiziell ablöste und den Energieverbrauch von Ethereum um ca. 99,95 % senkte.",
- "page-upgrades-merge-btn": "Mehr zum Zusammenschluss",
+ "page-upgrades-merge-btn": "Mehr zur Zusammenführung",
"page-upgrades-merge-desc": "Mainnet-Ethereum wurde mit der Proof-of-Stake-Beacon Chain zusammengeführt, wodurch dem energieintensiven Mining ein Ende bereitet wurde.",
"page-upgrades-merge-estimate": "Die Zusammenführung ist live",
"page-upgrades-merge-mainnet": "Was ist das Mainnet?",
@@ -97,7 +97,7 @@
"page-upgrades-question-6-answer-5": "Sie können sich auch der Diskussion über die Ethereum-Forschung und -Entwicklung auf ethresear.ch anschließen.",
"page-upgrades-question-6-title": "Was muss ich mit meiner dApp tun?",
"page-upgrades-question-6-desc": "Die Zusammenführung wurde so konzipiert, dass sie nur minimale Auswirkungen auf die Entwickler hat – wobei es einige kleine Änderungen gab, die beachtet werden sollten.",
- "page-upgrades-question-6-answer-1": "dApp-Entwickler, die mit Ethereum vor der Zusammenführung vertraut waren, sollten einige Änderungen kennen. Diese Änderungen umfassen Blockstruktur und Timing, einige Opcode-Änderungen, Quellen von On-Chain-Zufälligkeit und das Konzept der Epochenfinalisierung.",
+ "page-upgrades-question-6-answer-1": "Dapp-Entwickler, die mit Ethereum vor dem Merge vertraut sind, sollten einige Änderungen beachten. Dazu gehören die Blockstruktur und -zeit, einige Opcode-Änderungen, Quellen für On-Chain-Zufälligkeit und das Konzept der Epoch-Finalisierung.",
"page-upgrades-question-6-answer-1-link": "Wie die Zusammenführung die Anwendungsebene von Ethereum beeinflusste",
"page-upgrades-question-6-answer-2": "Anwendungen waren nahezu nicht betroffen.",
"page-upgrades-question-7-desc": "Viele verschiedene Teams aus der ganzen Community arbeiten an den verschiedenen Ethereum-Upgrades.",
@@ -126,7 +126,7 @@
"page-upgrades-question-9-answer-3": "Wenn Sie technisch versiert sind, können Sie dabei helfen, Fehler in den neuen Clients zu finden.",
"page-upgrades-question-9-answer-4": "Ebenso können Sie sich auf ethresear.ch an technischen Diskussionen mit Ethereum-Forschern beteiligen.",
"page-upgrades-question-9-desc": "Sie müssen kein Techniker sein, um etwas beizutragen. Die Community sucht nach Beiträgen aus allen möglichen Bereichen.",
- "page-upgrades-question-9-stake-eth": "Stake ETH",
+ "page-upgrades-question-9-stake-eth": "ETH staken",
"page-upgrades-question-9-title": "Wie kann ich zu den Ethereum-Upgrades beitragen?",
"page-upgrades-question-9-more": "Allgemeinere Möglichkeiten finden, um sich an Ethereum zu beteiligen",
"page-upgrades-question-10-title": "Was sind die „Eth2-Phasen“?",
@@ -179,10 +179,10 @@
"page-upgrades-what-happened-to-eth2-1-more": "Mehr über die Zusammenführung.",
"page-upgrades-what-happened-to-eth2-2": "Seit der Zusammenführung von „Eth1“ und „Eth2“ gibt es nicht mehr zwei verschiedene Ethereum-Blockchains, sondern nur noch Ethereum.",
"page-upgrades-what-happened-to-eth2-3": "Um Unklarheiten zu minimieren, hat die Community diese Begriffe aktualisiert:",
- "page-upgrades-what-happened-to-eth2-3-1": "„Eth1“ ist nun die „Ausführungsebene“, die Transaktionen und Ausführungen verarbeitet.",
- "page-upgrades-what-happened-to-eth2-3-2": "„Eth2“ ist nun die „Konsensebene“, die den Proof-of-Stake-Konsens regelt.",
- "page-upgrades-what-happened-to-eth2-4": "Diese aktualisierte Terminologie ändert lediglich die Benennungskonventionen. Die Ziele und der Fahrplan von Ethereum ändern sich dadurch nicht.",
- "page-upgrades-what-happened-to-eth2-5": "Mehr über die „Eth2“-Umbenennung erfahren",
+ "page-upgrades-what-happened-to-eth2-3-1": "„Eth1“ ist nun der „Ausführungslayer“, der Transaktionen verarbeitet und ausführt.",
+ "page-upgrades-what-happened-to-eth2-3-2": "„Eth2“ ist nun der „Konsenslayer“, der den Proof-of-Stake-Konsens regelt.",
+ "page-upgrades-what-happened-to-eth2-4": "Diese aktualisierte Terminologie ändert lediglich die Benennungskonventionen. Die Ziele von Ethereum oder die Roadmap ändern sich dadurch nicht.",
+ "page-upgrades-what-happened-to-eth2-5": "Mehr erfahren über die „Eth2“-Umbenennung",
"page-upgrades-why-cant-we-just-use-eth2-title": "Warum können wir nicht einfach Eth2 verwenden?",
"page-upgrades-why-cant-we-just-use-eth2-mental-models-title": "Gedankliche Modelle",
"page-upgrades-why-cant-we-just-use-eth2-mental-models-description": "Ein großes Problem mit der Eth2-Benennung besteht darin, dass neue Benutzer von Ethereum sich ein falsches Bild machen. Sie denken intuitiv, dass Eth1 vor Eth2 kommt oder dass Eth1 von Eth2 abgelöst wird. Weder das eine noch das andere ist wahr. Wenn wir den Begriff Eth2 nicht mehr verwenden, wecken wir in zukünftigen Benutzern keine falschen Vorstellungen.",
diff --git a/src/intl/de/page-wallets-find-wallet.json b/src/intl/de/page-wallets-find-wallet.json
index b62596c1017..e0e12ca0dfb 100644
--- a/src/intl/de/page-wallets-find-wallet.json
+++ b/src/intl/de/page-wallets-find-wallet.json
@@ -84,5 +84,8 @@
"page-find-wallet-social-links": "Links",
"page-find-wallet-empty-results-title": "Keine Ergebnisse",
"page-find-wallet-empty-results-desc": "Es gibt keine Wallets, die Ihren Kriterien entsprechen. Versuchen Sie, einige Filter zu entfernen.",
- "page-find-wallet-see-wallets": "Wallets anschauen"
+ "page-find-wallet-privacy": "Privatsphäre",
+ "page-find-wallet-privacy-desc": "Wallets, die integrierte private Transaktionen unterstützen",
+ "page-find-wallet-see-wallets": "Wallets anschauen",
+ "page-find-wallet-search-languages": "Sprachen suchen..."
}
diff --git a/src/intl/de/page-wallets.json b/src/intl/de/page-wallets.json
index bc4544c5071..61eb002c00a 100644
--- a/src/intl/de/page-wallets.json
+++ b/src/intl/de/page-wallets.json
@@ -61,6 +61,6 @@
"page-wallets-your-ethereum-account-desc": "Ihre Wallet ist Ihr Fenster in Ihr Ethereum-Konto – Ihr Guthaben, Transaktionsverlauf und vieles mehr. Sie können jedoch jederzeit Wallet-Anbieter austauschen.",
"page-wallets-your-login": "Ihr Login für Ethereum-Anwendungen",
"page-wallets-your-login-desc": "Mit Ihrer Wallet können Sie sich über Ihr Ethereum-Konto mit Anwendungen verbinden. Es ist wie ein Login, das Sie in unterschiedlichen Anwendungen verwenden können.",
- "additional-reading-how-to-create-an-ethereum-account": "So erstellen Sie ein Ethereum-Konto",
- "additional-reading-how-to-use-a-wallet": "So verwenden Sie eine Wallet"
+ "additional-reading-how-to-create-an-ethereum-account": "So erstellst du ein Ethereum-Konto",
+ "additional-reading-how-to-use-a-wallet": "So verwendest du eine Wallet"
}
diff --git a/src/intl/de/page-what-is-ether.json b/src/intl/de/page-what-is-ether.json
new file mode 100644
index 00000000000..a5b1766d699
--- /dev/null
+++ b/src/intl/de/page-what-is-ether.json
@@ -0,0 +1,100 @@
+{
+ "page-what-is-ether-meta-title": "Was ist Ether (ETH)? (Ein vollständiger Leitfaden) | ethereum.org",
+ "page-what-is-ether-meta-description": "Ether (ETH) ist die native Kryptowährung von Ethereum. Erfahren Sie, wofür es verwendet wird, wie und wo Sie es kaufen können, wie viel davon vorhanden ist und was seinen Preis beeinflusst.",
+ "page-what-is-ether-twitter-meta-description": "Ether (ETH) ist die native Kryptowährung von Ethereum. Erfahren Sie, wofür es verwendet wird, wie und wo Sie es kaufen können, wie viel davon vorhanden ist und mehr.",
+ "page-what-is-ether-title": "Was ist Ether (ETH)?",
+ "page-what-is-ether-hero-description-1": "Ether (ETH) ist die native Kryptowährung, die das Ethereum-Netzwerk antreibt. Es wird verwendet, um Transaktionsgebühren (bekannt als 'Gas') für die Nutzung des Netzwerks und der darauf aufbauenden Anwendungen zu bezahlen, um das Netzwerk durch Staking zu sichern und dient als digitales Geld für Zahlungen und Investitionen - ohne von einer zentralen Instanz, Organisation oder Regierung kontrolliert zu werden. ETH ist eine der größten Kryptowährungen nach Marktkapitalisierung.",
+ "page-what-is-ether-what-is-ether-description-1": "Ether, allgemein bekannt als ETH, ist der Treibstoff, der die Ethereum-Blockchain antreibt. Im Gegensatz zu Bitcoin, das hauptsächlich als digitales Geld dient, hat Ether vielfältige Verwendungsmöglichkeiten innerhalb des Ethereum-Ökosystems.",
+ "page-what-is-ether-what-is-ether-description-2": "Als native Kryptowährung von Ethereum wird ETH für Folgendes verwendet:",
+ "page-what-is-ether-what-is-ether-description-3": "Zahlung von Transaktionsgebühren (Gas) für die Nutzung des Netzwerks und seiner Anwendungen",
+ "page-what-is-ether-what-is-ether-description-4": "Sicherung des Ethereum-Netzwerks durch Staking",
+ "page-what-is-ether-what-is-ether-description-5": "ETH wurde 2015 als Teil des Starts von Ethereum eingeführt und hat sich seitdem zu einem der wertvollsten Vermögenswerte der Welt entwickelt.",
+ "page-what-is-ether-what-is-ether-description-6": "Für Verbraucher",
+ "page-what-is-ether-what-is-ether-description-7": "ETH ermöglicht globale Zahlungen ohne Banken, den Kauf von nicht-fungiblen Token (NFTs) und den Zugang zu dezentralen Finanzanwendungen (DeFi). Es ist zensurresistent und bietet eine grenzüberschreitende Funktionalität rund um die Uhr.",
+ "page-what-is-ether-what-is-ether-description-8": "Für Entwickler",
+ "page-what-is-ether-what-is-ether-description-9": "Mit ETH werden Transaktionsgebühren bezahlt, wenn Smart Contracts auf dem Ethereum-Mainnet bereitgestellt werden. Es ist auch die primäre Währung, die in vielen Anwendungen im Ethereum-Ökosystem verwendet wird.",
+ "page-what-is-ether-what-is-ether-description-10": "Für Investoren",
+ "page-what-is-ether-what-is-ether-description-11": "ETH fungiert als Wertspeicher und renditegenerierender Vermögenswert durch Staking. Es bietet Zugang zum Wachstum von Web3 und der expandierenden digitalen Wirtschaft.",
+ "page-what-is-ether-what-is-ether-description-12": "Erfahren Sie mehr über ETH-Staking",
+ "page-what-is-ether-how-to-buy-eth": "Wie man ETH kauft",
+ "page-what-is-ether-how-to-buy-eth-description-1": "Der Kauf von ETH ist unkompliziert und bietet je nach Ihren Bedürfnissen und Ihrem Standort mehrere Optionen. Beginnen Sie immer mit einer vertrauenswürdigen Plattform, die starke Sicherheit bietet.",
+ "page-what-is-ether-how-to-buy-eth-description-2": "Verbraucher können ETH über Kryptowährungsbörsen oder Wallet-Apps kaufen.",
+ "page-what-is-ether-how-to-buy-eth-description-3": "Nebenbemerkung",
+ "page-what-is-ether-how-to-buy-eth-description-4": "Wenn Sie ETH kaufen, werden Sie von \"Konto/Adresse\" und \"Wallet\" hören.",
+ "page-what-is-ether-how-to-buy-eth-description-5": "Stellen Sie sich Ihr Konto wie Ihre E-Mail-Adresse vor, an die Ihnen Leute Geld senden.",
+ "page-what-is-ether-how-to-buy-eth-description-6": "Stellen Sie sich Ihre Wallet wie Ihre E-Mail-App vor, mit der Sie Guthaben überprüfen und Zahlungen tätigen.",
+ "page-what-is-ether-how-to-buy-eth-description-7": "Sie können ETH kaufen mit:",
+ "page-what-is-ether-how-to-buy-eth-description-8": "Kredit-/Debitkarten, sofort, aber mit höheren Gebühren",
+ "page-what-is-ether-how-to-buy-eth-description-9": "Banküberweisungen, langsamer, aber mit niedrigeren Gebühren",
+ "page-what-is-ether-how-to-buy-eth-description-10": "PayPal oder ähnliche Dienste, wo verfügbar",
+ "page-what-is-ether-how-to-buy-eth-description-11": "Für Unternehmen bieten Börsen Firmenkonten mit höheren Limits, besserem Support, Compliance-Funktionen, Mengenrabatten und erhöhter Sicherheit.",
+ "page-what-is-ether-how-to-buy-eth-description-12": "Andere Wege, um ETH zu erhalten:",
+ "page-what-is-ether-how-to-buy-eth-description-13": "Zahlungen erhalten von Leuten, die Sie kennen",
+ "page-what-is-ether-how-to-buy-eth-description-14": "Liquidität bereitstellen auf dezentralen Finanzprotokollen",
+ "page-what-is-ether-how-to-buy-eth-description-15": "ETH staken, um Belohnungen zu verdienen und gleichzeitig das Ethereum-Netzwerk zu sichern",
+ "page-what-is-ether-how-to-buy-eth-description-16": "Erfahren Sie mehr darüber, wie und wo Sie ETH kaufen können",
+ "page-what-is-ether-how-to-send-and-receive-eth": "Wie man ETH sendet und empfängt",
+ "page-what-is-ether-how-to-send-and-receive-eth-description-1": "Das Senden von ETH erfordert eine Wallet und eine Empfängeradresse. Geben Sie deren Adresse ein, legen Sie den Betrag fest, überprüfen Sie die Transaktionsgebühr und bestätigen Sie. Transaktionen kommen in der Regel in weniger als 30 Sekunden an und können nach der Bestätigung nicht mehr rückgängig gemacht werden.",
+ "page-what-is-ether-how-to-send-and-receive-eth-description-2": "Der Empfang von ETH erfordert, dass Sie Ihre Ethereum-Adresse oder Ihren QR-Code mit dem Absender teilen. Das Geld erscheint nach der Netzwerkbestätigung in Ihrer Wallet, wobei die meisten Wallets Benachrichtigungen bereitstellen.",
+ "page-what-is-ether-how-to-send-and-receive-eth-description-3": "Benötigen Sie Hilfe? Lesen Sie den Leitfaden Wie man eine Wallet benutzt .",
+ "page-what-is-ether-how-to-send-and-receive-eth-description-4": "Wenn Sie ETH kaufen, werden Sie von \"Konto/Adresse\" und \"Wallet\" hören.",
+ "page-what-is-ether-how-to-send-and-receive-eth-description-5": "Stellen Sie sich Ihr Konto wie Ihre E-Mail-Adresse vor, an die Ihnen Leute Geld senden.",
+ "page-what-is-ether-how-to-send-and-receive-eth-description-6": "Stellen Sie sich Ihre Wallet wie Ihre E-Mail-App vor, mit der Sie Guthaben überprüfen und Zahlungen tätigen.",
+ "page-what-is-ether-how-to-send-and-receive-eth-description-7": "Für größere Beträge sollten Sie Hardware-Wallets für zusätzliche Sicherheit in Betracht ziehen.",
+ "page-what-is-ether-how-to-send-and-receive-eth-description-8": "Erfahren Sie mehr über Ethereum und wie es funktioniert.",
+ "page-what-is-ether-how-to-send-and-receive-eth-callout": "Teilen Sie Ihre Ethereum-Adresse nur mit vertrauenswürdigen Kontakten. Da Ethereum ein öffentliches Hauptbuch ist, können diese Ihr Guthaben und Ihre Transaktionen einsehen. Sie können nicht auf Ihr Geld zugreifen, aber Datenschutz wird empfohlen.",
+ "page-what-is-ether-how-long-does-it-take-to-send-eth": "Wie lange dauert es, ETH zu senden?",
+ "page-what-is-ether-how-long-does-it-take-to-send-eth-description-1": "ETH-Transaktionen sind in der Regel in weniger als 30 Sekunden abgeschlossen. Das Ethereum-Netzwerk verarbeitet alle 12 Sekunden Blöcke, obwohl sich Transaktionen bei Überlastung in einer Warteschlange befinden können.",
+ "page-what-is-ether-how-long-does-it-take-to-send-eth-description-2": "Transaktionen erreichen nach ca. 15 Minuten 'Finalität', im Vergleich zu Bitcoins Durchschnitt von 60 Minuten.",
+ "page-what-is-ether-how-long-does-it-take-to-send-eth-description-3": "Bei hohem Netzwerkverkehr können Sie Transaktionen beschleunigen, indem Sie höhere Transaktionsgebühren zahlen, was Sie in der Warteschlange nach vorne bringt. Die Gebühren werden zwischen Validatoren und einem Burning-Mechanismus aufgeteilt.",
+ "page-what-is-ether-how-much-does-it-cost-to-send-eth": "Wie viel kostet es, ETH zu senden?",
+ "page-what-is-ether-how-much-does-it-cost-to-send-eth-description-1": "Ethereum-Transaktionen erfordern Transaktions-gebühren, die in ETH bezahlt werden. Die Gebühr wird auf der Grundlage der erforderlichen Rechenarbeit (gemessen in 'Gas') und der aktuellen Nachfrage im Netzwerk berechnet. Der Gaspreis schwankt mit dem Netzwerkverkehr, was Transaktionen in Zeiten geringer Auslastung kostengünstiger macht.",
+ "page-what-is-ether-l2s": "L2s: Die Skalierung von Ethereum",
+ "page-what-is-ether-l2s-description-1": "Mit wachsender Popularität von Ethereum wird es zu einer Herausforderung, die Transaktionsgebühren niedrig zu halten. Layer 2 (L2)-Netzwerke gehen dieses Problem an.",
+ "page-what-is-ether-l2s-description-2": "L2s wie Optimism und Arbitrum bieten 10- bis 100-mal günstigere Gebühren und übernehmen gleichzeitig die Sicherheit von Ethereum. Sie verarbeiten Transaktionen offchain und veröffentlichen die Daten auf Ethereum.",
+ "page-what-is-ether-l2s-description-3": "Stellen Sie sie sich als Expressspuren vor, die schnellere und billigere Transaktionen neben der Hauptverkehrsader von Ethereum ermöglichen.",
+ "page-what-is-ether-l2s-description-4": "L2-Überweisungen kosten in der Regel weniger als 0,01 $ und bringen Ethereum durch Integrationen mit Unternehmen wie Robinhood, PayPal und Shopify zu Millionen weiterer Nutzer.",
+ "page-what-is-ether-what-is-the-eth-supply": "Wie hoch ist der ETH-Vorrat?",
+ "page-what-is-ether-what-is-the-eth-supply-description-1": "Im Gegensatz zu Bitcoins fester Obergrenze von 21 Millionen hat ETH eine dynamische Versorgungsmechanik:",
+ "page-what-is-ether-what-is-the-eth-supply-description-2": "Neue ETH werden emittiert, um Netzwerk-Validatoren mit einer begrenzten, vom Protokoll berechneten Rate zu belohnen",
+ "page-what-is-ether-what-is-the-eth-supply-description-3": "Ein Teil jeder Transaktionsgebühr wird dauerhaft \"gebrannt\" (aus dem Bestand gelöscht)",
+ "page-what-is-ether-what-is-the-eth-supply-description-4": "Dies führt zu abwechselnden Perioden von Inflation und Deflation, basierend auf der Netzwerknutzung",
+ "page-what-is-ether-what-is-the-eth-supply-description-5": "Erwartetes Gleichgewicht: Das System gleicht die Netzwerksicherheit mit langfristiger Werterhaltung aus. Hohe Nutzung führt zu Deflation; geringe Nutzung führt zu Inflation.",
+ "page-what-is-ether-what-is-the-eth-supply-description-6": "Datenquellen: Etherscan , Ultrasound Money ",
+ "page-what-is-ether-what-is-the-distribution-of-eth": "Wie ist die Verteilung von ETH?",
+ "page-what-is-ether-what-is-the-distribution-of-eth-description-1": "Das Eigentum ist weit über zig Millionen von Adressen verteilt, was eine Konzentration der Kontrolle verhindert und die Dezentralisierung verbessert.",
+ "page-what-is-ether-breakdown": "Eine Aufschlüsselung der Ether-Verteilung",
+ "page-what-is-ether-breakdown-description-1": "Gestakte Ether: Zig-Millionen von ETH, die für die Netzwerksicherheit gesperrt sind",
+ "page-what-is-ether-breakdown-description-2": "Börsen: Zentralisierte Plattformen halten 13-16 % des Vorrats",
+ "page-what-is-ether-breakdown-description-3": "Smart Contracts: Erhebliche Beträge in Smart Contracts, einschließlich DeFi-Protokollen",
+ "page-what-is-ether-breakdown-description-4": "Ethereum Foundation: Hält weniger als 0,3 % des Vorrats (von 9 % im Jahr 2014)",
+ "page-what-is-ether-who-holds-most": "Wer hält am meisten?",
+ "page-what-is-ether-who-holds-most-description-1": "Die Ethereum-Adressen mit den höchsten ETH-Guthaben gehören in der Regel nicht Einzelpersonen. Die große Mehrheit der Ether, die in den \"Top\"-Ethereum-Adressen sichtbar sind, repräsentiert die kollektiven, gebündelten Mittel vieler verschiedener Personen und Entitäten, nicht die Bestände einer einzelnen Person.",
+ "page-what-is-ether-who-holds-most-description-2": "Die ETH-Konten mit den höchsten Guthaben umfassen in der Regel:",
+ "page-what-is-ether-who-holds-most-description-3": "Der Beacon Chain Einzahlungsvertrag: Das Guthaben des Einzahlungsvertrags repräsentiert alle ETH, die gestakt wurden, um das Ethereum-Netzwerk zu sichern. Obwohl dies die Ethereum-Adresse mit dem größten ETH-Guthaben ist, stellt sie kein zugängliches Ethereum-Wallet-Konto dar. Es ist ein Smart Contract, der Einzahlungen von ETH als ersten Schritt zur Teilnahme am Staking annimmt und dann die Guthaben dieser Ether über die aktiven Validatoren des Netzwerks verwaltet.",
+ "page-what-is-ether-who-holds-most-description-4": "Smart Contracts: Viele der anderen Ethereum-Adressen mit hohem Guthaben repräsentieren die Smart Contracts, die Ethereum-basierte Anwendungen antreiben, wie z. B. die Smart-Contract-Adressen für dezentrale Finanzprotokolle (DeFi), kettenübergreifende Brücken oder dezentrale autonome Organisationen (DAOs). Diese Vertragsguthaben repräsentieren die Ether, die viele Wallets eingezahlt haben, um an ihrer Anwendung teilzunehmen.",
+ "page-what-is-ether-who-holds-most-description-5": "Sammelkonten: Dies sind große Wallets, die von Börsen, Plattformen und Fonds (wie Coinbase, Robinhood oder Binance) betrieben werden. Wenn ein Nutzer ETH an einer Börse kauft, wird es oft auf einem dieser riesigen Konten zusammen mit den ETH von Tausenden anderer Kunden der Plattform gehalten.",
+ "page-what-is-ether-who-holds-most-description-6": "Eine Live-Liste der Ethereum-Wallet-Adressen mit den höchsten ETH-Guthaben können Sie hier auf Etherscan einsehen.",
+ "page-what-is-ether-distribution": "Warum Verteilung für die Dezentralisierung wichtig ist",
+ "page-what-is-ether-distribution-description-1": "Eine breite Verteilung verhindert eine zentralisierte Kontrolle. Echte Dezentralisierung hängt von der Anzahl unabhängiger Nodes und Validatoren ab, die das Netzwerk aufrechterhalten.",
+ "page-what-is-ether-what-makes-eth-valuable": "Was macht ETH wertvoll?",
+ "page-what-is-ether-what-makes-eth-valuable-description-1": "ETH bezieht seinen Wert aus mehreren Quellen:",
+ "page-what-is-ether-what-makes-eth-valuable-description-2": "Netzwerknutzen: Alle Ethereum-Transaktionen erfordern ETH für Gasgebühren, was eine beständige Nachfrage erzeugt, die mit der Akzeptanz des Netzwerks wächst.",
+ "page-what-is-ether-what-makes-eth-valuable-description-3": "Staking-Belohnungen: ETH-Staker verdienen Renditen, während sie das Netzwerk sichern, was sowohl für private als auch für institutionelle Anleger attraktiv ist.",
+ "page-what-is-ether-what-makes-eth-valuable-description-4": "Wertspeicher: Viele sehen ETH als \"digitales Öl\" – ein knappes Gut mit echtem Nutzen, das die digitale Wirtschaft antreibt.",
+ "page-what-is-ether-what-makes-eth-valuable-description-5": "Angebotsdynamik: Das Verbrennen von Gebühren erzeugt in Zeiten hoher Auslastung deflationären Druck. Seit 2021 wurden Millionen von ETH dauerhaft aus dem Umlauf entfernt .",
+ "page-what-is-ether-what-is-wrapping-eth": "Was ist das Wrapping von ETH?",
+ "page-what-is-ether-what-is-wrapping-eth-description-1": "Wrapped ETH (WETH) ist ein ERC-20-Token, der ETH im Verhältnis 1:1 repräsentiert. Viele dezentrale Apps und L2-Netzwerke sind für die Verarbeitung von ERC-20-Token ausgelegt, aber nativer ETH selbst ist kein ERC-20-Token. ‚Wrapping‘ bedeutet, ETH in einem Smart Contract zu sperren und eine ERC-20-Repräsentation dieses gesperrten ETH (WETH) auszugeben, sodass es in allen Apps und L2s verwendet werden kann, die nur ERC-20-Token akzeptieren.",
+ "page-what-is-ether-what-is-wrapping-eth-description-2": "Häufige Verwendungszwecke sind:",
+ "page-what-is-ether-what-is-wrapping-eth-description-3": "Handelspaare auf dezentralen Börsen wie Uniswap ",
+ "page-what-is-ether-what-is-wrapping-eth-description-4": "Sicherheiten auf Kreditplattformen wie Aave ",
+ "page-what-is-ether-what-is-wrapping-eth-description-5": "Bieten auf NFT-Marktplätzen wie OpenSea ",
+ "page-what-is-ether-what-is-wrapping-eth-description-6": "WETH kann jederzeit gegen minimale Gebühren wieder in ETH zurückgewandelt werden. Der WETH wird zerstört und der repräsentierte ETH wird aus dem Smart Contract freigegeben. Die meisten Anwendungen handhaben den Wrapping- und Unwrapping-Prozess nahtlos.",
+ "page-what-is-ether-what-is-wrapping-eth-description-7": "Erfahren Sie mehr über Wrapped ETH (WETH)",
+ "page-what-is-ether-gas-table-transaction-type": "Transaktionstyp",
+ "page-what-is-ether-gas-table-typical-cost-range": "Live-Kostenbereich",
+ "page-what-is-ether-gas-table-estimated-gas-units": "Geschätzte Gas-Einheiten",
+ "page-what-is-ether-gas-table-row-1-1": "ETH-Überweisungen",
+ "page-what-is-ether-gas-table-row-2-1": "Tausch von Token",
+ "page-what-is-ether-gas-table-row-3-1": "Komplexe DeFi/NFT-Transaktionen"
+}
\ No newline at end of file
diff --git a/src/intl/de/page-what-is-ethereum.json b/src/intl/de/page-what-is-ethereum.json
index 7ce6c1d99c4..6315c0632f8 100644
--- a/src/intl/de/page-what-is-ethereum.json
+++ b/src/intl/de/page-what-is-ethereum.json
@@ -1,128 +1,187 @@
{
- "page-what-is-ethereum-alt-img-bazaar": "Abbildung einer Person, die in einen Basar hineinblickt, welcher Ethereum repräsentiert",
- "page-what-is-ethereum-alt-img-comm": "Eine Illustration von Mitgliedern der Ethereum-Community, die zusammenarbeiten",
- "page-what-is-ethereum-alt-img-lego": "Eine Illustration einer Hand, die ein Ethereum-Logo aus Lego-Steinen aufbaut",
- "page-what-is-ethereum-banking-card": "Banking für alle",
- "page-what-is-ethereum-banking-card-desc": "Nicht jeder hat Zugriff auf Finanzierungsdienstleistungen. Alles, was Sie brauchen, um auf Ethereum und die darauf basierenden Kreditvergabe-, Kreditaufnahme- und Spareinlagenprodukte zugreifen zu können, ist eine Internetverbindung.",
- "page-what-is-ethereum-build": "Erschaffen Sie etwas mit Ethereum",
- "page-what-is-ethereum-build-desc": "Wenn Sie mit Ethereum etwas erschaffen möchten, lesen unsere Dokumentationen, probieren Sie ein paar Tutorials aus oder schauen Sie sich die Werkzeuge an, die Sie brauchen, um loszulegen.",
- "page-what-is-ethereum-censorless-card": "Zensurresistent",
- "page-what-is-ethereum-censorless-card-desc": "Keine Regierung und kein Unternehmen kann Ethereum kontrollieren. Durch die Dezentralisierung ist es nahezu unmöglich, den Erhalt von Zahlungen oder die Nutzung von Diensten auf Ethereum zu verhindern.",
- "page-what-is-ethereum-comm-desc": "Unsere Community umfasst Menschen jeden Hintergrunds, darunter Künstler, Krypto-Anarchisten, Unternehmen der Fortune 500, und jetzt auch Sie. Finden Sie heraus, wie Sie sich heute beteiligen können.",
- "page-what-is-ethereum-commerce-card": "Handelsgarantien",
- "page-what-is-ethereum-commerce-card-desc": "Kunden haben die Garantie, dass Geldmittel nur dann den Besitzer wechseln, wenn Sie das liefern, was vereinbart wurde. Ebenso können Entwickler sicher sein, dass sich die Regeln für sie nicht ändern.",
- "page-what-is-ethereum-composable-card": "Zusammensetzbare Produkte",
- "page-what-is-ethereum-composable-card-desc": "Alle Anwendungen basieren auf derselben Blockchain mit einem geteilten globalen Status, was bedeutet, dass sie aufeinander aufbauen können (wie Lego-Steine). Dies ermöglicht bessere Produkte und Erfahrungen und gewährleistet, dass niemand Werkzeuge entfernen kann, auf die die Anwendungen angewiesen sind.",
- "page-what-is-ethereum-community": "Die Ethereum-Gemeinschaft",
- "page-what-is-ethereum-desc": "Das Fundament für unsere digitale Zukunft",
- "page-what-is-ethereum-explore": "Ethereum entdecken",
- "page-what-is-ethereum-internet-card": "Ein offenes Internet",
- "page-what-is-ethereum-internet-card-desc": "Jeder kann mit dem Ethereum-Netzwerk interagieren oder Anwendungen darauf aufbauen. Das ermöglicht die direkte Kontrolle über die eigenen Vermögenswerte und die eigene Identität, anstatt sie von Mega-Konzernen kontrollieren zu lassen.",
- "page-what-is-ethereum-meet-comm": "Lernen Sie unsere Gemeinschaft kennen",
- "page-what-is-ethereum-meta-description": "Erfahren Sie mehr über Ethereum, was es macht und wie Sie es selbst ausprobieren können.",
- "page-what-is-ethereum-meta-title": "Was ist Ethereum? | ethereum.org",
- "page-what-is-ethereum-p2p-card": "Ein Peer-to-Peer-Netzwerk",
- "page-what-is-ethereum-p2p-card-desc": "Ethereum ermöglicht Ihnen die Koordination, das Treffen von Vereinbarungen oder den direkten Austausch digitaler Vermögenswerte mit anderen Personen. Ganz ohne Zwischenhändler.",
- "page-what-is-ethereum-start-building-btn": "Fangen Sie an zu bauen",
+ "page-what-is-ethereum-meta-title": "Was ist Ethereum? (Ein vollständiger Leitfaden) | ethereum.org",
+ "page-what-is-ethereum-meta-description": "Ein vollständiger Überblick darüber, was Ethereum ist, wie es funktioniert, was es tut und wie man es nutzt oder darauf aufbaut. Einfach erklärt.",
"page-what-is-ethereum-title": "Was ist Ethereum?",
- "page-what-is-ethereum-subtitle": "Ein umfassender Leitfaden für Einsteiger, der erklärt, wie Ethereum funktioniert, welche Vorteile es bringt und wie es von Millionen von Menschen auf der ganzen Welt genutzt wird.",
- "page-what-is-ethereum-button-lets-start": "Los geht's",
- "page-what-is-ethereum-blockchain-tab-title": "Was ist eine Blockchain?",
- "page-what-is-ethereum-blockchain-tab-content": "Eine Blockchain ist eine Datenbank von Transaktionen, die aktualisiert und über viele Computer in einem Netzwerk geteilt wird. Jedes Mal, wenn ein neuer Satz von Transaktionen hinzugefügt wird, wird dies als \"Block\" bezeichnet – daher der Name Blockchain. Öffentliche Blockchains wie Ethereum erlauben es jedem, Daten hinzuzufügen, aber nicht zu entfernen. Wenn jemand versuchen würde, Informationen zu verändern oder das System zu betrügen, müsste er dies auf der Mehrheit der Computer im Netzwerk tun – und das sind viele. Dadurch sind dezentralisierte Blockchains wie Ethereum sehr sicher.",
- "page-what-is-ethereum-cryptocurrency-tab-title": "Was ist eine Kryptowährung?",
- "page-what-is-ethereum-cryptocurrency-tab-content-1": "Kryptowährung ist ein Begriff, der verwendet wird, um viele Arten von fungiblen digitalen Token zu beschreiben, die über eine Blockchain gesichert sind. Alles begann mit Bitcoin. Bitcoin kann verwendet werden, um Werte zwischen zwei Parteien zu übertragen, ohne einem Mittelsmann vertrauen zu müssen. Sie müssen nur dem Bitcoin-Code vertrauen, der vollständig offen und frei verfügbar ist.",
- "page-what-is-ethereum-cryptocurrency-tab-content-2": "Der Grund, warum Vermögenswerte wie Bitcoin und Ether als „Kryptowährungen“ bezeichnet werden, liegt darin, dass die Sicherheit Ihrer Daten und Vermögenswerte durch Kryptografie gewährleistet wird, nicht durch Vertrauen darauf, dass eine Institution oder ein Unternehmen ehrlich handeln.",
- "page-what-is-ethereum-cryptocurrency-tab-content-3": "Ethereum hat seine eigene native Kryptowährung, Ether (ETH), die verwendet wird, um für bestimmte Aktivitäten im Netzwerk zu bezahlen. Es kann an andere Benutzer übertragen oder gegen andere Token auf Ethereum getauscht werden. Ether ist besonders, weil es dazu verwendet wird, die für Aufbau und Betrieb von Anwendungen und Organisationen auf Ethereum erforderliche Rechenleistung zu bezahlen.",
- "page-what-is-ethereum-summary-title": "Zusammenfassung",
- "page-what-is-ethereum-summary-desc-1": "Ethereum ist die Hauptplattform für Tausende von Apps und Blockchains, die alle vom Ethereum-Protokoll betrieben werden.",
- "page-what-is-ethereum-summary-desc-2": "Dieses lebendige Ökosystem treibt Innovationen und eine Vielzahl von dezentralisierten Apps und Diensten voran.",
- "page-what-is-ethereum-summary-bullet-1": "Kostenlose und globale Ethereum-Konten",
- "page-what-is-ethereum-summary-bullet-2": "Pseudo-privat, keine persönlichen Informationen erforderlich",
- "page-what-is-ethereum-summary-bullet-3": "Ohne Einschränkungen kann jeder teilnehmen",
- "page-what-is-ethereum-summary-bullet-4": "Kein Unternehmen besitzt Ethereum oder entscheidet über seine Zukunft",
- "page-what-is-ethereum-btc-eth-diff-title": "Was ist der Unterschied zwischen Ethereum und Bitcoin?",
- "page-what-is-ethereum-btc-eth-diff-1": "Ethereum, 2015 ins Leben gerufen, baut auf der Innovation von Bitcoin auf – mit einigen großen Unterschieden.",
- "page-what-is-ethereum-btc-eth-diff-2": "Mit beiden Geldsystemen können Sie digitales Geld ohne Zahlungsanbieter oder Bank verdienen und ausgeben. Aber Ethereum ist programmierbar. In seinem Netzwerk können Sie auch dezentrale Anwendungen entwickeln und bereitstellen.",
- "page-what-is-ethereum-btc-eth-diff-3": "Bitcoin ermöglicht es uns, untereinander grundlegende Botschaften darüber zu senden, was wir für wertvoll halten. Die Festlegung von Werten ohne Autorität ist bereits sehr stark. Ethereum erweitert dies: Anstatt nur einfache Nachrichten zu senden, können Sie beliebige Programme oder Verträge erstellen. Es gibt keine Grenzen für die Art der Verträge, die erstellt und vereinbart werden können, weshalb im Ethereum-Netzwerk große Innovationen stattfinden.",
- "page-what-is-ethereum-btc-eth-diff-4": "Während Bitcoin nur ein Zahlungsnetzwerk ist, ist Ethereum eher wie ein Marktplatz für Finanzdienstleistungen, Spiele, soziale Netzwerke und andere Anwendungen.",
- "page-what-is-ethereum-what-can-eth-do-title": "Was leistet Ethereum?",
- "page-what-is-ethereum-why-would-i-use-ethereum-title": "Weshalb sollte ich Ethereum verwenden?",
- "page-what-is-ethereum-why-would-i-use-ethereum-1": "Wenn widerstandsfähigere, offenere und vertrauenswürdigere Möglichkeiten zur globalen Koordination, zur Gründung von Organisationen, zur Entwicklung von Anwendungen und zum Teilen von Werten Sie begeistern, ist Ethereum das Richtige für Sie. Die Geschichte von Ethereum wird von uns allen geschrieben. Seien Sie dabei und entdecken Sie, welche unglaublichen Welten wir damit gemeinsam aufbauen können.",
- "page-what-is-ethereum-why-would-i-use-ethereum-2": "Ethereum ist auch von unschätzbarem Wert für Menschen, die aufgrund äußerer Einflüsse außerhalb ihrer Kontrolle Unsicherheiten bezüglich der Sicherheit, Zuverlässigkeit oder Mobilität ihrer Vermögenswerte bewältigen mussten.",
- "page-what-is-ethereum-slide-1-title": "Zahlungen ins Ausland – schneller und günstiger",
- "page-what-is-ethereum-slide-1-desc-1": "Stablecoins sind eine neue Kryptowährung, deren Wert auf stabileren Vermögenswerten basiert. Meist sind Stablecoins an US-Dollar und damit an den Wert dieser Währung gebunden. Sie ermöglichen ein äußerst günstiges und stabiles globales Zahlungssystem. Viele der heutigen Stablecoins entspringen dem Ethereum-Netzwerk.",
- "page-what-is-ethereum-slide-1-desc-2": "Ethereum und Stablecoins vereinfachen den Geldtransfer ins Ausland. Der Transfer rund um den Globus dauert oft nur wenige Minuten – ein Bruchteil der Tage oder gar Wochen, die eine herkömmliche Bank dafür benötigt, und dies zu einem weitaus geringeren Preis. Zudem fallen für umfangreiche Transaktionen keine zusätzlichen Gebühren an und hinsichtlich der Transaktionsziele gibt es keine Einschränkungen.",
- "page-what-is-ethereum-slide-2-title": "Schnelle Hilfe in Krisenzeiten",
- "page-what-is-ethereum-slide-2-desc-1": "Wenn Sie das Glück haben, in Ihrem Land eine reiche Auswahl an Transaktionsoptionen durch vertrauenswürdige Finanzinstitute zu haben, sind für Sie finanzielle Freiheit, Sicherheit und Stabilität vermutlich eine Selbstverständlichkeit. Für viele Menschen auf der Welt, die unter politischer Unterdrückung oder in wirtschaftlicher Not leben, bieten Finanzinstitute möglicherweise jedoch nicht den Schutz oder die Leistungen, die sie benötigen.",
- "page-what-is-ethereum-slide-2-desc-2": "Als die Bewohner von Venezuela, Kuba, Afghanistan, Nigeria, Belarus und der Ukraine mit Krieg, wirtschaftlichen Katastrophen oder hartem Vorgehen gegen Bürgerrechte konfrontiert wurden, waren Kryptowährungen die schnellste und oft einzige Option, um finanzielle Handlungsfreiheit zu bewahren. 1 Wie aus diesen Beispielen hervorgeht, können Kryptowährungen wie Ethereum uneingeschränkten Zugriff zur Weltwirtschaft bieten, wenn Menschen von der Außenwelt abgeschnitten werden. Außerdem bieten Stablecoins einen Wertespeicher, wenn lokale Währungen aufgrund von Hyperinflation zusammenbrechen.",
- "page-what-is-ethereum-slide-3-title": "Stärkung von kreativen Schaffenden",
- "page-what-is-ethereum-slide-3-desc-1": "Allein im Jahr 2021 verdienten Künstler, Musiker, Schriftsteller und andere künstlerisch und kreativ Tätige mit Ethereum insgesamt etwa 3,5 Milliarden Dollar. Dies macht Ethereum neben Spotify, YouTube und Etsy zu einer der größten globalen Plattformen für Schöpfer. Erfahre mehr.",
- "page-what-is-ethereum-slide-4-title": "Spieler stärken",
- "page-what-is-ethereum-slide-4-desc-1": "So genannte „Play to earn Games\", bei denen Spieler tatsächlich für ihr Spiel finanziell entlohnt werden, sind der neueste Trend der Spieleindustrie. Zumeist ist der Handel oder der Tausch von In-Game-Assets mit anderen Spielern gegen echtes Geld verboten. Spieler verlegen sich daher trotz des Sicherheitsrisikos oft auf Schwarzmarkt-Websites. Das dagegen sehr vertrauenswürdige Blockchain-Gaming kommt hier der so eigenen Ökonomie der Gaming-Welt sehr entgegen.",
- "page-what-is-ethereum-slide-4-desc-2": "Darüber hinaus erhalten die Spieler einen Anreiz, indem sie Token im Spiel gegen echtes Geld eintauschen können und so für ihre Spielzeit wirklich belohnt werden.",
- "page-what-is-ethereum-meet-ether-title": "Ether – die Kryptowährung von Ethereum",
- "page-what-is-ethereum-meet-ether-desc-1": "Viele Aktionen im Ethereum-Netzwerk erfordern einige Arbeiten auf dem in Ethereum integrierten Computer („Ethereum Virtual Machine“ genannt). Diese Berechnungen sind nicht kostenlos; sie werden mit der nativen Kryptowährung von Ethereum namens Ether (ETH) bezahlt. Das bedeutet, dass Sie zumindest eine kleine Menge Ether benötigen, um das Netzwerk zu nutzen.",
- "page-what-is-ethereum-meet-ether-desc-2": "Ether ist rein digital und kann sofort an jeden Ort der Welt gesendet werden. Die Gesamtmenge an Ether wird nicht von einer Regierung oder einem Unternehmen kontrolliert – Ether ist dezentralisiert und völlig transparent. Ether wird auf präzise Weise gemäß dem Protokoll ausgestellt und zwar nur an die Staker, die das Netzwerk sichern.",
- "page-what-is-ethereum-what-is-ether": "Was ist Ether?",
- "page-what-is-ethereum-get-eth": "Erwerb von ETH",
- "page-what-is-ethereum-explore-applications": "Anwendungsmöglichkeiten",
- "page-what-is-ethereum-learn-defi": "Infos über DeFi",
- "page-what-is-ethereum-who-runs-ethereum-title": "Wer betreibt Ethereum?",
- "page-what-is-ethereum-who-runs-ethereum-desc-1": "Ethereum wird von keiner bestimmten Entität kontrolliert. Es existiert, wann immer verbundene Computer Software ausführen, die dem Ethereum-Protokoll folgen und zur Ethereum-Blockchain. beitragen. Jeder dieser Computer wird als Node bezeichnet. Nodes können von jedem betrieben werden, obwohl ETH (Ethereums nativer Token) „gestaked“ werden müssen, um dazu beizutragen, die Sicherheit des Netzwerks zu garantieren. Jede Person mit 32 ETH kann dies ohne Genehmigung tun.",
- "page-what-is-ethereum-who-runs-ethereum-desc-2": "Selbst der Quellcode von Ethereum wird nicht von einer einzigen Entität produziert. Jeder kann Änderungen am Protokoll vorschlagen und über Upgrades diskutieren. Es gibt mehrere Implementierungen des Ethereum-Protokolls, die von unabhängigen Organisationen in verschiedenen Programmiersprachen erstellt werden, und sie werden normalerweise offen entwickelt und ermutigen Beiträge aus der Community.",
- "page-what-is-ethereum-run-a-node": "Betrieb eines Nodes",
- "page-what-is-ethereum-smart-contract-title": "Was sind Smart Contracts?",
- "page-what-is-ethereum-smart-contract-desc-1": "Smart Contracts sind Computerprogramme, die auf der Ethereum-Blockchain existieren. Sie werden ausgeführt, wenn sie durch eine Transaktion eines Benutzers ausgelöst werden. Dies eröffnet Ethereum äußerst flexible Mögichkeiten. Diese Programme dienen als Bausteine für dezentrale Anwendungen und Organisationen.",
- "page-what-is-ethereum-smart-contract-desc-2": "Kennen Sie das: Sie nutzen ein Produkt, und auf einmal werden dessen Nutzungsbedingungen geändert? Oder eine für Sie wichtige Funktion wird entfernt? Nicht so bei Smart Contracts! Nach seiner Veröffentlichung bleibt jeder Smart Contract für die Lebensdauer von Ethereum online und betriebsbereit. Nicht einmal der Verfasser kann seinen Smart Contract entfernen. Zudem sind Smart Contracts automatisiert – weshalb sie niemals diskriminieren und immer einsatzbereit sind.",
- "page-what-is-ethereum-smart-contract-desc-3": "Beliebte Beispiele für Smart Contracts sind Kreditvergabe-Anwendungen, dezentrale Handelsbörsen, Versicherungen, quadratische Finanzierung, soziale Netzwerke und NFTs – im Grunde genommen alles, was Sie sich vorstellen können.",
- "page-what-is-ethereum-more-on-smart-contracts": "Mehr über Smart Contracts",
- "page-what-is-ethereum-explore-dapps": "Was sind dApps?",
- "page-what-is-ethereum-criminal-activity-title": "Ich habe gehört, dass Kryptowährungen ein Einfallstor für kriminelle Aktivitäten sind. Stimmt das?",
- "page-what-is-ethereum-criminal-activity-desc-1": "Wie jede Technologie kann auch Ethereum gelegentlich missbraucht werden. Da jedoch alle Transaktionen auf einer öffentlichen Blockchain stattfinden, ist es für Behörden oft einfacher, illegale Aktivitäten nachzuverfolgen als im herkömmlichen Finanzsystem. Dies macht Ethereum für diejenigen, die lieber unentdeckt bleiben möchten, möglicherweise weniger attraktiv.",
- "page-what-is-ethereum-criminal-activity-desc-2": "Kryptowährungen werden laut einer erst kürzlich erhobenen Studie von Europol, der Agentur der Europäischen Union für die Zusammenarbeit zwischen Strafverfolgungsbehörden, gegenüber Fiat-Währungen weitaus seltener für kriminelle Zwecke missbraucht:",
- "page-what-is-ethereum-criminal-activity-desc-3": "„Der Missbrauch von Kryptowährungen für illegale Aktivitäten scheint nur einen kleinen Teil der gesamten Kryptowirtschaft einzunehmen und dies in einem vergleichsweise geringeren Umfang als illegale Gelder im herkömmlichen Finanzsystem.“",
- "page-what-is-ethereum-energy-title": "Wie ist es um den Energieverbrauch von Ethereum bestellt?",
- "page-what-is-ethereum-energy-desc-1": "Am 15. September 2022 durchlief Ethereum die Verbesserung der Zusammenführung (Merge), bei der Ethereum vom Arbeitsnachweis (Proof-of-Work) zum Beteiligungsnachweis (Proof-of-Stake) überging.",
- "page-what-is-ethereum-energy-desc-2": "Die Zusammenführung war Ethereums größte Verbesserung und reduzierte den Energieverbrauch, welcher benötigt wird, um Ethereum abzusichern, um 99,95 %, was ein sichereres Netzwerk für wesentlich geringere CO2-Emissionskosten schuf. Ethereum ist nun eine kohlenstoffarme Blockchain mit gleichzeitig erhöhter Sicherheit und Skalierbarkeit.",
- "page-what-is-ethereum-more-on-energy-consumption": "Mehr zum Energieverbrauch",
- "page-what-is-ethereum-energy-consumption-chart-legend": "Jährlicher Energieverbrauch in TWh/Jahr",
- "energy-consumption-chart-global-data-centers-label": "Globale Rechenzentren",
- "energy-consumption-gold-mining-cbeci-label": "Goldabbau",
- "energy-consumption-chart-btc-pow-label": "BTC PoW",
- "energy-consumption-chart-netflix-label": "Netflix",
- "energy-consumption-chart-eth-pow-label": "ETH PoW",
- "energy-consumption-chart-gaming-us-label": "Gaming in den USA",
- "energy-consumption-chart-airbnb-label": "AirBnB",
- "energy-consumption-chart-paypal-label": "PayPal",
- "energy-consumption-chart-eth-pos-label": "ETH PoS",
- "page-what-is-ethereum-the-merge-update": "Kommendes Update – die Zusammenführung („The Merge“)",
- "page-what-is-ethereum-additional-reading": "Weiterführende Informationen",
- "page-what-is-ethereum-week-in-ethereum": "Week in Ethereum News",
- "page-what-is-ethereum-week-in-ethereum-desc": "- Ein wöchentlicher Newsletter zu wichtigen Entwicklungen im gesamten Ökosystem.",
- "page-what-is-ethereum-kernel-dreamers": "Kernel",
- "page-what-is-ethereum-kernel-dreamers-desc": "Ethereums Traum",
- "page-what-is-ethereum-atoms-institutions-blockchains": "Atome, Institutionen, Blockchains",
- "page-what-is-ethereum-atoms-institutions-blockchains-desc": "– Weshalb Blockchains wichtig sind",
- "page-what-is-ethereum-ethereum-in-numbers-title": "Ethereum in Zahlen",
- "page-what-is-ethereum-ethereum-in-numbers-stat-1-desc": "Auf Ethereum aufbauende Projekte",
- "page-what-is-ethereum-ethereum-in-numbers-stat-2-desc": "Konten (Wallets) mit einem ETH-Guthaben",
- "page-what-is-ethereum-ethereum-in-numbers-stat-3-desc": "Smart Contracts auf Ethereum",
- "page-what-is-ethereum-ethereum-in-numbers-stat-4-desc": "Auf Ethereum gesicherter Wert",
- "page-what-is-ethereum-ethereum-in-numbers-stat-5-desc": "Ersteller-Einnahmen auf Ethereum im Jahr 2021",
- "page-what-is-ethereum-ethereum-in-numbers-stat-6-desc": "Anzahl der Transaktionen heute",
- "adoption-chart-column-now-label": "Gerade",
- "adoption-chart-investors-label": "Investoren",
- "adoption-chart-developers-label": "Entwickler:innen",
- "adoption-chart-companies-label": "Unternehmen",
- "adoption-chart-artists-label": "Künstler:innen",
- "adoption-chart-musicians-label": "Musiker:innen",
- "adoption-chart-writers-label": "Autor:innen",
- "adoption-chart-gamers-label": "Gamer",
- "adoption-chart-refugees-label": "Flüchtlinge",
- "page-what-is-ethereum-get-eth-alt": "ETH erwerben",
- "page-what-is-ethereum-get-eth-description": "ETH ist die native Währung von Ethereum. Um Ethereum-Anwendungen nutzen zu können, benötigen Sie ETH in Ihrer Wallet.",
- "page-what-is-ethereum-get-eth-title": "ETH erwerben",
- "page-what-is-ethereum-explore-dapps-alt": "dApps entdecken",
- "page-what-is-ethereum-explore-dapps-description": "dApps sind Anwendungen, die auf Ethereum basieren. dApps verändern aktuelle Geschäftsmodelle und erfinden neue.",
- "page-what-is-ethereum-explore-dapps-title": "Testen Sie ein paar DApp"
+ "page-what-is-ethereum-hero-description-1": "Ethereum ist ein dezentrales Blockchain-Netzwerk und eine Softwareentwicklungsplattform, die von der Kryptowährung Ether (ETH) betrieben wird.",
+ "page-what-is-ethereum-hero-description-2": "Es beherbergt Tausende von Kryptowährungen und Anwendungen aus den Bereichen DeFi, NFTs, Gaming, dezentrale soziale Medien und Stablecoins.",
+ "page-what-is-ethereum-ethereum-intro-1": "Ethereum ist eine offene, öffentliche Blockchain, die im Juli 2015 von einem Softwareentwickler namens Vitalik Buterin und einem kleinen Team von Mitbegründern ins Leben gerufen wurde.",
+ "page-what-is-ethereum-ethereum-intro-2": "Die Idee hinter Ethereum war einfach. Während Bitcoin das Senden und Empfangen von digitalem Geld ermöglicht, baut Ethereum mit Open-Source-Programmen namens Smart Contracts darauf auf.",
+ "page-what-is-ethereum-ethereum-intro-3": "Mit Smart Contracts kann jeder seine eigenen digitalen Assets und dezentralen Anwendungen (Dapp) erstellen, 24/7 die rund um die Uhr weltweit laufen. Und im Gegensatz zu Banken, Unternehmen oder anderen Institutionen sind Smart Contracts für jeden mit Internetanschluss verfügbar.",
+ "page-what-is-ethereum-ethereum-intro-4": "Seit 2015 hat sich Ethereum zu einem florierenden Ökosystem digitaler Vermögenswerte wie Stablecoins, nicht fungiblen Token (NFTs) und Governance-Token sowie zu einer weitläufigen Welt von Dapps für dezentrale Finanzen (DeFi), Kunst und Sammlerstücke, Gaming und dezentrale soziale Medien entwickelt.",
+ "page-what-is-ethereum-ethereum-intro-5": "Zusammengefasst wird dieses Ökosystem als „Web3“ bezeichnet und stellt die dritte Phase des Internets dar, in der es um Eigentum geht.",
+ "page-what-is-ethereum-ethereum-intro-6": "Heute wird Ethereum von Millionen von Menschen auf der ganzen Welt verwendet, die Milliarden von Dollar an Vermögenswerten besitzen und jedes Jahr Billionen von Dollar senden und empfangen – und das alles ohne Bank.",
+ "page-what-is-ethereum-ethereum-intro-7": "Im Mittelpunkt steht dabei die native Kryptowährung Ether (ETH) von Ethereum, eine neue Art von digitalem Geld, mit dem das gesamte Netzwerk betrieben wird.",
+ "page-what-is-ethereum-network-title": "Was ist das Ethereum-Netzwerk?",
+ "page-what-is-ethereum-network-intro-1": "Sie können sich das Ethereum-Netzwerk als eine globale digitale Infrastruktur vorstellen, die jeder nutzen kann, aber niemand missbrauchen kann.",
+ "page-what-is-ethereum-network-intro-2": "Das Netzwerk besteht aus Tausenden unabhängigen Computern auf der ganzen Welt, den sogenannten Knoten. Diese Knoten werden von normalen Menschen betrieben und arbeiten zusammen, um Finanzdienstleistungen und digitale Anwendungen für jedermann und überall bereitzustellen.",
+ "page-what-is-ethereum-network-intro-3": "Das Ethereum-Netzwerk hat drei wesentliche Vorteile gegenüber herkömmlichen Netzwerken im Besitz von Institutionen. Diese sind Zensurresistenz, erhöhte Sicherheit und verbesserte Zuverlässigkeit.",
+ "page-what-is-ethereum-network-censorship-title": "Zensurresistent",
+ "page-what-is-ethereum-network-censorship-desc-1": "Während herkömmliche Apps und Finanzdienstleistungen auf Banken oder Unternehmen angewiesen sind, die den Zugriff sperren oder Konten einfrieren können, sind dapps auf Ethereum zensurresistent.",
+ "page-what-is-ethereum-network-censorship-desc-2": "Dies liegt daran, dass das Knotennetzwerk von Ethereum jede einzelne Transaktion ohne Diskriminierung aufzeichnet und diese Regel ist im Code eingebettet.",
+ "page-what-is-ethereum-network-security-title": "Hochsicher",
+ "page-what-is-ethereum-network-security-desc-1": "Während viele Apps heute bei Cloud-Anbietern wie AWS gehostet werden und anfällig für Deaktivierungen und Angriffe sein können, werden dapps auf Ethereum durch das Netzwerk selbst geschützt. Jeder Knoten speichert und synchronisiert den gesamten Status von Ethereum, einschließlich aller Verträge.",
+ "page-what-is-ethereum-network-security-desc-2": "Versuchte jemand, einen Vertrag zu ändern, lehnte das Netzwerk dies ab, da es nicht mit den Daten übereinstimmte. Um eine einzige App lahmzulegen, müssten Angreifer das gesamte Netzwerk übernehmen, was Milliarden kosten würde und extrem schwer zu koordinieren wäre.",
+ "page-what-is-ethereum-network-reliability-title": "Langlebig und zuverlässig",
+ "page-what-is-ethereum-network-reliability-desc-1": "Ausfallzeiten auf Cloud-Hosting-Plattformen können dazu führen, dass Apps offline gehen. Das Design von Ethereum gewährleistet jedoch eine perfekte Verfügbarkeit. Das Netzwerk läuft weiter, selbst wenn einige Knoten aufgrund von Softwarefehlern, staatlichen Maßnahmen, Naturkatastrophen oder Krieg offline gehen.",
+ "page-what-is-ethereum-network-reliability-desc-2": "Millionen von Menschen nutzen täglich Tausende von dapps auf Ethereum. Eine hohe Nachfrage kann zwar zu höheren Transaktionsgebühren führen, spiegelt aber die Stärke eines Netzwerks wider, das Sicherheit, Dezentralisierung und die Garantie der ständigen Verfügbarkeit bei Bedarf priorisiert.",
+ "page-what-is-ethereum-network-layer2-title": "Ethereum Erweiterungen (Layer 2)",
+ "page-what-is-ethereum-network-layer2-desc-1": "Verschiedene Teams haben Layer 2 Netzwerke (L2) entwickelt, die auf Ethereum laufen, um dessen Kapazität zu erhöhen. L2 Netzwerke fungieren als Schnellstraßen und machen Transaktionen schneller und günstiger manchmal kosten sie im Durchschnitt weniger als einen Cent.",
+ "page-what-is-ethereum-network-layer2-desc-2": "Einige der beliebtesten L2s, darunter Optimism , Arbitrum , ZKSync und automatisierte Versicherung für ihre Ernte abschließen, ohne eine Bank zu kontaktieren. Unternehmen wie Visa können vom ersten Tag an neue, weltweit funktionierende Zahlungssysteme einführen. Globale Organisationen wie die UN können Hilfe für Flüchtlinge leisten und so Millionen an Bankgebühren sparen.",
+ "page-what-is-ethereum-what-intro-3": "Diese dapps und Assets laufen auf Ethereum mit Open-Source-Code und können nicht eingeschränkt, zensiert oder deaktiviert werden.",
+ "page-what-is-ethereum-what-intro-4": "So wird es heute von verschiedenen Gruppen verwendet:",
+ "page-what-is-ethereum-what-consumers-title": "Verbraucher",
+ "page-what-is-ethereum-what-consumers-desc-1": "Millionen von Menschen nutzen bereits täglich Dapps auf Ethereum, um Geld zu transferieren, zu handeln und digitale Vermögenswerte zu besitzen. Im Gegensatz zu herkömmlichen Apps müssen Sie sich nicht mit Ihrem Namen registrieren, auf die Genehmigung einer Bank warten oder Ihre persönlichen Daten weitergeben.",
+ "page-what-is-ethereum-what-consumers-desc-2": "Mit nur einer Brieftasche und einer Internetverbindung können Sie:",
+ "page-what-is-ethereum-what-consumers-benefit-1": "Zugriff auf Finanzdienstleistungen ohne Bankkonto oder Kredithistorie",
+ "page-what-is-ethereum-what-consumers-benefit-2": "Eigene digitale Sammlerstücke, Kunst und Vermögenswerte, die nicht kopiert oder beschlagnahmt werden können",
+ "page-what-is-ethereum-what-consumers-benefit-3": "Melden Sie sich bei dapps mit Ihrem Wallet an, nicht mit Ihrer E-Mail-Adresse – keine Passwörter, keine persönlichen Daten erforderlich",
+ "page-what-is-ethereum-what-consumers-benefit-4": "Nehmen Sie an globalen Communities teil, in denen Sie grenzenlos abstimmen, beitragen und verdienen können",
+ "page-what-is-ethereum-what-businesses-title": "Unternehmen und Entwickler",
+ "page-what-is-ethereum-what-businesses-benefit-1": "Starten Sie Dapp mit integriertem globalen Zahlungssystem vom ersten Tag an",
+ "page-what-is-ethereum-what-businesses-benefit-2": "Setzen Sie manipulationssichere Verträge ein, die Vereinbarungen automatisch durchsetzen",
+ "page-what-is-ethereum-what-businesses-benefit-3": "Erstellen Sie Finanzprodukte, auf denen jeder aufbauen und deren Wert steigern kann",
+ "page-what-is-ethereum-what-businesses-example": "Beispielsweise hat PayPal seinen eigenen Stablecoin, PYUSD, auf Ethereum eingeführt. Dies ist ein Zeichen dafür, dass selbst die weltweit größten Zahlungsunternehmen die Vorteile der offenen und programmierbaren Natur von Ethereum erkennen.",
+ "page-what-is-ethereum-what-governments-title": "Regierungen",
+ "page-what-is-ethereum-what-governments-intro": "Auch Regierungen beginnen zu erforschen, was Ethereum ermöglicht.",
+ "page-what-is-ethereum-what-governments-benefit-1": "Verteilen Sie öffentliche Gelder und Leistungen direkt und mit voller Transparenz an die Bürger",
+ "page-what-is-ethereum-what-governments-benefit-2": "Stellen Sie digitale IDs oder Aufzeichnungen aus, die überprüfbar und grenzüberschreitend übertragbar sind",
+ "page-what-is-ethereum-what-governments-benefit-3": "Bauen Sie eine manipulationssichere öffentliche Infrastruktur für Wahlen, Grundbucheinträge und Register auf",
+ "page-what-is-ethereum-what-governments-example-1": "In einem anderen Fall nutzte das ukrainische Ministerium für digitale Transformation Ethereum zur Verteilung von Kriegshilfe.",
+ "page-what-is-ethereum-what-governments-example-2": "Mittel wurden mithilfe offener Smart Contracts direkt an Bürger und NGOs gesendet, was während einer Krise für Transparenz, Schnelligkeit und Rechenschaftspflicht sorgte.",
+ "page-what-is-ethereum-what-learn-more": "Erfahren Sie mehr darüber, wofür Ethereum verwendet wird",
+ "page-what-is-ethereum-start-title": "So starten Sie mit der Nutzung von Ethereum",
+ "page-what-is-ethereum-start-intro-1": "Der Einstieg in Ethereum ist einfacher als Sie vielleicht denken.",
+ "page-what-is-ethereum-start-intro-2": "Sie benötigen keine Genehmigung. Sie brauchen weder eine Bank noch einen Ausweis. Alles, was Sie zum Starten brauchen, ist ein Gerät und eine Internetverbindung.",
+ "page-what-is-ethereum-start-individuals-title": "Für Einzelpersonen",
+ "page-what-is-ethereum-start-individuals-desc-1": "Der erste Schritt ist das Herunterladen einer Wallet.",
+ "page-what-is-ethereum-start-individuals-desc-2": "Stellen Sie es sich wie eine App vor, die sowohl als Ihr Konto als auch als Ihr Internetbrowser für Ethereum fungiert. Sie verwaltet Ihre Kryptowährungen, ermöglicht Ihnen die Anmeldung bei Dapp sowie das Senden und Empfangen digitaler Assets wie Token und NFTs.",
+ "page-what-is-ethereum-start-individuals-desc-3": "Beliebte Wallets wie er wollte , Regenbogen und Coinbase Wallet sind kostenlos und einfach zu verwenden. Sobald Ihr Wallet eingerichtet ist, können Sie:",
+ "page-what-is-ethereum-start-individuals-step-1": "Kaufen Sie eine kleine Menge ETH an einer Börse oder direkt in einigen Wallets",
+ "page-what-is-ethereum-start-individuals-step-2": "Verwenden Sie dieses ETH, um Transaktionen wie das Senden von Token oder das Sammeln von NFTs zu bezahlen",
+ "page-what-is-ethereum-start-individuals-step-3": "Entdecken Sie Dapp wie Zora , Uniswap oder Feuerwerfer – keine neuen Anmeldungen oder Genehmigungen erforderlich",
+ "page-what-is-ethereum-start-individuals-desc-4": "Diese Prioritäten werden dazu beitragen, dass Ethereum sicher, skalierbar und benutzerfreundlich ist, da sich täglich mehr Menschen auf das Netzwerk verlassen.",
+ "page-what-is-ethereum-start-individuals-desc-5": "Diese Dapp laufen in Ihrem Browser und funktionieren sofort mit Ihrem Wallet. Sie können Ethereum innerhalb weniger Minuten nutzen.",
+ "page-what-is-ethereum-start-individuals-cta-1": "Hier starten",
+ "page-what-is-ethereum-start-individuals-cta-2": "Siehe Apps",
+ "page-what-is-ethereum-start-developers-title": "Für Entwickler",
+ "page-what-is-ethereum-start-developers-desc-1": "Ethereum ist ein Spielplatz für Entwickler. Sie können ohne Erlaubnis, Genehmigung oder sogar echtes Geld mit dem Bauen beginnen.",
+ "page-what-is-ethereum-start-developers-desc-2": "Die Ethereum-Entwicklerdokumente führen Sie durch alles, vom Schreiben Ihres ersten Smart Contracts bis zur Bereitstellung in Testnetzwerken wie Sepolia.",
+ "page-what-is-ethereum-start-developers-desc-3": "Sie können voll Stack Dapp mit Tools wie Hardhat , Foundry und Ethers.js erstellen oder mit niedrig Code Plattformen wie Thirdweb oder Moralis experimentieren.",
+ "page-what-is-ethereum-start-developers-desc-4": "Alles ist Open Source und zusammensetzbar, sodass Sie bereits vorhandene Elemente neu kombinieren und darauf aufbauen können, ohne um Erlaubnis fragen zu müssen.",
+ "page-what-is-ethereum-start-developers-cta": "Beginnen Sie mit dem Aufbau auf Ethereum",
+ "page-what-is-ethereum-start-business-title": "Nutzen Sie Ethereum im Geschäftsleben",
+ "page-what-is-ethereum-start-business-desc-1": "Unternehmen nutzen Ethereum bereits, um neue Infrastrukturen zu betreiben.",
+ "page-what-is-ethereum-start-business-desc-2": "Viele Unternehmen setzen auf L2-Netzwerke wie Optimism und Base, um Anwendungsfälle mit hohem Volumen zu unterstützen. Diese Netzwerke bieten niedrigere Gebühren und höhere Geschwindigkeiten, profitieren aber dennoch von der Sicherheit von Ethereum und eliminieren das Kontrahentenrisiko.",
+ "page-what-is-ethereum-start-business-desc-3": "Du kannst:",
+ "page-what-is-ethereum-start-business-benefit-1": "Starten Sie modulare Treueprogramme, die die Kundenbindung stärken und die Kosten für Drittanbieter senken",
+ "page-what-is-ethereum-start-business-benefit-2": "Tokenisieren Sie Vermögenswerte wie Tickets, Coupons oder Zertifikate, um Betrug und das Risiko des Weiterverkaufs zu reduzieren",
+ "page-what-is-ethereum-start-business-benefit-3": "Ermöglichen Sie sofortige globale Zahlungen, um Transaktionsgebühren zu senken und neue Märkte zu erschließen",
+ "page-what-is-ethereum-start-business-example": "Beispielsweise wurde im Jahr 2025 Shopify auf Base eingeführt, um Verbrauchern das Ausgeben von Stablecoins bei Millionen von Händlern auf der ganzen Welt zu ermöglichen.",
+ "page-what-is-ethereum-start-business-cta": "Nutzen Sie Ethereum im Geschäftsleben",
+ "page-what-is-ethereum-bitcoin-title": "Was ist der Unterschied zwischen Ethereum und Bitcoin?",
+ "page-what-is-ethereum-bitcoin-intro-1": "Bitcoin und Ethereum sind die beiden größten Kryptowährungen der Welt.",
+ "page-what-is-ethereum-bitcoin-intro-2": "Mit beiden können Sie Geld ohne Bank senden, beide basieren auf Blockchain-Technologie und beide sind für jeden zugänglich. Aber hier enden die Gemeinsamkeiten auch schon.",
+ "page-what-is-ethereum-bitcoin-comparison-1-title": "Bitcoin ist wie digitales Gold.",
+ "page-what-is-ethereum-bitcoin-comparison-1-desc": "Es verfügt über einen festen Vorrat von 21 Millionen Coins, einen engen Fokus auf Peer-to-Peer-Zahlungen und eine einfache Skriptsprache, die die Möglichkeiten, damit zu bauen, einschränkt. Diese Einfachheit ist beabsichtigt, da Bitcoin Vorhersehbarkeit, Haltbarkeit und langfristige Sicherheit gegenüber Flexibilität priorisiert.",
+ "page-what-is-ethereum-bitcoin-comparison-2-title": "Ethereum verfolgt einen umfassenderen Ansatz.",
+ "page-what-is-ethereum-bitcoin-comparison-2-desc": "Es geht nicht nur um Geld, sondern um programmierbare Infrastruktur. Anstatt nur Werte zu senden und zu empfangen, ermöglicht Ethereum Entwicklern die Erstellung kompletter Anwendungen. Sie haben dies bereits in Aktion gesehen: von Kreditmärkten und Stablecoins bis hin zu Sammlerstücken, sozialen Medien und Echtzeitzahlungen – alles basiert auf Smart Contracts und ist durch ETH gesichert.",
+ "page-what-is-ethereum-bitcoin-comparison-3-title": "Auch die Art und Weise, wie die Netzwerke einen Konsens erzielen, ist unterschiedlich.",
+ "page-what-is-ethereum-bitcoin-comparison-3-desc-1": "Bitcoin nutzt Miner, um das Netzwerk zu sichern. Dabei handelt es sich um leistungsstarke Computer, die im Wettstreit um die Lösung komplexer Rätsel stehen. Der Gewinner darf den nächsten Transaktionsblock zur Kette hinzufügen und erhält Bitcoins als Belohnung. Dieser Prozess wird als Mining bezeichnet und verbraucht große Mengen Strom.",
+ "page-what-is-ethereum-bitcoin-comparison-3-desc-2": "Ethereum hat früher auch so funktioniert. Aber 2022 wurde von Proof-of-Work auf Proof-of-Stake umgestellt. Heute werden Transaktionen von Validatoren bestätigt, die ETH als Sicherheit hinterlegen. Ehrliche Validatoren verdienen ETH-Belohnungen, während unehrliche einen Teil ihres Einsatzes verlieren. Diese Umstellung machte Ethereum um über 99,988 % energieeffizienter, ohne dabei die Sicherheit oder Dezentralisierung zu beeinträchtigen.",
+ "page-what-is-ethereum-bitcoin-comparison-4-title": "Auch in der Handhabung der Versorgung gibt es Unterschiede.",
+ "page-what-is-ethereum-bitcoin-comparison-4-desc-1": "Bitcoin hat ein festes Angebot. Es wird immer nur 21 Millionen Münzen geben. Ethereum hingegen hat ein dynamisches Angebot. Neue ETH werden ausgegeben, um Validierer zu belohnen, während bei jeder Transaktion ein Teil verbrannt wird. Das bedeutet, dass Ethereum nicht einfach \"unendlich ETH drucken“ kann.",
+ "page-what-is-ethereum-bitcoin-comparison-4-desc-2": "Die Ausgaberate wird durch die Höhe des ETH-Einsatzes begrenzt. Je mehr ETH eingesetzt werden, desto geringer sind die individuellen Belohnungen, wodurch ein natürliches Gleichgewicht entsteht. Dieses Design gewährleistet ein nachhaltiges Sicherheitsbudget auch in der Zukunft, ohne sich ausschließlich auf Transaktionsgebühren zu verlassen.",
+ "page-what-is-ethereum-bitcoin-comparison-4-desc-3": "Kurz gesagt: Bitcoin ist ein Werkzeug zum Senden von Werten. Ethereum ist eine Plattform zum Erstellen dieser Werte.",
+ "page-what-is-ethereum-bitcoin-learn-more": "Erfahren Sie mehr über den Unterschied zwischen Ethereum und Bitcoin",
+ "page-what-is-ethereum-when-who-title": "Wann wurde Ethereum eingeführt, wer hat es gegründet und wer betreibt es jetzt?",
+ "page-what-is-ethereum-when-who-intro-1": "Ethereum wurde von Anfang an so konzipiert, dass es von seiner Community betrieben wird.",
+ "page-what-is-ethereum-when-who-intro-2": "Im Jahr 2013 veröffentlichte Vitalik Buterin ein Whitepaper, in dem er eine neue Art von Blockchain für Geld und Apps vorschlug, die jeder nutzen könnte. Die Idee gewann schnell an Bedeutung.",
+ "page-what-is-ethereum-when-who-intro-3": "Im Jahr 2014 schlossen sich Mitbegründer wie Gavin Wood und Joseph lubin dem Projekt an und das Team sammelte im Rahmen einer der ersten Krypto Crowdfunding Kampagnen Geld.",
+ "page-what-is-ethereum-when-who-intro-4": "Ethereum wurde im Juli 2015 offiziell eingeführt.",
+ "page-what-is-ethereum-when-who-history-title": "Schlüsselmomente in der Geschichte von Ethereum",
+ "page-what-is-ethereum-when-who-history-2013": "Der 19-jährige Vitalik Buterin veröffentlicht das Ethereum-Whitepaper",
+ "page-what-is-ethereum-when-who-history-2014": "Die Ethereum Foundation gründet und startet eine Crowdfunding Kampagne",
+ "page-what-is-ethereum-when-who-history-2015": "Entwickler starten das Ethereum-Netzwerk mit der Frontier-Version",
+ "page-what-is-ethereum-when-who-history-2016": "Ein Smart Contract Exploit entzieht der DAO 60 Millionen US-Dollar (3,6 Millionen ETH) und löst eine Kettengabelung aus",
+ "page-what-is-ethereum-when-who-history-2020": "Mit der Einführung der Beacon Chain beginnt der Übergang zum Proof of Stake",
+ "page-what-is-ethereum-when-who-history-2021": "London-Upgrade beginnt mit der Verbrennung von Gasgebühren über EIP-1559",
+ "page-what-is-ethereum-when-who-history-2022": "The Merge ersetzt Mining durch Staking und senkt den Energieverbrauch um 99 %",
+ "page-what-is-ethereum-when-who-history-2025": "Pectra-Upgrade verbessert Smart Wallet-Unterstützung und L2-Kompatibilität",
+ "page-what-is-ethereum-when-who-governance-1": "Heute wird Ethereum nicht mehr von einer einzelnen Person oder Firma betrieben.",
+ "page-what-is-ethereum-when-who-contributors-title": "Das Netzwerk wird von einer breiten Gruppe von Mitwirkenden gepflegt:",
+ "page-what-is-ethereum-when-who-contributors-1": "Entwickler, die Upgrades schreiben und vorschlagen",
+ "page-what-is-ethereum-when-who-contributors-2": "Knotenbetreiber, die zur verteilten physischen Infrastruktur beitragen",
+ "page-what-is-ethereum-when-who-contributors-3": "Staker, die Transaktionen validieren",
+ "page-what-is-ethereum-when-who-contributors-4": "Community-Mitglieder, die die Tools und die Kultur entwickeln",
+ "page-what-is-ethereum-when-who-contributors-5": "Sie durch die Nutzung des Netzwerks",
+ "page-what-is-ethereum-when-who-governance-2": "Es gibt keinen CEO, Vorstand oder eine zentrale Behörde. Die Ethereum Foundation unterstützt weiterhin die Finanzierung von Forschung und Entwicklung, aber das Ökosystem basiert auf offener Beteiligung.",
+ "page-what-is-ethereum-when-who-governance-3": "Änderungen werden über Ethereum Improvement Proposals (EIPs) vorgeschlagen, öffentlich diskutiert und nur dann übernommen, wenn die breitere Community sie unterstützt .",
+ "page-what-is-ethereum-when-who-governance-4": "Dadurch verändert sich Ethereum langsamer als ein Startup, ist aber auch viel schwieriger zu schließen oder zu übernehmen.",
+ "page-what-is-ethereum-when-who-learn-more": "Erfahren Sie mehr über die Geschichte von Ethereum",
+ "page-what-is-ethereum-roadmap-title": "Wie sieht die Ethereum-Roadmap für 2025 aus?",
+ "page-what-is-ethereum-roadmap-intro-1": "Ethereum folgt keiner festen Roadmap. Es folgt einer gemeinsamen Vision.",
+ "page-what-is-ethereum-roadmap-intro-2": "Netzwerkupgrades werden als EIPs umgesetzt und von Mitwirkenden auf der ganzen Welt öffentlich entwickelt. Es gibt kein zentrales Team, das entscheidet, was passiert, sondern einfach Menschen, die das entwickeln, was sie auf der Grundlage der Nutzerbedürfnisse für nützlich halten.",
+ "page-what-is-ethereum-roadmap-intro-3": "Pectra ist das neueste Upgrade, das im Mai 2025 veröffentlicht wurde. Dieses Upgrade verbesserte die Wallet-Funktionen, gab den Stakern mehr Flexibilität und erleichterte die Ausführung von Dapps auf L2s. Ziel war es, die Benutzerfreundlichkeit zu verbessern, ohne Kompromisse bei Sicherheit oder Dezentralisierung einzugehen.",
+ "page-what-is-ethereum-roadmap-priorities-intro": "Mit Blick auf die Zukunft gehören zu den Prioritäten von Ethereum:",
+ "page-what-is-ethereum-roadmap-priority-1": "Das Kernprotokoll und seine L2s für alle schneller und günstiger machen",
+ "page-what-is-ethereum-roadmap-priority-2": "Verbesserung der Erfahrung für Benutzer und Entwickler",
+ "page-what-is-ethereum-roadmap-outro-1": "Diese Prioritäten werden dazu beitragen, dass Ethereum sicher, skalierbar und benutzerfreundlich ist, da sich täglich mehr Menschen auf das Netzwerk verlassen.",
+ "page-what-is-ethereum-roadmap-outro-2": "Wenn Sie die Richtung von Ethereum bestimmen möchten, beteiligen Sie sich. Sie brauchen keine Genehmigung, nur den Wunsch, in dieser neuen digitalen Wirtschaft etwas zu bewegen.",
+ "page-what-is-ethereum-roadmap-learn-more": "Sehen Sie sich eine Übersicht der Ethereum-Roadmap an",
+ "page-what-is-ethereum-further-reading-title": "Was sind Wallets?",
+ "page-what-is-ethereum-further-reading-wallets": "Was sind Wallets?",
+ "page-what-is-ethereum-further-reading-eth": "Was ist Ether (ETH)?",
+ "page-what-is-ethereum-further-reading-web3": "Was ist web3?",
+ "page-what-is-ethereum-further-reading-networks": "Erfahren Sie mehr über das Ethereum Netzwerk",
+ "page-what-is-ethereum-toc-ethereum": "Was ist Ethereum?",
+ "page-what-is-ethereum-toc-network": "Was ist das Ethereum-Netzwerk?",
+ "page-what-is-ethereum-toc-ether": "Was ist Ether (ETH)?",
+ "page-what-is-ethereum-toc-how": "Wie funktioniert Ethereum?",
+ "page-what-is-ethereum-toc-what": "Wofür wird Ethereum verwendet?",
+ "page-what-is-ethereum-toc-start": "So starten Sie mit der Nutzung von Ethereum",
+ "page-what-is-ethereum-toc-bitcoin": "Was ist der Unterschied zwischen Ethereum und Bitcoin?",
+ "page-what-is-ethereum-toc-when-who": "Wann wurde Ethereum eingeführt, wer hat es gegründet und wer betreibt es jetzt?",
+ "page-what-is-ethereum-toc-roadmap": "Wie sieht die Ethereum-Roadmap für 2025 aus?",
+ "page-what-is-ethereum-banner-networks-alt": "Illustration des futuristischen Ethereum-Gemeindezentrums",
+ "page-what-is-ethereum-banner-ether-alt": "Offene Hände halten Äther Glyphe",
+ "page-what-is-ethereum-banner-how-alt": "Mann repariert Computer",
+ "page-what-is-ethereum-banner-contributing-alt": "Doge lächelt am Computer",
+ "page-what-is-ethereum-banner-what-alt": "Vier futuristische Menschen und ein Doge blicken in ein Ethereum Prisma",
+ "page-what-is-ethereum-banner-start-alt": "Futuristisches Gemeindezentrum",
+ "page-what-is-ethereum-banner-when-who-alt": "Zwei Menschen gehen und reden"
}
diff --git a/src/intl/de/page-what-is-the-ethereum-network.json b/src/intl/de/page-what-is-the-ethereum-network.json
new file mode 100644
index 00000000000..00c23059867
--- /dev/null
+++ b/src/intl/de/page-what-is-the-ethereum-network.json
@@ -0,0 +1,89 @@
+{
+ "page-what-is-ethereum-network-meta-title": "Was ist das Ethereum-Netzwerk? | ethereum.org",
+ "page-what-is-ethereum-network-meta-description": "Verstehen Sie, was das Ethereum-Netzwerk ist, Staking und Sicherheit, Netzwerkgebühren (auch als Gas bekannt), Layer-2-Skalierungsnetzwerke und wie man Live-Netzwerkdaten erkundet.",
+ "page-what-is-ethereum-network-twitter-meta-description": "Verstehen Sie, was das Ethereum-Netzwerk ist, Staking und Sicherheit, Netzwerkgebühren, Layer-2-Skalierungsnetzwerke und wie man Live-Netzwerkdaten erkundet.",
+ "page-what-is-ethereum-network-title": "Was ist das Ethereum-Netzwerk?",
+ "page-what-is-ethereum-network-description-1": "Das Ethereum-Netzwerk ist die physische und digitale Infrastruktur, die Ethereum zugrunde liegt.",
+ "page-what-is-ethereum-network-description-2": "Dazu gehören Knoten (Nodes), die Daten speichern, Validatoren, die Transaktionen verarbeiten, Software, die Smart Contracts ausführt, und Layer-2-Netzwerke, die Ethereum über die Haupt-Chain hinaus skalieren.",
+ "page-what-is-ethereum-network-section-network-fees-title": "Was sind Ethereum-Netzwerkgebühren (auch Gasgebühren genannt)?",
+ "page-what-is-ethereum-network-section-staking-title": "Was ist Staking und wie sichert es das Netzwerk?",
+ "page-what-is-ethereum-network-section-layer-2s-title": "Was sind Ethereum Layer-2s und wie skalieren sie das Netzwerk?",
+ "page-what-is-ethereum-network-section-live-network-data-title": "Wie man Live-Daten des Ethereum-Netzwerks erkundet",
+ "page-what-is-ethereum-network-read-next-title": "Was sind Wallets?",
+ "page-what-is-ethereum-network-read-next-item-1": "Was sind Wallets?",
+ "page-what-is-ethereum-network-read-next-item-2": "Was ist Ether (ETH)?",
+ "page-what-is-ethereum-network-read-next-item-3": "Was ist web3?",
+ "page-what-is-ethereum-network-read-next-item-4": "Erfahren Sie mehr über das Ethereum Netzwerk",
+ "page-what-is-ethereum-network-section-description-1": "Wenn Leute über Ethereum sprechen, meinen sie normalerweise ein paar verschiedene Dinge. Es gibt das Ökosystem aus Apps und digitalen Vermögenswerten, die Open-Source-Softwareplattform und die native Währung Ether (ETH).",
+ "page-what-is-ethereum-network-section-description-2": "Aber unter all dem liegt das Ethereum-Netzwerk; die physische und digitale Grundlage, die alles zusammenhält.",
+ "page-what-is-ethereum-network-section-description-3": "Im Kern ist das Ethereum-Netzwerk eine Sammlung von Tausenden unabhängiger Computer, die Knoten (Nodes) genannt werden. Diese Knoten werden von Menschen auf der ganzen Welt betrieben. Sie arbeiten zusammen, um Daten zu speichern, Smart Contracts auszuführen und jede Transaktion in einem offenen, öffentlichen Hauptbuch aufzuzeichnen.",
+ "page-what-is-ethereum-network-section-description-4": "Das Ethereum-Netzwerk erledigt mehrere Schlüsselaufgaben, wie zum Beispiel:",
+ "page-what-is-ethereum-network-section-description-5": "Aktualisierung von Benutzerkonten und Guthaben",
+ "page-what-is-ethereum-network-section-description-6": "Ausführung von Smart Contracts (Programme, die Apps ausführen)",
+ "page-what-is-ethereum-network-section-description-7": "Nachverfolgung des Eigentums an digitalen Vermögenswerten (wie Stablecoins und NFTs)",
+ "page-what-is-ethereum-network-section-description-8": "Verarbeitung aller Transaktionen, die täglich über Ethereum laufen",
+ "page-what-is-ethereum-network-section-description-9": "Glücklicherweise müssen Sie nicht verstehen, wie das Netzwerk funktioniert, um es zu nutzen.",
+ "page-what-is-ethereum-network-section-description-10": "Die meisten Menschen nutzen das Netzwerk einfach über eine digitale Wallet. Eine Wallet ist in der Regel eine Web- oder mobile App, mit der Sie ETH senden und empfangen, Ihre Vermögenswerte verwalten und Apps nutzen können.",
+ "page-what-is-ethereum-network-section-description-11": "Andere Arten von Benutzern wie Entwickler und Unternehmen, die auf Ethereum aufbauen, könnten APIs, Node-Software verwenden oder Smart Contracts bereitstellen.",
+ "page-what-is-ethereum-network-section-description-12": "Das Ethereum-Netzwerk unterscheidet sich von traditionellen Systemen durch seine Konzeption. Der Code und die Daten von Ethereum werden auf dezentralen Knoten (Nodes) auf der ganzen Welt gespeichert, sodass niemand Ihren Zugang blockieren oder Ihre App abschalten kann.",
+ "page-what-is-ethereum-network-section-description-13": "Und weil jeder beitreten kann, öffnet es die Tür für globalen Zugang und Innovation.",
+ "page-what-is-ethereum-network-section-description-14": "Diese Eigenschaften ermöglichen Dinge, die vorher nicht möglich waren, wie zum Beispiel:",
+ "page-what-is-ethereum-network-section-description-15": "Dateneigentum",
+ "page-what-is-ethereum-network-section-description-16": "soziale Medien ohne De-Platforming",
+ "page-what-is-ethereum-network-section-description-17": "offene und transparente Finanzsysteme",
+ "page-what-is-ethereum-network-section-description-18": "Im Kern ist das Ethereum-Netzwerk eine Grundlage für digitales Eigentum und offene Teilnahme.",
+ "page-what-is-ethereum-network-section-description-19": "Sie hören vielleicht, wie Leute vom Ethereum Mainnet sprechen. Dies ist dasselbe Ethereum-Netzwerk, das Millionen täglich nutzen, auf dem echte Vermögenswerte ausgetauscht werden und echte Apps laufen. Aber „Mainnet“ hilft dabei, es von Ethereum Layer-2-Netzwerken und Testnetzen (Testnets) zu unterscheiden, die Entwickler verwenden, um neue Funktionen vor der Live-Schaltung auszuprobieren.",
+ "page-what-is-ethereum-network-gas-section-description-1": "Jede Transaktion auf Ethereum kostet eine kleine Gebühr, die als Gasgebühr bezeichnet wird. Egal, ob Sie ETH senden, Tokens tauschen oder eine App verwenden, Sie zahlen jedes Mal eine kleine Menge Gas, wenn Sie Daten auf die Blockchain schreiben.",
+ "page-what-is-ethereum-network-gas-section-description-2": "Gasgebühren sorgen dafür, dass Ethereum reibungslos läuft. Ohne sie könnten böswillige Akteure das Netzwerk mit leeren Transaktionen zuspammen und es durch starke Überlastung unbenutzbar machen, da es keine Möglichkeit gäbe, Transaktionen nach der Gebühr zu priorisieren, die die Benutzer zu zahlen bereit sind.",
+ "page-what-is-ethereum-network-gas-section-description-3": "Ethereum-Gasgebühren decken die Kosten der vielen verschiedenen Ressourcen, die eine Transaktion verbrauchen kann, wie Rechenleistung, Bandbreite oder Speicher. All dies wird für Benutzer in einem einzigen Wert abstrahiert, aber es wird umfangreiche F&E betrieben, um zu bestimmen, wie viel jede Operation im Verhältnis zu den anderen kosten sollte.",
+ "page-what-is-ethereum-network-gas-section-description-4": "Was passiert also, wenn Sie Gas bezahlen? Ein Teil davon wird an den Validator gezahlt, der Ihre Transaktion zu einem „Block“ von Transaktionen hinzufügt. Ein anderer Teil wird „verbrannt“, wodurch er aus dem Angebot entfernt wird.",
+ "page-what-is-ethereum-network-gas-section-description-5": "Dies hilft, Angebot und Nachfrage auszugleichen, denn wenn das Netzwerk ausgelastet ist, steigen die Gebühren. Wenn es ruhiger ist, sinken die Gebühren.",
+ "page-what-is-ethereum-network-gas-section-description-6": "Seitdem das Netzwerk im August 2021 das Verbrennen von Gebühren eingeführt hat , wurden Millionen von ETH verbrannt . Sie können die neuesten Zahlen über Netzwerk-Dashboards und Explorer erkunden, die von der Ethereum-Community erstellt wurden.",
+ "page-what-is-ethereum-network-gas-section-description-7": "Wie viel kostet also eine Transaktion?",
+ "page-what-is-ethereum-network-gas-section-description-8": "Nun, die Gebühren variieren je nachdem, was Sie tun. Das einfache Senden von ETH kann weniger als einen Dollar kosten. Das Tauschen von Tokens an einer dezentralen Börse (DEX) kann einige Dollar oder mehr kosten, besonders wenn das Netzwerk ausgelastet ist. Je komplexer die Transaktion, desto mehr Gas kostet sie.",
+ "page-what-is-ethereum-network-gas-section-description-9": "Gasgebühren sind einer der sichtbarsten Aspekte bei der Nutzung von Ethereum, insbesondere für neue Benutzer, aber sie tragen alle dazu bei, das Netzwerk zuverlässiger und sicherer zu machen.",
+ "page-what-is-ethereum-network-gas-section-description-10": "Erfahren Sie mehr über Ethereum-Netzwerkgebühren",
+ "page-what-is-ethereum-network-staking-section-description-1": "Das Ethereum-Netzwerk wird durch ein System namens Staking gesichert. Auf diese Weise verifiziert Ethereum Transaktionen, fügt neue Blöcke hinzu und schützt das Netzwerk vor Angriffen.",
+ "page-what-is-ethereum-network-staking-section-description-2": "Als Ethereum anfing, verwendete es einen Konsensmechanismus (eine Methode, um sich darauf zu einigen, wem was gehört), der Proof-of-Work genannt wird. Dies ist derselbe Mechanismus, den Bitcoin heute verwendet.",
+ "page-what-is-ethereum-network-staking-section-description-3": "Im September 2022 stieg Ethereum auf einen sichereren und energieeffizienteren Proof-of-Stake-Konsensmechanismus um.",
+ "page-what-is-ethereum-network-staking-section-description-4": "Wie funktioniert das also?",
+ "page-what-is-ethereum-network-staking-section-description-5": "Einfach ausgedrückt, sperren Leute einige ETH (setzen ihre ETH ein) als Einlage, damit sie helfen können, das Netzwerk zu sichern. Diese Leute werden Validatoren genannt. Wenn Sie ETH staken, wird Ihr Validator ausgewählt, um neue Transaktionen zu überprüfen und hinzuzufügen. Wenn Sie dies ehrlich tun, verdienen Sie Belohnungen. Wenn Sie versuchen zu betrügen, verlieren Sie einen Teil Ihres Einsatzes.",
+ "page-what-is-ethereum-network-staking-section-description-6": "Staking ist die Art und Weise, wie sich Ethereum glaubwürdig zu seiner Servicequalität verpflichtet. All dieses eingesetzte Geld hat das beste Interesse daran, dass Ethereum sicher bleibt – würden Sie dagegen wetten?",
+ "page-what-is-ethereum-network-staking-section-description-7": "Nur zwei Jahre nach der Einführung von Proof-of-Stake hat Ethereum über eine Million Validatoren angezogen, die Millionen von ETH staken, um Ethereum zu sichern. Dies macht einen Angriff auf Ethereum extrem teuer und schwierig. Das liegt daran, dass eine Entität, um das Netzwerk anzugreifen, mindestens 1/3 aller gestakten ETH benötigt, um mit dem Angriff auf das Netzwerk zu beginnen. Heute beläuft sich das auf Dutzende von Milliarden Dollar, und selbst dann würde der Angriff wahrscheinlich scheitern, denn wenn mehr als 1/3 mit dem Rest des Netzwerks nicht übereinstimmt, würde dies die Finalisierung verhindern, aber die Chain würde mit der anderen Version, die als Wahrheitsquelle gilt, weiterwachsen. Mehr als 1/2 ändert, welche Version als Wahrheit gilt, und mehr als 2/3 würden es ermöglichen, etwas zu finalisieren, mit dem der Rest nicht einverstanden ist.",
+ "page-what-is-ethereum-network-staking-section-description-8": "Das ist es, was Ethereum „ökonomische Sicherheit“ verleiht. Es geht nicht nur darum, die richtige Technologie zu haben. Es geht darum, Angriffe so kostspielig zu machen, dass sie gar nicht erst versucht werden.",
+ "page-what-is-ethereum-network-staking-section-description-9": "Um das Ethereum-Netzwerk zu sichern, können Sie dies auf zwei Hauptwegen tun.",
+ "page-what-is-ethereum-network-staking-section-description-10": "Der erste Weg ist das Betreiben eines Knotens (Node). Knoten speichern die gesamte Historie der Blockchain, einschließlich aller Transaktionen und Smart-Contract-Daten. Durch die Synchronisierung mit anderen Knoten können sie sich über den Zustand des Netzwerks einigen und sicherstellen, dass Transaktionen legitim sind und Smart-Contract-Daten verfügbar sind.",
+ "page-what-is-ethereum-network-staking-section-description-11": "Der zweite Weg ist das Staken Ihrer ETH. Der einfachste Weg ist über einen Staking-Anbieter wie Lido oder Rocketpool . aber wenn Sie das nötige Wissen haben, versuchen Sie, Validator-Software zu Hause zu betreiben.",
+ "page-what-is-ethereum-network-staking-section-description-12": "Erfahren Sie mehr über Staking und wie Sie es tun können",
+ "page-what-is-ethereum-network-staking-section-description-13": "Erfahren Sie, wie man einen Knoten (Node) betreibt",
+ "page-what-is-ethereum-network-layer-2s-section-description-1": "Da Ethereum immer beliebter wird, wird das Netzwerk immer stärker ausgelastet. Bei hoher Nachfrage steigen die Gasgebühren und Transaktionen dauern länger. Um dies zu beheben, haben Entwickler eine Reihe von Begleitnetzwerken namens Layer-2s entwickelt.",
+ "page-what-is-ethereum-network-layer-2s-section-description-2": "Layer-2s, auch als L2s bezeichnet, sind andere Netzwerke, die auf Ethereum aufbauen. Sie verarbeiten Transaktionen separat und senden dann eine Zusammenfassung zur Speicherung an Ethereum.",
+ "page-what-is-ethereum-network-layer-2s-section-description-3": "Man kann sie sich wie Expressspuren auf einer Autobahn vorstellen. Anstatt dass jede einzelne Transaktion über das Ethereum Mainnet läuft, nutzen viele von ihnen diese schnelleren, günstigeren Wege.",
+ "page-what-is-ethereum-network-layer-2s-section-description-4": "Einige der beliebtesten L2s sind Base, Arbitrum, Optimism, zkSync und Starknet. Jedes von ihnen funktioniert etwas anders, aber die Idee ist dieselbe – Ethereum zu skalieren, ohne die Sicherheit zu beeinträchtigen.",
+ "page-what-is-ethereum-network-layer-2s-section-description-5": "Ein einfacher ETH-Transfer auf Optimism oder zkSync kann nur 0,04 $ kosten , verglichen mit 0,3–1 $ auf dem Ethereum Mainnet. Andere Transaktionen wie das Tauschen von Tokens können nur 0,20 $ kosten . Für Benutzer bedeutet dies schnellere Transaktionen zu einem Bruchteil des Preises.",
+ "page-what-is-ethereum-network-layer-2s-section-description-6": "Infolgedessen wachsen L2s schnell. Zusammen halten sie digitale Vermögenswerte im Wert von Milliarden von Dollar .",
+ "page-what-is-ethereum-network-layer-2s-section-description-7": "Da L2s von der Sicherheit von Ethereum profitieren, haben Unternehmen, die globale Zahlungen und Anwendungen erstellen möchten, begonnen, auf Ethereum aufzubauen.",
+ "page-what-is-ethereum-network-layer-2s-section-description-8": "Zum Beispiel hat Robinhood kürzlich seine eigene L2 gestartet , um eine schnellere Abwicklung von Aktien zu erforschen. PayPal hat seinen Stablecoin PYUSD auf die Ethereum L2 Arbitrum verschoben . Shopify ermöglicht es Händlern jetzt, den Stablecoin USDC auf Base zu akzeptieren.",
+ "page-what-is-ethereum-network-layer-2s-section-description-9": "Für Benutzer ist das Verschieben von Vermögenswerten zwischen Ethereum und L2s unkompliziert. Sie können kettenübergreifende Brücken verwenden, die von L2s wie Superbridge von Optimism oder Portal von ZKsync gebaut wurden, um ETH und andere Vermögenswerte zu verschieben. Sie können sogar Tools von Drittanbietern wie Hop und Across verwenden, die von unabhängigen Teams entwickelt werden.",
+ "page-what-is-ethereum-network-layer-2s-section-description-10": "Erfahren Sie mehr über Ethereum Layer-2-Netzwerke",
+ "page-what-is-ethereum-network-live-network-data-section-description-1": "Ethereum ist von Natur aus transparent. Jede Aktion im Netzwerk, vom Senden von ETH bis zum Betreiben eines Validators, wird in einem offenen, öffentlichen Hauptbuch aufgezeichnet, auf das jeder zugreifen kann.",
+ "page-what-is-ethereum-network-live-network-data-section-description-2": "Dies steht in scharfem Kontrast zur heutigen Funktionsweise der meisten Systeme:",
+ "page-what-is-ethereum-network-live-network-data-section-description-3": "Banken und Institutionen veröffentlichen ihre internen Zahlen",
+ "page-what-is-ethereum-network-live-network-data-section-description-4": "App-Nutzungszahlen werden von Technologieunternehmen streng gehütet",
+ "page-what-is-ethereum-network-live-network-data-section-description-5": "Wirtschaftsdaten kommen oft zu spät an und werden später revidiert",
+ "page-what-is-ethereum-network-live-network-data-section-description-6": "Bei Ethereum müssen Sie nicht vertrauen. Sie können verifizieren.",
+ "page-what-is-ethereum-network-live-network-data-section-description-7": "Sie müssen nichts davon verstehen, um Ethereum zu nutzen. Aber wenn Sie neugierig sind, wie viele Transaktionen im Jahr 2024 abgewickelt wurden oder wie viele neue Ethereum-Adressen in den letzten sechs Monaten erstellt wurden, gibt es Tools, mit denen jeder das Netzwerk in Echtzeit erkunden kann.",
+ "page-what-is-ethereum-network-live-network-data-section-description-8": "Hier sind einige der nützlichsten Datenquellen und wofür Sie sie verwenden könnten:",
+ "page-what-is-ethereum-network-live-network-data-section-description-9": "Etherscan : Überprüfen Sie Transaktionen, Wallet-Aktivitäten und Smart Contracts",
+ "page-what-is-ethereum-network-live-network-data-section-description-10": "beaconcha.in : Sehen Sie sich Validator-Statistiken, Staking-Levels und den Netzwerkzustand an",
+ "page-what-is-ethereum-network-live-network-data-section-description-11": "ultrasound.money : Verfolgen Sie das ETH-Angebot, die Emission und das Verbrennen in Echtzeit",
+ "page-what-is-ethereum-network-live-network-data-section-description-12": "l2fees.info : Vergleichen Sie die aktuellen Transaktionskosten auf Ethereum und L2s",
+ "page-what-is-ethereum-network-live-network-data-section-description-13": "L2Beat : Sehen Sie den gesicherten Wert und die Sicherheitsmodelle aller wichtigen L2s",
+ "page-what-is-ethereum-network-live-network-data-section-description-14": "growthepie : Sehen Sie alle On-Chain-Aktivitäten und das Wachstum auf Ethereum",
+ "page-what-is-ethereum-network-live-network-data-section-description-15": "Dune : Erkunden Sie benutzerdefinierte Dashboards zu allen digitalen Vermögenswerten auf Ethereum",
+ "page-what-is-ethereum-network-live-network-data-section-description-16": "Token Terminal : Vergleichen Sie Dapp-Einnahmen, Nutzung und Protokollleistung",
+ "page-what-is-ethereum-network-live-network-data-section-description-17": "Nansen : Verfolgen Sie Wallet-Flüsse, Stablecoin-Bewegungen und Smart-Money-Trends.",
+ "page-what-is-ethereum-network-live-network-data-section-description-18": "Alle diese Tools stehen Ihnen bei Bedarf zur Verfügung.",
+ "page-what-is-ethereum-network-live-network-data-section-description-19": "Egal, ob Sie Entwickler, Forscher, Investor oder einfach nur jemand sind, der eine Transaktion überprüfen möchte, das offene Netzwerk von Ethereum liefert Ihnen die Daten – live, genehmigungsfrei und verifizierbar.",
+ "page-what-is-ethereum-network-live-network-data-section-description-20": "Durchsuchen Sie Ethereum-Netzwerk-Dashboards und Block-Explorer"
+}
\ No newline at end of file
diff --git a/src/intl/de/table.json b/src/intl/de/table.json
index e7ac99e4b59..a6c0053440c 100644
--- a/src/intl/de/table.json
+++ b/src/intl/de/table.json
@@ -1,7 +1,7 @@
{
- "table-active": "aktiv",
+ "table-active": "Aktiv",
"table-filters": "Filter",
- "table-showing": "Zeigen",
+ "table-showing": "Angezeigt",
"table-reset-filters": "Zurücksetzen",
"table-what-are-you-looking-for": "Was suchen Sie?"
}
\ No newline at end of file
diff --git a/src/intl/de/template-usecase.json b/src/intl/de/template-usecase.json
index 2c62ffdd27e..c6362b4b2c1 100644
--- a/src/intl/de/template-usecase.json
+++ b/src/intl/de/template-usecase.json
@@ -1,13 +1,20 @@
{
+ "template-usecase-dropdown-ai-agents": "KI-Agenten",
"template-usecase-dropdown-defi": "Dezentrales Finanzwesen (DeFi)",
"template-usecase-dropdown-nft": "Non-fungible Token (NFTs)",
- "template-usecase-dropdown-dao": "Dezentrale autonome Organisationen (DAO)",
+ "template-usecase-dropdown-dao": "Dezentrale autonome Organisationen (DAOs)",
+ "template-usecase-dropdown-apps": "Ethereum-Anwendungen",
+ "template-usecase-dropdown-payments": "Ethereum-Zahlungen",
+ "template-usecase-dropdown-prediction-markets": "Prognosemärkte",
"template-usecase-dropdown-social-networks": "Dezentrale soziale Netzwerke",
+ "template-usecase-dropdown-restaking": "Restaking",
"template-usecase-dropdown-identity": "Dezentralisierte Identität",
"template-usecase-dropdown-desci": "Dezentrale Wissenschaft (DeSci)",
"template-usecase-dropdown-refi": "Regenerative Finanzen (ReFi)",
"template-usecase-dropdown": "Ethereum-Anwendungsfälle",
"template-usecase-banner": "Die Verwendung von Ethereum entwickelt sich ständig weiter. Fügen Sie alle Informationen hinzu, die die Dinge klarer machen oder aktueller darstellen.",
"template-usecase-edit-link": "Seite bearbeiten",
- "template-usecase-dropdown-aria": "Anwendungsfall-Dropdown-Menü"
+ "template-usecase-dropdown-aria": "Anwendungsfall-Dropdown-Menü",
+ "template-usecase-dropdown-onchain-gaming": "Onchain-Gaming",
+ "template-usecase-dropdown-rwa": "Real wertige Vermögenswerte (RWAs)"
}
From b9aba8956c63d8f23383f093ed2b6093796d60e9 Mon Sep 17 00:00:00 2001
From: wackerow <54227730+wackerow@users.noreply.github.com>
Date: Sat, 24 Jan 2026 12:20:19 -0500
Subject: [PATCH 2/9] i18n(de): JSX attribute translations
---
.../translations/de/ai-agents/index.md | 6 ++--
.../translatathon/index.md | 12 +++----
.../translations/de/ethereum-forks/index.md | 36 +++++++++----------
.../de/guides/how-to-id-scam-tokens/index.md | 6 ++--
.../content/translations/de/payments/index.md | 6 ++--
.../de/prediction-markets/index.md | 6 ++--
.../de/real-world-assets/index.md | 12 +++----
.../de/roadmap/danksharding/index.md | 12 +++----
.../translations/de/roadmap/merge/index.md | 18 +++++-----
.../de/roadmap/merge/issuance/index.md | 2 +-
.../translations/de/roadmap/pbs/index.md | 4 +--
.../de/roadmap/single-slot-finality/index.md | 2 +-
.../de/roadmap/statelessness/index.md | 2 +-
.../de/roadmap/verkle-trees/index.md | 4 +--
.../translations/de/staking/pools/index.md | 12 +++----
.../translations/de/staking/saas/index.md | 14 ++++----
.../translations/de/staking/solo/index.md | 32 ++++++++---------
.../de/staking/withdrawals/index.md | 4 +--
.../translations/de/what-are-apps/index.md | 12 +++----
.../translations/de/wrapped-eth/index.md | 8 ++---
20 files changed, 105 insertions(+), 105 deletions(-)
diff --git a/public/content/translations/de/ai-agents/index.md b/public/content/translations/de/ai-agents/index.md
index 4606aef4bd4..dec287cde4f 100644
--- a/public/content/translations/de/ai-agents/index.md
+++ b/public/content/translations/de/ai-agents/index.md
@@ -40,9 +40,9 @@ Im Gegensatz dazu bietet das dezentrale Ökosystem von Ethereum mehrere entschei
Diese Faktoren verwandeln KI-Agenten von einfachen Bots in dynamische, sich selbst verbessernde Systeme, die in verschiedenen Sektoren einen erheblichen Mehrwert bieten:
-
## Verifizierbare KI {#verifiable-ai}
diff --git a/public/content/translations/de/contributing/translation-program/translatathon/index.md b/public/content/translations/de/contributing/translation-program/translatathon/index.md
index a04a929237a..80e88842b7e 100644
--- a/public/content/translations/de/contributing/translation-program/translatathon/index.md
+++ b/public/content/translations/de/contributing/translation-program/translatathon/index.md
@@ -7,18 +7,18 @@ template: Translatathon
diff --git a/public/content/translations/de/ethereum-forks/index.md b/public/content/translations/de/ethereum-forks/index.md
index ea9a5609f46..793aa8b62f1 100644
--- a/public/content/translations/de/ethereum-forks/index.md
+++ b/public/content/translations/de/ethereum-forks/index.md
@@ -9,7 +9,7 @@ sidebarDepth: 1
Ein Zeitstrang aller wichtigsten Meilensteine, Forks und Aktualisierungen der Ethereum-Blockchain.
-
+
Forks entstehen, wenn wichtige technische Neuerungen oder Änderungen am Netzwerk vorgenommen werden müssen. Sie stammen in der Regel von den [Ethereum-Verbesserungsvorschlägen (EIPs)](/eips) ab und verändern die "Richtlinien" des Protokolls.
@@ -19,7 +19,7 @@ Diese Regeländerungen können eine vorübergehende Spaltung des Netzwerks verur
-
+
Die Software, die Ethereum zugrunde liegt, besteht aus zwei Hälften, der sogenannten [Ausführungsschicht](/glossary/#execution-layer) und der [Konsensschicht](/glossary/#consensus-layer).
@@ -89,7 +89,7 @@ Das Staking erhielt ein Upgrade durch zusammengesetzte Validator-Konten und verb
Weitere Teile des Upgrades konzentrierten sich darauf, das Erlebnis für reguläre Nutzer zu verbessern. EIP-7702 brachte die Möglichkeit für ein reguläres Konto ohne Smart Contract ([EOA](/glossary/#eoa)), Code ähnlich wie ein Smart Contract auszuführen. Dies eröffnete völlig neue Möglichkeiten für traditionelle Ethereum-Konten, wie z. B. das Bündeln von Transaktionen, Gas-Sponsoring, alternative Authentifizierungsverfahren, programmierbare Ausgabekontrollen, Mechanismen zur Kontowiederherstellung und vieles mehr.
-
+
Bessere Benutzererfahrung:
@@ -138,7 +138,7 @@ Das Cancun-Upgrade enthält eine Reihe von Verbesserungen an der _Ausführung_ v
Insbesondere enthält es EIP-4844, bekannt als **Proto-Danksharding**, das die Kosten für die Datenspeicherung für Layer-2-Rollups erheblich senkt. Dies wird durch die Einführung von Daten-„Blobs“ erreicht, die es Rollups ermöglichen, Daten für einen kurzen Zeitraum im Mainnet zu veröffentlichen. Dies führt zu deutlich geringeren Transaktionsgebühren für Nutzer von Layer-2-Rollups.
-
+
- EIP-1153 – Transiente Speicher-Opcodes
@@ -164,7 +164,7 @@ Vorgenerierte, signierte „freiwillige Exit-Nachrichten“ laufen nicht mehr ab
EIP-7514 führt zu einer Verschärfung der ETH-Ausgabe, indem die „Churn“-Rate, mit der Validierer dem Netzwerk beitreten können, auf acht (8) pro Epoche begrenzt wird. Da die ETH-Emission proportional zur Gesamtzahl der gestaketen ETH ist, begrenzt die Begrenzung der Anzahl der beitretenden Validatoren die _Wachstumsrate_ der neu emittierten ETH, während gleichzeitig die Hardwareanforderungen für Node-Betreiber reduziert werden, was die Dezentralisierung fördert.
-
+
- EIP-4788 – Beacon-Block-Root im EVM
@@ -191,7 +191,7 @@ EIP-7514 führt zu einer Verschärfung der ETH-Ausgabe, indem die „Churn“-Ra
Das Shanghai-Update ebnete den Weg für Staking-Auszahlungen auf der Ausführungsebene. Die Fusion mit dem Capella-Upgrade ermöglichte es Blöcken, Auszahlungen zu akzeptieren, wodurch Stakern erlaubt wurde, ihre ETH von der Beacon Chain auf der Ausführungsebene abzuheben.
-
+
- EIP-3651 – Führt die
COINBASE-Adresse ein
@@ -230,7 +230,7 @@ Das Paris-Upgrade wurde ausgelöst, als die Proof-of-Work-Blockchain eine [termi
- [Lesen Sie die Paris-Upgrade-Spezifikation](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/paris.md)
-
+
- EIP-3675 – Ermöglicht den Übergang des Ethereum-Netzwerks vom Konsensmechanismus Proof-of-Work (PoW) zum Proof-of-Stake (PoS).
@@ -263,7 +263,7 @@ Das Gray Glacier-Netzwerk-Upgrade hat die [Schwierigkeitsbombe](/glossary/#diffi
- [EF Blog – Ankündigung des Gray-Glacier-Upgrades](https://blog.ethereum.org/2022/06/16/gray-glacier-announcement/)
-
+
- EIP-5133 – Verzögert die Explosion der Schwierigkeitsbombe bis Ende September 2022
@@ -286,7 +286,7 @@ Das Arrow-Glacier-Netzwerk-Upgrade verschob die [Schwierigkeitsbombe](/glossary/
- [EF Blog – Ankündigung des Arrow-Glacier-Upgrades](https://blog.ethereum.org/2021/11/10/arrow-glacier-announcement/)
- [Ethereum Cat Herders – Ethereum-Arrow-Glacier-Upgrade](https://medium.com/ethereum-cat-herders/ethereum-arrow-glacier-upgrade-e8d20fa4c002)
-
+
- EIP-4345 – verzögert die Schwierigkeitsbombe bis Juni 2022
@@ -340,7 +340,7 @@ Dieses Video erklärt EIP-1559 und die Vorteile, die es mit sich bringt: [EIP-15
- [Lesen Sie die Ankündigung der Ethereum Foundation](https://blog.ethereum.org/2021/07/15/london-mainnet-announcement/)
- [Lesen Sie die Erklärung der Ethereum Cat Herders](https://medium.com/ethereum-cat-herders/london-upgrade-overview-8eccb0041b41)
-
+
- EIP-1559 – trägt zur Verbesserung der Marktbedingungen bei und senkt gleichzeitig die Transaktionsgebühren
@@ -365,7 +365,7 @@ Mit dem Berliner Upgrade wurden die Gaskosten für bestimmte EVM-Aktionen optimi
- [Lesen Sie die Ankündigung der Ethereum Foundation](https://blog.ethereum.org/2021/03/08/ethereum-berlin-upgrade-announcement/)
- [Lesen Sie die Erklärung der Ethereum Cat Herders](https://medium.com/ethereum-cat-herders/the-berlin-upgrade-overview-2f7ad710eb80)
-
+
- EIP-2565 – senkt die Gaskosten für ModExp
@@ -423,7 +423,7 @@ Der Muir-Glacier-Fork führte eine Verzögerung der [Schwierigkeitsbombe](/gloss
- [Lesen Sie die Ankündigung der Ethereum Foundation](https://blog.ethereum.org/2019/12/23/ethereum-muir-glacier-upgrade-announcement/)
- [Lesen Sie die Erklärung der Ethereum Cat Herders](https://medium.com/ethereum-cat-herders/ethereum-muir-glacier-upgrade-89b8cea5a210)
-
+
- EIP-2384 – verzögert die Schwierigkeitsbombe um weitere 4.000.000 Blöcke, oder etwa 611 Tage.
@@ -451,7 +451,7 @@ Die Istanbul-Abspaltung:
[Lesen Sie die Ankündigung der Ethereum Foundation](https://blog.ethereum.org/2019/11/20/ethereum-istanbul-upgrade-announcement/)
-
+
- EIP-152 – ermöglicht es dem Ethereum-Netzwerk, mit anonymen Währungen wie Zcash zu arbeiten, wodurch das Recht auf Privatsphäre geschützt werden kann.
@@ -482,7 +482,7 @@ Die Constantinople-Fork:
[Lesen Sie die Ankündigung der Ethereum Foundation](https://blog.ethereum.org/2019/02/22/ethereum-constantinople-st-petersburg-upgrade-announcement/)
-
+
- EIP-145 – optimiert die Kosten bestimmter Aktionen auf der Blockchain.
@@ -512,7 +512,7 @@ Die Byzantium-Fork:
[Lesen Sie die Ankündigung der Ethereum Foundation](https://blog.ethereum.org/2017/10/12/byzantium-hf-announcement/)
-
+
- EIP-140 – integriert den Operationscode
REVERT.
@@ -546,7 +546,7 @@ Die Spurious-Dragon-Fork war die zweite Reaktion auf die Denial-of-Service(DoS)-
[Lesen Sie die Ankündigung der Ethereum Foundation](https://blog.ethereum.org/2016/11/18/hard-fork-no-4-spurious-dragon/)
-
+
- EIP-155 – verhindert, dass Transaktionen von einer Ethereum-Blockchain wieder auf einer alternativen Blockchain gesendet werden. Beispiel: Eine Testnetz-Transaktion, die auf der Ethereum Haupt-Blockchain wiedergegeben wird.
@@ -571,7 +571,7 @@ Die Tangerine-Whistle-Fork war die erste Reaktion auf die Denial-of-Service(DoS)
[Lesen Sie die Ankündigung der Ethereum Foundation](https://blog.ethereum.org/2016/10/18/faq-upcoming-ethereum-hard-fork/)
-
+
- EIP-150 – erhöht die Gaskosten der Verfahrenscodes, die bei Spam-Attacken verwendet werden können.
@@ -608,7 +608,7 @@ Die Homestead-Abspaltung, die in die Zukunft schaute. Sie enthielt mehrere Proto
[Lesen Sie die Ankündigung der Ethereum Foundation](https://blog.ethereum.org/2016/02/29/homestead-release/)
-
+
- EIP-2 – ermöglicht es Bearbeitungen bei der Entwicklung von Smart Contracts vorzunehmen.
diff --git a/public/content/translations/de/guides/how-to-id-scam-tokens/index.md b/public/content/translations/de/guides/how-to-id-scam-tokens/index.md
index f0dca647514..6e729d28045 100644
--- a/public/content/translations/de/guides/how-to-id-scam-tokens/index.md
+++ b/public/content/translations/de/guides/how-to-id-scam-tokens/index.md
@@ -16,7 +16,7 @@ Die beiden folgenden Täuschungsversuche sind dabei gängig:
Um zu veranschaulichen, was Scam-Tokens sind und wie man sie erkennt, sehen wir uns ein Beispiel an: [`wARB`](https://eth.blockscout.com/token/0xB047c8032b99841713b8E3872F06cF32beb27b82). Dieser Token versucht, wie der legitime [`ARB`](https://eth.blockscout.com/address/0xb50721bcf8d664c30412cfbc6cf7a15145234ad1)-Token auszusehen.
Arbitrum ist eine Organisation, die [Optimistic Rollups](/developers/docs/scaling/optimistic-rollups/) entwickelt und verwaltet. Ursprünglich war Arbitrum als gewinnorientiertes Unternehmen organisiert, unternahm dann aber Schritte zur Dezentralisierung. Als Teil dieses Prozesses haben sie einen handelbaren [Governance-Token](/dao/#token-based-membership) ausgegeben.
@@ -24,7 +24,7 @@ Arbitrum ist eine Organisation, die [Optimistic Rollups](/developers/docs/scalin
In Ethereum gibt es eine Konvention: Wird ein Asset erstellt, das nicht ERC-20-kompatibel ist, wird eine " Wrapped"-Version erstellt wird, deren Name mit "w" beginnt. So gibt es beispielsweise wBTC für Bitcoin und wETH für Ether.
@@ -38,7 +38,7 @@ Es ergibt keinen Sinn, eine Wrapped-Version eines ERC-20-Tokens zu erstellen, de
Dezentralisierung ist das zentrale Element von Ethereum. Das bedeutet, dass es keine zentrale Autorität gibt, die Ihre Anlagen konfiszieren oder Sie daran hindern könnte, einen Smart Contract bereitzustellen. Doch das bedeutet auch, dass Betrüger jeden beliebigen Smart Contract bereitstellen können.
[Smart Contracts](/developers/docs/smart-contracts/) sind die Programme, die auf der Ethereum-Blockchain ausgeführt werden. Jeder ERC-20 Token ist beispielsweise als Smart Contract implementiert.
diff --git a/public/content/translations/de/payments/index.md b/public/content/translations/de/payments/index.md
index abba18cac14..90a42389b02 100644
--- a/public/content/translations/de/payments/index.md
+++ b/public/content/translations/de/payments/index.md
@@ -28,9 +28,9 @@ Dies ist kein ferner Traum – es geschieht heute auf Ethereum. Obwohl tradition
Für Millionen von Menschen, die im Ausland arbeiten, ist es eine regelmäßige Notwendigkeit, Geld nach Hause zu schicken. Traditionelle Überweisungsdienste sind oft mit hohen Gebühren und langen Bearbeitungszeiten verbunden. Ethereum bietet eine überzeugende Alternative.
-
## Zugang zu globalen Währungen {#access-to-global-currencies}
diff --git a/public/content/translations/de/prediction-markets/index.md b/public/content/translations/de/prediction-markets/index.md
index d77664be814..2058e16bd83 100644
--- a/public/content/translations/de/prediction-markets/index.md
+++ b/public/content/translations/de/prediction-markets/index.md
@@ -30,9 +30,9 @@ Theoretisch können Prognosemärkte aufgrund der Gewinnchancen für korrekte Vor
Im Gegensatz zu herkömmlichen Prognoseverfahren bieten blockchainbasierte Prognosemärkte unter anderem Folgendes:
-
Selbst als Beobachter\*in des Marktes können Sie wertvolle Daten auswerten, die Ihnen andernfalls nicht zugänglich wären. Stellen Sie sich das so vor:
diff --git a/public/content/translations/de/real-world-assets/index.md b/public/content/translations/de/real-world-assets/index.md
index d905e083e97..8a83ac2e000 100644
--- a/public/content/translations/de/real-world-assets/index.md
+++ b/public/content/translations/de/real-world-assets/index.md
@@ -28,12 +28,12 @@ RWA-Token haben keinen inneren Wert. Sie spiegeln vielmehr den Wert des Gegensta
## Was sind die Vorteile von RWAs? {#rwas-benefits}
-
## Wie funktionieren RWAs? {#how-rwas-work}
diff --git a/public/content/translations/de/roadmap/danksharding/index.md b/public/content/translations/de/roadmap/danksharding/index.md
index b3cdfef89c7..ea39ade36f7 100644
--- a/public/content/translations/de/roadmap/danksharding/index.md
+++ b/public/content/translations/de/roadmap/danksharding/index.md
@@ -19,13 +19,13 @@ Proto-Danksharding, auch bekannt als [EIP-4844](https://eips.ethereum.org/EIPS/e
Das ist teuer, weil die Daten von allen Ethereum-Nodes verarbeitet werden und für immer onchain bleiben, obwohl Rollups die Daten nur für kurze Zeit benötigen. Proto-Danksharding führt Datenblobs ein, die versendet und an Blöcke angehängt werden können. Die Daten in diesen Blobs sind für die EVM nicht zugänglich und werden nach einer festgelegten Zeitspanne (zum Zeitpunkt der Erstellung dieses Dokuments 4.096 Epochen, also etwa 18 Tage) automatisch gelöscht. Das bedeutet, dass Rollups ihre Daten sehr viel kostengünstiger versenden und die Einsparungen in Form von günstigeren Transaktionen an die Endbenutzer weitergeben können.
-
+
Rollups sind eine Möglichkeit, Ethereum zu skalieren, indem Transaktionen offchain gebatcht und die Ergebnisse dann auf Ethereum gepostet werden. Ein Rollup besteht im Wesentlichen aus zwei Teilen: Daten und Ausführungsprüfung. Die Daten sind die vollständige Abfolge von Transaktionen, die von einem Rollup verarbeitet werden, um die Zustandsänderung zu erzeugen, die zu Ethereum gepostet wird. Die Ausführungsprüfung ist die Wiederholung dieser Transaktionen durch einen ehrlichen Akteur (einen "Prover"), um sicherzustellen, dass die vorgeschlagene Zustandsänderung korrekt ist. Um die Ausführungsprüfung durchführen zu können, müssen die Transaktionsdaten lange genug verfügbar sein, damit sie von jedem heruntergeladen und überprüft werden können. Das bedeutet, dass jedes unehrliche Verhalten des Rollup-Sequenzierers vom Beweiser erkannt und herausgefordert werden kann. Allerdings muss es nicht für immer verfügbar sein.
-
+
Rollups veröffentlichen onchain Commitments zu ihren Transaktionsdaten und stellen die eigentlichen Daten in Daten-Blobs zur Verfügung. Das bedeutet, dass Beweiser überprüfen können, ob die Verpflichtungen gültig sind, oder Daten herausfordern können, von denen sie glauben, dass sie falsch sind. Auf Node-Ebene werden die Datenblobs im Konsens-Client gehalten. Die Konsens-Clients bezeugen, dass sie die Daten gesehen haben und dass sie im Netzwerk verbreitet wurden. Wenn die Daten für immer aufbewahrt würden, würden diese Clients aufgebläht und zu hohen Hardwareanforderungen für den Betrieb von Nodes führen. Stattdessen werden die Daten alle 18 Tage automatisch aus dem Node gelöscht. Die Beglaubigungen des Konsens-Clients belegen, dass Beweisende ausreichend Gelegenheit hatten, die Daten zu überprüfen. Die eigentlichen Daten können von Rollup-Betreibern, Benutzern oder anderen offchain gespeichert werden.
@@ -45,13 +45,13 @@ Die KZG-Zeremonie war eine Möglichkeit für viele Menschen aus der Ethereum-Com
Die EIP-4844 KZG-Zeremonie war für die Öffentlichkeit zugänglich. Zehntausende Menschen nahmen daran teil und fügten ihre eigene Entropie (Zufälligkeit) hinzu. Insgesamt gab es über 140.000 Beiträge, wodurch sie zur weltweit größten Zeremonie dieser Art wurde. Damit die Zeremonie untergraben wird, müssten 100% dieser Teilnehmer aktiv unehrlich sein. Aus der Sicht der Teilnehmer besteht, sofern sie wissen, dass sie ehrlich waren, keine Notwendigkeit, jemand anderem zu vertrauen. Sie haben durch ihre Ehrlichkeit selbst die Sicherheit der Zeremonie gewährleistet und die Anforderung erfüllt, dass mindestens einer von N Teilnehmern ehrlich sein muss.
-
+
Wenn ein Rollup Daten in einem Blob postet, stellt es ein "Commitment" zur Verfügung, das onchain gepostet wird. Dieses Commitment ist das Ergebnis der Auswertung eines an die Daten angepassten Polynoms an bestimmten Punkten. Diese Punkte werden durch die in der KZG-Zeremonie erzeugten Zufallszahlen definiert. Beweiser können dann das Polynom an denselben Punkten auswerten, um die Daten zu überprüfen - wenn sie zu denselben Werten kommen, dann sind die Daten korrekt.
-
+
Wenn jemand die zufälligen Stellen kennt, die für das Commitment verwendet werden, ist es einfach, ein neues Polynom zu erzeugen, das an diesen spezifischen Punkten passt (d. h. eine "Kollision"). Das bedeutet, sie könnten Daten zum Blob hinzufügen oder daraus entfernen und dennoch einen gültigen Nachweis liefern. Um dies zu verhindern, erhalten die Beweiser statt der tatsächlichen geheimen Positionen diese Positionen eingehüllt in eine kryptographische "Black Box" unter Verwendung elliptischer Kurven. Diese verzerren die Werte effektiv auf eine Weise, dass die ursprünglichen Werte nicht rückentwickelt werden können, aber mit einiger cleverer Algebra können Beweiser und Verifizierer immer noch Polynome an den Punkten auswerten, die sie repräsentieren.
@@ -67,13 +67,13 @@ Danksharding ist die vollständige Realisierung der Rollup-Skalierung, die mit P
Dies funktioniert, indem die an die Blöcke angehängten Blobs von sechs (6) bei Proto-Danksharding auf 64 bei vollem Danksharding erweitert werden. Der Rest der benötigten Änderungen betrifft alle Updates in der Funktionsweise der Konsens-Clients, um sie in die Lage zu versetzen, die neuen großen Blobs zu verarbeiten. Mehrere dieser Änderungen sind bereits unabhängig von Danksharding aus anderen Gründen auf der Roadmap. Zum Beispiel erfordert Danksharding, dass die Trennung von Proposer und Builder implementiert wurde. Dies ist ein Upgrade, das die Aufgaben des Erstellens und Vorschlagens von Blöcken auf verschiedene Validierer verteilt. Ebenso ist Datenverfügbarkeitsstichproben für Danksharding erforderlich, aber sie sind auch für die Entwicklung von sehr leichtgewichtigen Clients erforderlich, die nicht viele historische Daten speichern ("zustandslose Clients").
-
+
Die Trennung von Vorschlagenden und Erstellenden ist notwendig, um zu verhindern, dass einzelne Validatoren teure Verpflichtungen und Nachweise für 32MB Blob-Daten erzeugen müssen. Dies würde zu einer zu großen Belastung für Heim-Staker führen und sie dazu zwingen, in leistungsfähigere Hardware zu investieren, was die Dezentralisierung beeinträchtigen würde. Stattdessen übernehmen spezialisierte Blockersteller die Verantwortung für diese aufwändige Rechenarbeit. Dann stellen sie ihre Blöcke den Blockvorschlägern zur Verfügung, um sie zu senden. Der Blockvorschläger wählt einfach den Block aus, der am rentabelsten ist. Jeder kann die Blobs kostengünstig und schnell überprüfen, was bedeutet, dass jeder normale Validator überprüfen kann, ob die Blockersteller ehrlich handeln. Dies ermöglicht die Verarbeitung der großen Blobs, ohne die Dezentralisierung zu opfern. Block Builder, die sich schlecht verhalten, könnten einfach aus dem Netzwerk geworfen und bestraft werden - andere würden ihren Platz einnehmen, weil Block Building eine profitable Tätigkeit ist.
-
+
Validators only have to download a small piece of each blob in order to verify its availability, rather than the entire thing. Mithilfe des Data Availability Samplings können die Validatoren sehr sicher sein, dass die Blob-Daten verfügbar waren und korrekt bestätigt wurden. Jeder Validator kann zufällig nur einige Datenpunkte abrufen und einen Nachweis erstellen, was bedeutet, dass kein Validator den gesamten Blob überprüfen muss. Fehlen irgendwelche Daten, wird dies schnell erkannt und der Blob abgelehnt.
diff --git a/public/content/translations/de/roadmap/merge/index.md b/public/content/translations/de/roadmap/merge/index.md
index 9925b4ef1b5..56eee057a37 100644
--- a/public/content/translations/de/roadmap/merge/index.md
+++ b/public/content/translations/de/roadmap/merge/index.md
@@ -58,8 +58,8 @@ Trotz des Austauschs von Proof-of-Work blieb die gesamte Geschichte von Ethereum
### Node-Betreiber und Dapp-Entwickler {#node-operators-dapp-developers}
Zu den Schlüsselaktionen gehören:
@@ -73,8 +73,8 @@ Wenn Sie die ersten beiden obigen Elemente nicht abschließen, wird Ihre Node al
Wenn kein "Gebührenempfänger" gesetzt wird, kann sich dein Validator wie üblich verhalten, aber Sie werden auf unverbrannte Gebührentipps verzichten und alle MEV, die Sie sonst in Blöcken verdient hätten, die Ihr Validator vorschlägt.
Bis zum Merge reichte ein Client (wie Geth, Erigon, Besu oder Nethermind) aus, um ihn zu empfangen, validieren und Blöcke verbreiten, die vom Netzwerk vorgeschlagen werden. _Nach dem Merge_, ist die Gültigkeit von Transaktionen, die innerhalb einer ausführbaren Nutzlast enthalten sind, jetzt auch von der Gültigkeit des "Konsensblocks" abhängig, in dem er enthalten ist.
@@ -91,8 +91,8 @@ Wenn Sie die ersten beiden obigen Elemente nicht abschließen, wird Ihre Node al
The Merge trat ein, indem es Änderungen an der Konsens-Methode mit sich brachte, darunter Änderungen an:
@@ -138,7 +138,7 @@ Die Möglichkeit für jeden, einen eigenen Node zu betreiben, ist absolut es
Die Gasgebühren sind ein Produkt der Netznachfrage im Verhältnis zur Netzkapazität. Der Merge veraltete den Einsatz von Proof-of-Work für den Übergang zu Proof-of-Stake als Konsens, aber keine signifikante Änderung von Parametern, die direkt Einfluss auf Netzwerk-Kapazität oder Durchsatz haben.
@@ -159,8 +159,8 @@ Proof-of-Stake führte das bisher nicht existierende Konzept der Transaktionsfin
+title="Missverständnis: "Die Zusammenführung hat Staking-Auszahlungen ermöglicht.""
+contentPreview="Falsch, aber Staking-Auszahlungen wurden seitdem durch das Shanghai/Capella-Upgrade ermöglicht.">
Nach dem Zusammenführen hatten die Staker zunächst nur Zugriff auf Gebührentipps und MEV, die durch Blockvorschläge verdient wurden. Diese Belohnungen werden auf einem von Validatoren kontrollierten Konto gutgeschrieben, das nicht zum Einsatz kommt (bekannt als die Gebührenempfänger), und sind sofort verfügbar. Diese Belohnungen sind von den Protokollbelohnungen für die Erfüllung der Pflichten von Validatoren getrennt.
diff --git a/public/content/translations/de/roadmap/merge/issuance/index.md b/public/content/translations/de/roadmap/merge/issuance/index.md
index 87b8b28e727..35ab26c04ed 100644
--- a/public/content/translations/de/roadmap/merge/issuance/index.md
+++ b/public/content/translations/de/roadmap/merge/issuance/index.md
@@ -16,7 +16,7 @@ Die **Emission** von ETH ist der Prozess, bei dem ETH geschaffen wird, das zuvor
+title="ETH-Emission kurz erklärt">
- Vor dem Übergang zu Proof-of-Stake betrug die Emission für Miner ungefähr 13.000 ETH/Tag.
- Die Emission für Staker beträgt ungefähr 1.700 ETH/Tag, basierend auf insgesamt etwa 14 Millionen gestaketen ETH.
diff --git a/public/content/translations/de/roadmap/pbs/index.md b/public/content/translations/de/roadmap/pbs/index.md
index ab96a995f90..a5f0b4ea8a5 100644
--- a/public/content/translations/de/roadmap/pbs/index.md
+++ b/public/content/translations/de/roadmap/pbs/index.md
@@ -18,7 +18,7 @@ Ein Beispiel hierfür sind Einschlusslisten, die verwendet werden können, damit
[Verschlüsselte Mempools](https://www.youtube.com/watch?v=fHDjgFcha0M&list=PLpktWkixc1gUqkyc1-iE6TT0RWQTBJELe&index=3) könnten es für Builder und Proposer auch unmöglich machen zu wissen, welche Transaktionen sie in einen Block aufnehmen, bis der Block bereits verbreitet wurde.
-
+
Einflussreiche Organisationen können Validatoren dazu drängen, Transaktionen zu zensieren, die von oder zu bestimmten Adressen erfolgen. Die Validatoren geben diesem Druck nach, indem sie Adressen auf der schwarzen Liste in ihrem Transaktionspool erkennen und sie auf den von ihnen vorgeschlagenen Blöcken auslassen. Nach der Einführung von PBS wird dies nicht mehr möglich sein, da Block-Vorschlagende nicht mehr wissen werden, welche Transaktionen sie in ihren Blöcken übertragen. Für bestimmte Personen oder Anwendungen könnte es wichtig sein, die Zensurvorschriften einzuhalten, z. B. wenn sie in ihrer Region gesetzlich vorgeschrieben sind. In solchen Fällen erfolgt die Einhaltung auf Anwendungsebene, während das Protokoll weiterhin erlaubnis- und zensurfrei bleibt.
@@ -30,7 +30,7 @@ Einflussreiche Organisationen können Validatoren dazu drängen, Transaktionen z
Das PBS löst dieses Problem, indem es die Wirtschaftlichkeit von MEV neu konfiguriert. Anstatt dass der Blockvorschlager selbst nach MEV-Möglichkeiten sucht, wählt er einfach einen Block aus vielen Blöcken aus, die ihm von Block-Erstellern angeboten werden. Die Block-Ersteller könnten eine ausgeklügelte MEV-Extraktion durchgeführt haben, aber die Belohnung dafür erhält der Blockvorschlager. Das bedeutet, dass selbst, wenn ein kleiner Pool spezialisierter Block-Ersteller die MEV-Extraktion dominiert, die Belohnung dafür an jeden Validator im Netzwerk gehen könnte, einschließlich einzelner Heim-Staker (Privat-Einsetzer/Staker).
-
+
Aufgrund der verbesserten Belohnungen durch ausgeklügelte MEV-Strategien könnten Einzelpersonen dazu angeregt werden, sich Pools anzuschließen, anstatt alleine zu staken. Die Trennung der Block-Erstellung vom Block-Vorschlagsverfahren führt dazu, dass die extrahierte MEV auf eine größere Anzahl von Validatoren verteilt wird, anstatt sich bei dem effektivsten MEV-Sucher zu zentralisieren. Gleichzeitig nimmt das Erlauben von spezialisierten Blockproduzenten die Last der Blockerstellung weg vom Einzelnen und verhindert das Stehlen von MEV einzelner für sich selber, während die Anzahl individueller, unabhängiger Validatoren, die Blöcke auf ehrliche weise überprüfen, maximiert wird. Das wichtige Konzept ist die "Beweiser-Verifizierer Asymetrie", welche die Idee beschreibt, dass zentralisierte Blockproduktion okay ist, solange es ein robustes und maximal dezentralisiertes Netzwerk von ehrlichen Validatoren gibt, die die Blöcke überprüfen. Dezentralisierung ist ein Mittel, kein Endziel - worauf es uns ankommt, sind ehrliche Blöcke.
diff --git a/public/content/translations/de/roadmap/single-slot-finality/index.md b/public/content/translations/de/roadmap/single-slot-finality/index.md
index 30e0249776e..ce1bc16c003 100644
--- a/public/content/translations/de/roadmap/single-slot-finality/index.md
+++ b/public/content/translations/de/roadmap/single-slot-finality/index.md
@@ -33,7 +33,7 @@ Mit dem derzeitigen Aufbau des Mechanismus müssen, um die Zeit zur Endlichkeit
## Wege zu SSF {#routes-to-ssf}
-
+
Der derzeitige Konsensmechanismus verbindet Attestierungen mehrerer Validatoren, welche Komitees genannt werden, um die Anzahl an Nachrichten, die jeder Validator in einem Block verarbeiten muss, um jenen zu validieren, zu verringern. Jeder Validator hat in jeder Epoche (32 Plätze) die Möglichkeit zur Attestierung. In jedem Platz haben jedoch nur eine Untergruppe von Validatoren, bekannt als Komitee-Attestierung diese Möglichkeit. Das machen sie, indem sie in Unternetzwerke unterteilt werden, in denen wenige Validatoren als "Aggregatoren" ausgewählt werden. Diese Aggregatoren verbinden alle die Unterschriften, welche sie von anderen Validatoren bekommen in, in ihrem Netzwerk zu einer einzelnen aggregierten Unterschrift. Der Aggregator, welcher die größte Anzahl an einzelnen Teilnahmen beinhaltet, gibt dann die aggregierte Unterschrift an den Blockantragsteller (Block Proposer) weiter, welcher sie dann in seinem Block mit den aggregierten Unterschriften anderer Komitees einschließt.
diff --git a/public/content/translations/de/roadmap/statelessness/index.md b/public/content/translations/de/roadmap/statelessness/index.md
index a05c63395b4..8d179ad2404 100644
--- a/public/content/translations/de/roadmap/statelessness/index.md
+++ b/public/content/translations/de/roadmap/statelessness/index.md
@@ -68,7 +68,7 @@ Schwache Zustandslosigkeit beinhaltet Änderungen dazu, wie Ethereum Nodes Zusta
Damit dies geschehen kann, müssen [Verkle-Trees](/roadmap/verkle-trees/) bereits in Ethereum-Clients implementiert worden sein. Verkle-Bäume sind eine Datenersetzungsstruktur um Ethereums Zustandsdaten zu speichern. Sie erlauben kleine "Zeugen" fester Größe, die dazu da sind Daten zwischen Peers zu vermitteln und Blöcke direkt, anstatt gegen lokale Datenbanken zu verifizieren. [Proposer-Builder Separation](/roadmap/pbs/) ist ebenfalls erforderlich, da dies Block-Buildern ermöglicht, spezialisierte Nodes mit leistungsstärkerer Hardware zu sein, und genau diese benötigen Zugriff auf die vollständigen Zustandsdaten.
-
+
Zustandslosigkeit stützt sich auf Blockerzeuger, welche eine Kopie der vollen Zustandsdaten pflegen, sodass sie Zeugen generieren können, welche genutzt werden um Blöcke zu verifizieren. Andere Nodes müssen die Zustandsdaten nicht abrufen, da alle benötigten Informationen für das Verifizieren eines Blocks im Zeugen vorhanden sind. Das erzeugt eine Situation, in der das Vorschlagen eines Blocks teuer, das Verifizieren jedoch günstig ist, was bedeutet, das weniger Operatoren einen blockvorschlagenden Node betreiben werden. Jedoch ist die Dezentralisation von Block Proposern nicht kritisch, solange möglichst viele Teilnehmende unabhängig voneinander verifizieren können, dass der vorgeschlagene Block valide ist.
diff --git a/public/content/translations/de/roadmap/verkle-trees/index.md b/public/content/translations/de/roadmap/verkle-trees/index.md
index 69a78b97c0e..8dc8eabc9a0 100644
--- a/public/content/translations/de/roadmap/verkle-trees/index.md
+++ b/public/content/translations/de/roadmap/verkle-trees/index.md
@@ -15,7 +15,7 @@ Verkle Trees (ein Schachtelwort aus "Vektor-Verpflichtung" und "Merkle Bäumen")
Verkle Bäume sind ein kritischer Schritt hin zu Zustandsfreien Ethereum Clients. Zustandsfreie Clients müssen nicht den ganzen Zustand der Datenbank speichern, um hereinkommende Blöcke prüfen zu können. Anstatt ihre eigene Lokale Kopie von Ethereums' Zustand zur Verifizierung zu verwenden, nutzen zustandsfreie Clients einen "Zeugen" der Zustandsdaten, die mit dem Block ankommen. Ein Zeuge ist eine Ansammlung von Einzelteilen an Zustandsdaten, die benötigt werden, um bestimmte Transaktionen auszuführen und gleichzeitig ein kryptographischer Beweis das der Zeuge wirklich Teil der ganzen Daten ist. Der Zeuge wird _anstatt_ der Zustandsdatenbank verwendet. Damit dies funktioniert, müssen Zeugen sehr klein sein, so dass sie sicher und rechtzeitig über das Netzwerk verteilt werden können, damit Validatoren sie innerhalb des 12 Sekunden Zeitfensters bearbeiten können. Die momentane Zustandsdatenstruktur ist dafür nicht geeignet, weil Zeugen zu groß sind. Verkle Trees lösen dieses Problem, indem sie kleine Zeugen ermöglichen und damit eines der Hauptprobleme der zustandsfreien Clienten entfernen.
-
+
Ethereum Clients nutzen momentan eine Datenstruktur, die als Patricia Merkle Trie bekannt ist, um ihre Zustandsdaten zu speichern. Informationen über einzelne Accounts sind als Blätter auf der Baumstruktur gespeichert und Paare von Blättern werden wiederholt gehashed, bis nur ein einzelner Hash bleibt. Der endgültige Hash ist bekannt als die "Wurzel". Um Blöcke zu überprüfen, führen Ethereum Clients alle Transaktionen in einem Block aus und aktualisieren ihren lokalen Zustandsbaum. Der Block wird als gültig angesehen, wenn die Wurzel des lokalen Baumes identisch zu der vom Block-Vorschlagenden ist, weil jeder Unterschied in der Berechnung des Block-Vorschlagenden und der überprüfenden Node einen komplett anderen Wurzelhash ergeben würde. Das Problem hierbei ist, dass die Überprüfung der Blockchain erfordert, dass jeder Client den gesamten Zustandsbaum des Kopf-Blocks und mehrere historische Blöcke (der Standard in Geth ist, die Zustandsdaten für 128 Blöcke hinter dem Kopf zu behalten) erfordert. Dies setzt voraus, dass Clients über große Mengen an Speicherplatz verfügen, was wiederum eine Barriere für günstige ressourcenschonende Hardware ist. Eine Lösung hierfür ist ein Update des Zutandsbaumes auf eine effizientere Struktur (Verkle Tree), die Daten effizient über kleine "Zeugen" teilen kann, anstatt den vollständigen Zustand von Ethereum zu übertragen. Den Datenzustand in Verkle Trees umzuschreiben, ist ein großer Schritt hin zu Zustandsfreien Clients.
@@ -31,7 +31,7 @@ Die Struktur eines Merkle Trie erzeugt sehr große Zeugen - zu groß, um sicher
In einem Polynombindungs-Schema haben die Zeugen überschaubare Größen, die leicht unter Netzwerkteilnehmern versendet werden können. Dies erlaubt Clients, Zustandsveränderungen in jedem Block mit minimaler Menge an Daten zu verifizieren.
-
+
Die Größe des Zeugen variiert abhängig von der Anzahl der Blätter, die er enthält. Davon ausgehend, dass ein Zeuge 1000 Blätter abdeckt, wäre ein Zeuge für einen Merkle Baum ungefähr 3,5 MB (von 7 Ebenen im Trie ausgehend). Ein Zeuge für die selben Daten in einem Verkle Baum (von 4 Ebenen zum Baum ausgehend) würde ungefähr 150 kB an Daten ergeben -**etwa 23x kleiner**. Diese Reduktion der Zeugengröße wird Zeugen in zustandsfreien Clients ermöglichen, akzeptabel klein zu sein. Polynomzeugen sind 0,128–1 kB groß; abhängig davon, welches spezifische Polynom-Commitment verwendet wird.
diff --git a/public/content/translations/de/staking/pools/index.md b/public/content/translations/de/staking/pools/index.md
index 3376c9bf1f9..d8961d00818 100644
--- a/public/content/translations/de/staking/pools/index.md
+++ b/public/content/translations/de/staking/pools/index.md
@@ -24,9 +24,9 @@ Einige Pools arbeiten mit Smart Contracts, bei denen Gelder in einen Vertrag ein
Zusätzlich zu den Vorteilen, die wir in unserer [Einführung zum Staking](/staking/) beschrieben haben, bietet das Staking mit einem Pool eine Reihe von besonderen Vorteilen.
-
+
Typischerweise werden ERC-20-Staking-Token an die Staker ausgegeben und repräsentieren den Wert ihres eingesetzten ETH sowie Belohnungen. Denken Sie daran, dass Staking-Belohnungen grundsätzlich etabliert sind, verschiedene Pools Staking-Belohnungen allerdings nach leicht unterschiedlichen Methoden an ihre Benutzer verteilen.
-
+
Sofort! Die Aktualisierung des Netzwerks auf Shanghai/Capella erfolgte im April 2023 und führte das Auszahlen von Staking-Mitteln ein. Validatoren haben nun die Möglichkeit, Staking-Pools, die sie unterstützen, zu verlassen und eine Auszahlung von ETH an ihre angegebene Adresse anzuweisen. Dies macht es möglich, Ihren Anteil am Stake gegen das zugrundeliegende ETH einzulösen. Bitte wenden Sie sich an Ihren Anbieter, um zu erfahren, wie er diese Funktionalität unterstützt.
Alternativ dazu ermöglichen Pools, die einen ERC-20 Staking-Token verwenden, den Handel mit diesem Token auf dem freien Markt, so dass Sie Ihre Staking-Position verkaufen können, ohne tatsächlich ETH aus dem Staking-Vertrag zu entnehmen.
Mehr zu Staking-Auszahlungen \n
-\nEs gibt viele Ähnlichkeiten zwischen diesen gepoolten Staking-Optionen und zentralisierten Börsen, wie z. B. die Möglichkeit, kleine ETH-Beträge zu staken und sie zu bündeln, um Validatoren zu aktivieren.
+\nEs gibt viele Ähnlichkeiten zwischen diesen gepoolten Staking-Optionen und zentralisierten Börsen, wie z. B. die Möglichkeit, kleine ETH-Beträge zu staken und sie zu bündeln, um Validatoren zu aktivieren.
Im Gegensatz zu zentralisierten Börsen nutzen viele andere gepoolte Staking-Optionen Smart Contracts und/oder Staking-Token, bei denen es sich in der Regel um ERC-20-Token handelt, die Sie in Ihrer eigenen Wallet halten und wie jeden anderen Token kaufen oder verkaufen können. Dies bietet eine gewisse Souveränität und Sicherheit, da Sie die Kontrolle über Ihre Token besitzen. Allerdings haben Sie immer noch keine direkte Kontrolle über den Validator-Client, der in Ihrem Namen im Hintergrund Attestierungen ausgibt.
diff --git a/public/content/translations/de/staking/saas/index.md b/public/content/translations/de/staking/saas/index.md
index 301498a9a53..826943a8f9e 100644
--- a/public/content/translations/de/staking/saas/index.md
+++ b/public/content/translations/de/staking/saas/index.md
@@ -22,9 +22,9 @@ Staking-as-a-Service („SaaS“) stellt eine Kategorie von Staking-Diensten dar
Das Ethereum-Protokoll unterstützt keine Delegation von Staking, daher wurden diese Serviceleistungen aufgebaut, um die entsprechende Nachfrage zu befriedigen. Wenn Sie über 32 ETH zum Staking verfügen, sich aber davor scheuen, mit Hardware umzugehen, bieten SaaS-Dienste Ihnen die Möglichkeit, den schwierigen Teil zu delegieren, während Sie native Blockbelohnungen erhalten.
-
+
Die Vereinbarungen unterscheiden sich von Anbieter zu Anbieter. In der Regel werden Sie durch die Einrichtung aller benötigten Signaturschlüssel (einer pro 32 ETH) und das Hochladen dieser Schlüssel zu Ihrem Anbieter geleitet, damit dieser in Ihrem Namen validieren kann. Die Signaturschlüssel allein bieten nicht die Möglichkeit, Ihr Geld abzuheben, zu überweisen oder auszugeben. Sie bieten jedoch die Möglichkeit, Stimmen für einen Konsens abzugeben, was, wenn es nicht richtig gemacht wird, zu Offline-Strafen oder Slashing führen kann.
-
+
Ja. Jedes Konto besteht aus BLS-Signaturschlüsseln und BLS-Abhebungsschlüsseln. Damit ein Validator den Zustand der Blockchain attestieren, an Synchronisierungsausschüssen teilnehmen und Blöcke vorschlagen kann, müssen die Signaturschlüssel für einen Validator-Kunden leicht zugänglich sein. Diese müssen in irgendeiner Form mit dem Internet verbunden sein und werden daher naturgemäß als "Hot Keys" betrachtet. Dies ist eine Voraussetzung für Ihren Validator, um attestieren zu können. Daher werden die Schlüssel, die zum Überweisen oder Abheben von Geldern verwendet werden, aus Sicherheitsgründen getrennt.
Die BLS-Abhebungsschlüssel werden verwendet, um eine einmalige Nachricht zu signieren, die angibt, an welches Execution-Layer-Konto Staking-Belohnungen und ausgetretene Mittel gehen sollen. Sobald diese Nachricht gesendet wurde, werden die BLS-Abhebungsschlüssel nicht mehr benötigt. Stattdessen wird die Kontrolle über abgehobene Mittel dauerhaft an die von Ihnen angegebene Adresse delegiert. Auf diese Weise können Sie eine Abhebungsadresse festlegen, die durch Ihre eigene Cold Storage gesichert ist, um das Risiko für Ihre Validator-Fonds zu minimieren, selbst wenn jemand anderes die Signaturschlüssel Ihres Validators kontrolliert.
@@ -72,13 +72,13 @@ Das Aktualisieren der Auszahlungsberechtigungen ist ein erforderlicher Schritt,
\*Staker, die bei der Ersteinzahlung eine Auszahlungsadresse angegeben haben, müssen dies nicht festlegen. Bitte wenden Sie sich an Ihren SaaS-Anbieter, um Unterstützung bei der Vorbereitung Ihres Validators zu erhalten.
-\nStaker müssen (sofern nicht bereits bei der Ersteinzahlung geschehen) eine Auszahlungsadresse bereitstellen. Belohnungen werden daraufhin automatisch alle paar Tage in regelmäßigen Abständen ausgezahlt.
+\nStaker müssen (sofern nicht bereits bei der Ersteinzahlung geschehen) eine Auszahlungsadresse bereitstellen. Belohnungen werden daraufhin automatisch alle paar Tage in regelmäßigen Abständen ausgezahlt.
Validatoren haben auch die Möglichkeit, ihre Tätigkeit als Validator zu beenden. Das ermöglicht die Auszahlung ihres restlichen ETH-Guthabens. Konten, die eine Auszahlungsadresse angegeben und den Austrittsprozess abgeschlossen haben, erhalten ihr gesamtes Guthaben bei der nächsten Validatorendurchsicht auf die angegebene Auszahlungsadresse.
Mehr zu Staking-Auszahlungen \n
-
+
Durch die Nutzung eines SaaS-Anbieters vertrauen Sie den Betrieb Ihrer Nodes jemand anderem an. Dies birgt das Risiko einer schlechten Node-Leistung, auf die Sie keinen Einfluss haben. Falls Ihr Validator geslashed wird, wird Ihr Validator-Guthaben bestraft und zwangsweise aus dem Validator-Pool entfernt.
Nach Abschluss des Slashing-/Austrittsprozesses werden diese Mittel an die dem Validator zugewiesene Auszahlungsadresse übertragen. Dies erfordert die Angabe einer Auszahlungsadresse zur Aktivierung. Diese Adresse kann bei der anfänglichen Einzahlung angegeben worden sein. Falls nicht, müssen die Auszahlungsschlüssel des Validators verwendet werden, um eine Nachricht zu unterschreiben, die eine Auszahlungsadresse angibt. Wenn keine Auszahlungsadresse angegeben wurde, bleibt das Guthaben bis zur Angabe gesperrt.
diff --git a/public/content/translations/de/staking/solo/index.md b/public/content/translations/de/staking/solo/index.md
index ea0c83eec59..d0f31e3ad77 100644
--- a/public/content/translations/de/staking/solo/index.md
+++ b/public/content/translations/de/staking/solo/index.md
@@ -30,9 +30,9 @@ Ein Hausbesitzer erhält Belohnungen direkt vom Protokoll dafür, dass er dafür
Home Staking bringt mehr Verantwortung mit sich, bietet Ihnen jedoch maximale Kontrolle über Ihre Gelder und Ihr Abstecken aufstellen.
-
## Überlegungen vor dem Home-Staking {#considerations-before-staking-solo}
@@ -40,30 +40,30 @@ Home Staking bringt mehr Verantwortung mit sich, bietet Ihnen jedoch maximale Ko
So sehr wir uns auch wünschen, dass Home-Staking für jeden zugänglich und risikofrei wäre, so ist dies nicht die Realität. Es gibt einige praktische und ernsthafte Überlegungen, die Sie berücksichtigen sollten, bevor Sie sich für das Home-Staking Ihrer ETH entscheiden.
-
+
Wenn Sie Ihren eigenen Knoten betreiben, sollten Sie sich etwas Zeit nehmen, um zu lernen, wie Sie die von Ihnen gewählte Software verwenden. Dazu gehört das Lesen der relevanten Dokumentation und die Kenntnis der Kommunikationskanäle dieser Entwicklerteams.
Je mehr Sie über die von Ihnen verwendete Software und die Funktionsweise von Proof-of-Stake verstehen, desto weniger riskant ist es als Staker und desto einfacher wird es, als Knotenbetreiber alle auftretenden Probleme zu beheben.
-
+
Das Einrichten von Knoten erfordert einen gewissen Grad an Vertrautheit im Umgang mit Computern, obwohl neue Tools dies im Laufe der Zeit einfacher machen. Das Verständnis der Kommandozeilenschnittstelle ist hilfreich, aber nicht mehr zwingend erforderlich.
Es erfordert auch eine sehr einfache Hardware-Einrichtung und ein gewisses Verständnis der empfohlenen Mindestspezifikationen.
-
+
So wie private Schlüssel Ihre Ethereum-Adresse sichern, müssen Sie auch speziell für Ihren Validator Schlüssel generieren. Sie müssen verstehen, wie Sie Seed-Phrases oder private Schlüssel sicher aufbewahren.{' '}
[Ethereum-Sicherheit und Betrugsprävention](/security/)
-
+
Hardware fällt gelegentlich aus, Netzwerkverbindungen schlagen fehl und Client-Software muss gelegentlich aktualisiert werden. Die Wartung von Knoten ist unvermeidlich und erfordert gelegentlich Ihre Aufmerksamkeit. Sie sollten sicherstellen, dass Sie über alle erwarteten Netzwerk-Upgrades oder andere wichtige Client-Upgrades informiert bleiben.
-
+
Ihre Belohnungen sind proportional zu der Zeit, in der Ihr Validator online ist und ordnungsgemäß Bestätigungen abgibt. Ausfallzeiten führen zu Strafen, die proportional zur Anzahl der gleichzeitig offline geschalteten Validatoren sind, aber führen nicht zu Slashing. Auch die Bandbreite ist wichtig, da die Belohnungen für nicht rechtzeitig erhaltene Bestätigungen verringert werden. Die Anforderungen variieren, aber es wird ein Minimum von 10 Mbit/s für Up- und Download empfohlen.
-
+
Im Gegensatz zu Inaktivitätsstrafen für das Offline-Sein ist Slashing eine wesentlich schwerwiegendere Strafe, die böswilligen Verstößen vorbehalten ist. Indem Sie einen Minderheits-Client betreiben und Ihre Schlüssel nur auf einem einzigen Gerät geladen haben, wird Ihr Risiko eines Slashings minimiert. Dennoch müssen sich alle Staker der Risiken des Slashings bewusst sein.
Mehr über Slashing und den Lebenszyklus von Validatoren
@@ -122,13 +122,13 @@ Haben Sie einen Vorschlag für einen Staking-Tool, der noch fehlt? Sehen Sie sic
Das sind einige der häufigsten Fragen zum Thema Staking. Es ist lohnenswert sich damit auseinanderzusetzen.
-
+
Ein Validator ist eine virtuelle Entität, die auf Ethereum lebt und am Konsens des Ethereum-Protokolls teilnimmt. Validatoren werden durch ein Guthaben, einen öffentlichen Schlüssel und andere Eigenschaften dargestellt. Ein Validator-Client ist die Software, die im Namen des Validators handelt, indem sie dessen privaten Schlüssel hält und verwendet. Ein einzelner Validator-Client kann viele Schlüsselpaare enthalten und somit viele Validatoren steuern.
-
+
Ja, moderne Validator-Konten können bis zu 2048 ETH halten. Zusätzliche ETH über 32 werden schrittweise verzinst und erhöhen sich in ganzzahligen Schritten, wenn Ihr tatsächliches Guthaben steigt. Dies wird als Ihr effektives Guthaben bezeichnet.
Um das effektive Guthaben eines Kontos und damit die Belohnungen zu erhöhen, muss ein Puffer von 0,25 ETH über einer beliebigen Ganzzahl-ETH-Schwelle überschritten werden. Beispielsweise müsste ein Konto mit einem tatsächlichen Guthaben von 32,9 und einem effektiven Guthaben von 32 weitere 0,35 ETH verdienen, um sein tatsächliches Guthaben über 33,25 zu bringen, bevor eine Erhöhung des effektiven Guthabens ausgelöst wird.
@@ -139,14 +139,14 @@ Jedes Schlüsselpaar, das einem Validator zugeordnet ist, benötigt mindestens 3
Wenn Ihnen Home-Staking zu anspruchsvoll erscheint, ziehen Sie die Nutzung eines [Staking-as-a-Service](/staking/saas/)-Anbieters in Betracht, oder sehen Sie sich die [Staking-Pools](/staking/pools/) an, wenn Sie mit weniger als 32 ETH arbeiten.
-
+
Offline zu gehen, während das Netzwerk ordnungsgemäß finalisiert, führt NICHT zu Slashing. Geringe Inaktivitätsstrafen fallen an, wenn Ihr Validator für eine bestimmte Epoche (jeweils 6,4 Minuten lang) nicht für Bestätigungen zur Verfügung steht, was sich jedoch stark von Slashing unterscheidet. Diese Strafen sind etwas geringer als die Belohnung, die Sie erhalten hätten, wenn der Validator für Bestätigungen zur Verfügung gestanden hätte. Die Verluste können durch eine ungefähr gleich lange Zeit, in der Sie wieder online sind, ausgeglichen werden.
Beachten Sie, dass die Strafen für Inaktivität proportional zur Anzahl der gleichzeitig offline geschalteten Validatoren sind. In Fällen, in denen ein großer Teil des Netzwerks gleichzeitig offline ist, sind die Strafen für jeden dieser Validatoren höher als bei der Nichtverfügbarkeit eines einzelnen Validators.
In extremen Fällen, wenn das Netzwerk die Finalisierung einstellt, weil mehr als ein Drittel der Validatoren offline ist, erleiden diese Benutzer einen sogenannten quadratischen Inaktivitätsverlust, der einen exponentiellen Abfluss von ETH von Offline-Validator-Konten darstellt. Dies ermöglicht es dem Netzwerk, sich schließlich selbst zu heilen, indem die ETH inaktiver Validatoren verbrannt werden, bis ihr Guthaben 16 ETH erreicht. An diesem Punkt werden sie automatisch aus dem Validator-Pool entfernt. Die verbleibenden Online-Validatoren werden schließlich wieder mehr als 2/3 des Netzwerks ausmachen und so die erforderliche Supermajorität erreichen, um die Kette erneut zu finalisieren.
-
+
Kurz gesagt, dies kann nie vollständig garantiert werden, aber wenn Sie in gutem Glauben handeln, einen Minderheits-Client betreiben und Ihre Signaturschlüssel jeweils nur auf einem Computer aufbewahren, ist das Risiko eines Slashings nahezu null.
Es gibt nur wenige spezifische Vorgehensweisen, die dazu führen können, dass ein Validator einem Slashing unterzogen und aus dem Netzwerk entfernt wird. Zum Zeitpunkt der Erstellung dieses Dokuments waren die aufgetretenen Slashings ausschließlich auf redundante Hardware-Setups zurückzuführen, bei denen Signaturschlüssel gleichzeitig auf zwei separaten Maschinen gespeichert wurden. Dies kann unbeabsichtigt zu einer doppelten Abstimmung (Double Vote) durch Ihre Schlüssel führen, was ein durch Slashing strafbares Vergehen ist.
@@ -161,21 +161,21 @@ Der Betrieb eines Supermajoritäts-Clients (jeder Client, der von über 2/3 des
-
+
Einzelne Clients können sich in Bezug auf Leistung und Benutzeroberfläche geringfügig unterscheiden, da sie von verschiedenen Teams unter Verwendung einer Vielzahl von Programmiersprachen entwickelt werden. Dennoch ist keiner von ihnen der "Beste". Alle Produktions-Clients sind ausgezeichnete Software-Komponenten, die alle die gleichen Kernfunktionen zur Synchronisierung und Interaktion mit der Blockchain ausführen.
Da alle Produktions-Clients die gleiche Grundfunktionalität bieten, ist es sehr wichtig, dass Sie einen Minderheits-Client wählen, d. h. einen Client, der derzeit NICHT von einer Mehrheit der Validatoren im Netzwerk verwendet wird. Dies mag kontraintuitiv klingen, aber der Betrieb eines Majoritäts- oder Supermajoritäts-Clients setzt Sie einem erhöhten Slashing-Risiko aus, falls in diesem Client ein Fehler auftritt. Der Betrieb eines Minderheits-Clients begrenzt diese Risiken drastisch.
Erfahren Sie mehr darüber, warum Client-Diversität entscheidend ist
-
+
Obwohl ein virtueller privater Server (VPS) als Ersatz für die Hardware zu Hause verwendet werden kann, sind der physische Zugang und der Standort Ihres Validator-Clients sehr wohl von Bedeutung. Zentralisierte Cloud-Lösungen wie Amazon Web Services oder Digital Ocean bieten den Komfort, keine Hardware beschaffen und betreiben zu müssen, gehen aber auf Kosten der Zentralisierung des Netzwerks.
Je mehr Validator-Clients auf einer einzigen zentralisierten Cloud-Speicherlösung laufen, desto gefährlicher wird es für diese Benutzer. Jedes Ereignis, das diese Anbieter offline schaltet, sei es durch einen Angriff, regulatorische Anforderungen oder einfach nur Strom-/Internetausfälle, führt dazu, dass jeder Validator-Client, der auf diesen Server angewiesen ist, gleichzeitig offline geht.
Offline-Strafen sind proportional zur Anzahl der anderen, die gleichzeitig offline sind. Die Verwendung eines VPS erhöht das Risiko, dass Offline-Strafen schwerwiegender ausfallen, und erhöht Ihr Risiko von quadratischem Verlust oder Slashing, falls der Ausfall groß genug ist. Um Ihr eigenes Risiko und das Risiko für das Netzwerk zu minimieren, wird den Benutzern dringend empfohlen, ihre eigene Hardware zu beschaffen und zu betreiben.
-
+
Abhebungen jeglicher Art aus der Beaconchain erfordern die Angabe von Rücktrittsberechtigungen.
diff --git a/public/content/translations/de/staking/withdrawals/index.md b/public/content/translations/de/staking/withdrawals/index.md
index 66f639896ee..60812282b6b 100644
--- a/public/content/translations/de/staking/withdrawals/index.md
+++ b/public/content/translations/de/staking/withdrawals/index.md
@@ -151,7 +151,7 @@ Abhebungsadressen können entweder ein intelligenter Vertrag sein (durch seinen
Als Alternative zur Änderung der Auszahlungsadresse für einen bestimmten Validator können sich Benutzer dafür entscheiden, einen intelligenten Vertrag als ihre Auszahlungsadresse festzulegen, der Schlüsselrotationen handhaben könnte, wie zum Beispiel ein Safe. Benutzer, die ihre Mittel auf ihr eigenes extern kontrolliertes Konto (EOA) setzen, können einen vollständigen Ausstieg durchführen, um all ihre gestakten Mittel abzuheben, und dann mit neuen Anmeldeinformationen erneut staken.
@@ -170,7 +170,7 @@ eventName="read more">
Ja, solange Ihr Validator eine Auszahlungsadresse angegeben hat. Diese muss einmal bereitgestellt werden, um Auszahlungen zu ermöglichen, danach werden Belohnungszahlungen automatisch alle paar Tage mit jedem Durchlauf des Validators ausgelöst.
diff --git a/public/content/translations/de/what-are-apps/index.md b/public/content/translations/de/what-are-apps/index.md
index c1472a8ea58..4239e12954c 100644
--- a/public/content/translations/de/what-are-apps/index.md
+++ b/public/content/translations/de/what-are-apps/index.md
@@ -22,9 +22,9 @@ Einmal auf der Ethereum-Blockchain veröffentlicht, kann eine App nicht mehr ges
Die Logik von Ethereum-Anwendungen läuft auf der Ethereum-Blockchain und nicht auf zentralen Servern. Deswegen werden sie häufig als dezentrale Anwendungen, kurz dApps, bezeichnet.
-
## Warum ist das wichtig? {#why-does-this-matter}
@@ -68,14 +68,14 @@ Alle Apps auf Ethereum sind kompatibel miteinander. Ein Token für eine App funk
## Häufig gestellte Fragen {#faq}
-
+
Dapp steht für dezentrale Anwendungen. Diese werden auf Blockchain-Netzwerken wie Ethereum gebaut. Man nennt sie dezentral, da das darunterliegende Netzwerk dezentralisiert ist.
-
+
Mit einigen Anwendungen können Sie Krypto-Tokens verhandeln oder kaufen, aber nicht alle Apps sind dafür gedacht. Wenn Sie Ihre ersten Token kaufen möchten, besuchen Sie [ETH kaufen](/get-eth).
-
+
Mit einer Krypto-Wallet können Sie Ihre Tokens sicher aufbewahren und Ihr Ethereum-Account einfach verwalten. Es gibt zahlreiche gute Wallets, die jeweils für unterschiedliche Zwecke entwickelt wurden. Um herauszufinden, welche Wallet für Sie am besten geeignet ist, besuchen Sie unsere [Liste der Wallets](/wallets/find-wallet).
\ No newline at end of file
diff --git a/public/content/translations/de/wrapped-eth/index.md b/public/content/translations/de/wrapped-eth/index.md
index 46670f6ecea..1c3f5433aaa 100644
--- a/public/content/translations/de/wrapped-eth/index.md
+++ b/public/content/translations/de/wrapped-eth/index.md
@@ -37,25 +37,25 @@ Sie können WETH in ETH umwandeln, indem Sie den WETH-Smart Contract verwenden.
## Häufig gestellte Fragen {#faq}
-
+
Sie zahlen Gasgebühren, um ETH mit dem WETH-Vertrag zu verpacken oder zu entpacken.
-
+
WETH gilt allgemein als sicher, da es auf einem einfachen, bewährten Smart Contract basiert. Der WETH-Vertrag wurde zudem formal verifiziert, was den höchsten Sicherheitsstandard für Smart Contracts auf Ethereum darstellt.
-
+
Neben der [kanonischen Implementierung von WETH](https://etherscan.io/token/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2), die auf dieser Seite beschrieben ist, gibt es auch andere Varianten. Diese können benutzerdefinierte Token sein, die von App-Entwicklern erstellt wurden, oder Versionen, die auf anderen Blockchains herausgegeben wurden, und sich unterschiedlich verhalten oder unterschiedliche Sicherheitseigenschaften haben. **Überprüfen Sie immer die Token-Informationen, um zu erfahren, mit welcher WETH-Implementierung Sie interagieren.**
-
+
- [Ethereum-Mainnet](https://etherscan.io/token/0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2)
- [Arbitrum](https://arbiscan.io/token/0x82af49447d8a07e3bd95bd0d56f35241523fbab1)
From 3077849e08536784a9a55fcff1602e6dfad701b8 Mon Sep 17 00:00:00 2001
From: wackerow <54227730+wackerow@users.noreply.github.com>
Date: Sat, 24 Jan 2026 12:22:21 -0500
Subject: [PATCH 3/9] i18n: post-import sanitization
---
public/content/translations/de/about/index.md | 4 +--
.../translations/de/ai-agents/index.md | 6 ++--
.../content/translations/de/bridges/index.md | 4 +--
.../de/community/code-of-conduct/index.md | 2 +-
.../de/community/get-involved/index.md | 2 +-
.../translations/de/community/grants/index.md | 7 +++--
.../de/community/language-resources/index.md | 2 +-
.../translations/de/community/online/index.md | 2 +-
.../de/community/research/index.md | 12 +++----
.../de/community/support/index.md | 2 +-
.../adding-desci-projects/index.md | 4 +--
.../adding-developer-tools/index.md | 4 +--
.../de/contributing/adding-exchanges/index.md | 4 +--
.../adding-glossary-terms/index.md | 4 +--
.../de/contributing/adding-layer-2s/index.md | 4 +--
.../de/contributing/adding-products/index.md | 4 +--
.../de/contributing/adding-resources/index.md | 4 +--
.../adding-staking-products/index.md | 4 +--
.../de/contributing/adding-wallets/index.md | 4 +--
.../contributing/content-resources/index.md | 4 +--
.../contributing/design-principles/index.md | 4 +--
.../design/adding-design-resources/index.md | 4 +--
.../translations/de/contributing/index.md | 2 +-
.../de/contributing/quizzes/index.md | 4 +--
.../translation-program/faq/index.md | 4 +--
.../how-to-translate/index.md | 4 +--
.../contributing/translation-program/index.md | 4 +--
.../mission-and-vision/index.md | 2 +-
.../translation-program/playbook/index.md | 4 +--
.../translation-program/resources/index.md | 4 +--
.../translatathon/details/index.md | 2 +-
.../translators-guide/index.md | 4 +--
public/content/translations/de/dao/index.md | 10 +++---
.../de/decentralized-identity/index.md | 14 ++++-----
public/content/translations/de/defi/index.md | 9 +++---
public/content/translations/de/desci/index.md | 4 +--
.../de/developers/docs/accounts/index.md | 2 +-
.../de/developers/docs/apis/backend/index.md | 2 +-
.../developers/docs/apis/javascript/index.md | 2 +-
.../de/developers/docs/apis/json-rpc/index.md | 2 +-
.../de/developers/docs/blocks/index.md | 4 +--
.../de/developers/docs/bridges/index.md | 4 +--
.../docs/consensus-mechanisms/index.md | 2 +-
.../docs/consensus-mechanisms/poa/index.md | 2 +-
.../pos/attack-and-defense/index.md | 2 +-
.../pos/block-proposal/index.md | 5 ++-
.../consensus-mechanisms/pos/faqs/index.md | 4 +--
.../consensus-mechanisms/pos/gasper/index.md | 2 +-
.../docs/consensus-mechanisms/pos/index.md | 2 +-
.../consensus-mechanisms/pos/keys/index.md | 4 +--
.../pos/rewards-and-penalties/index.md | 2 +-
.../pos/weak-subjectivity/index.md | 4 +--
.../docs/consensus-mechanisms/pow/index.md | 2 +-
.../mining/mining-algorithms/ethash/index.md | 2 +-
.../pow/mining/mining-algorithms/index.md | 2 +-
.../block-explorers/index.md | 2 +-
.../docs/data-and-analytics/index.md | 2 +-
.../index.md | 2 +-
.../docs/data-availability/index.md | 16 +++++-----
.../data-structures-and-encoding/index.md | 2 +-
.../patricia-merkle-trie/index.md | 4 +--
.../data-structures-and-encoding/rlp/index.md | 2 +-
.../data-structures-and-encoding/ssz/index.md | 2 +-
.../web3-secret-storage/index.md | 2 +-
.../dex-design-best-practice/index.md | 4 +--
.../heuristics-for-web3/index.md | 4 +--
.../de/developers/docs/design-and-ux/index.md | 2 +-
.../docs/development-networks/index.md | 2 +-
.../developers/docs/ethereum-stack/index.md | 2 +-
.../de/developers/docs/evm/index.md | 2 +-
.../de/developers/docs/evm/opcodes/index.md | 6 ++--
.../de/developers/docs/frameworks/index.md | 2 +-
.../de/developers/docs/gas/index.md | 4 +--
.../de/developers/docs/ides/index.md | 2 +-
.../translations/de/developers/docs/index.md | 2 +-
.../developers/docs/intro-to-ether/index.md | 2 +-
.../docs/intro-to-ethereum/index.md | 7 ++---
.../de/developers/docs/mev/index.md | 2 +-
.../developers/docs/networking-layer/index.md | 2 +-
.../network-addresses/index.md | 2 +-
.../networking-layer/portal-network/index.md | 2 +-
.../de/developers/docs/networks/index.md | 2 +-
.../nodes-and-clients/archive-nodes/index.md | 2 +-
.../docs/nodes-and-clients/bootnodes/index.md | 4 +--
.../client-diversity/index.md | 4 +--
.../docs/nodes-and-clients/index.md | 5 ++-
.../nodes-and-clients/light-clients/index.md | 2 +-
.../nodes-as-a-service/index.md | 2 +-
.../nodes-and-clients/run-a-node/index.md | 4 +--
.../de/developers/docs/oracles/index.md | 2 +-
.../docs/programming-languages/dart/index.md | 4 +--
.../programming-languages/delphi/index.md | 4 +--
.../programming-languages/dot-net/index.md | 4 +--
.../programming-languages/elixir/index.md | 4 +--
.../programming-languages/golang/index.md | 4 +--
.../docs/programming-languages/index.md | 2 +-
.../docs/programming-languages/java/index.md | 4 +--
.../programming-languages/javascript/index.md | 4 +--
.../programming-languages/python/index.md | 4 +--
.../docs/programming-languages/ruby/index.md | 4 +--
.../docs/programming-languages/rust/index.md | 4 +--
.../de/developers/docs/scaling/index.md | 2 +-
.../docs/scaling/optimistic-rollups/index.md | 2 +-
.../developers/docs/scaling/plasma/index.md | 2 +-
.../docs/scaling/sidechains/index.md | 2 +-
.../docs/scaling/state-channels/index.md | 4 +--
.../developers/docs/scaling/validium/index.md | 5 ++-
.../docs/scaling/zk-rollups/index.md | 2 +-
.../docs/smart-contracts/compiling/index.md | 2 +-
.../smart-contracts/composability/index.md | 2 +-
.../docs/smart-contracts/deploying/index.md | 2 +-
.../formal-verification/index.md | 2 +-
.../developers/docs/smart-contracts/index.md | 7 ++---
.../docs/smart-contracts/languages/index.md | 2 +-
.../docs/smart-contracts/naming/index.md | 2 +-
.../docs/smart-contracts/security/index.md | 2 +-
.../docs/smart-contracts/testing/index.md | 2 +-
.../docs/smart-contracts/upgrading/index.md | 5 ++-
.../docs/smart-contracts/verifying/index.md | 4 +--
.../de/developers/docs/standards/index.md | 2 +-
.../docs/standards/tokens/erc-1155/index.md | 2 +-
.../docs/standards/tokens/erc-1363/index.md | 2 +-
.../docs/standards/tokens/erc-20/index.md | 2 +-
.../docs/standards/tokens/erc-223/index.md | 2 +-
.../docs/standards/tokens/erc-4626/index.md | 2 +-
.../docs/standards/tokens/erc-721/index.md | 2 +-
.../docs/standards/tokens/erc-777/index.md | 2 +-
.../developers/docs/standards/tokens/index.md | 2 +-
.../de/developers/docs/storage/index.md | 2 +-
.../de/developers/docs/transactions/index.md | 2 +-
.../index.md | 4 +--
.../tutorials/all-you-can-cache/index.md | 2 +-
.../developers/tutorials/app-plasma/index.md | 8 ++---
.../index.md | 6 ++--
.../index.md | 2 +-
.../index.md | 2 +-
.../index.md | 2 +-
.../index.md | 2 +-
.../erc-721-vyper-annotated-code/index.md | 2 +-
.../tutorials/ethereum-for-web2-auth/index.md | 4 +--
.../index.md | 6 ++--
.../index.md | 11 ++++---
.../hello-world-smart-contract/index.md | 4 +--
.../tutorials/how-to-mint-an-nft/index.md | 4 +--
.../index.md | 4 +--
.../index.md | 2 +-
.../index.md | 2 +-
.../index.md | 2 +-
.../how-to-use-tellor-as-your-oracle/index.md | 2 +-
.../how-to-view-nft-in-metamask/index.md | 2 +-
.../how-to-write-and-deploy-an-nft/index.md | 4 +--
.../tutorials/ipfs-decentralized-ui/index.md | 4 +--
.../index.md | 2 +-
.../index.md | 2 +-
.../logging-events-smart-contracts/index.md | 2 +-
.../index.md | 6 ++--
.../index.md | 4 +--
.../developers/tutorials/nft-minter/index.md | 2 +-
.../index.md | 2 +-
.../tutorials/run-node-raspberry-pi/index.md | 2 +-
.../tutorials/scam-token-tricks/index.md | 2 +-
.../tutorials/secret-state/index.md | 4 +--
.../secure-development-workflow/index.md | 2 +-
.../tutorials/server-components/index.md | 2 +-
.../developers/tutorials/short-abi/index.md | 2 +-
.../index.md | 4 +--
.../index.md | 2 +-
.../token-integration-checklist/index.md | 4 +--
.../index.md | 4 +--
.../index.md | 2 +-
.../index.md | 2 +-
.../tutorials/yellow-paper-evm/index.md | 4 +--
public/content/translations/de/eips/index.md | 4 +--
.../de/energy-consumption/index.md | 2 +-
.../translations/de/eth/supply/index.md | 2 +-
.../translations/de/ethereum-forks/index.md | 20 +-----------
.../translations/de/foundation/index.md | 2 +-
.../content/translations/de/gaming/index.md | 6 ++--
.../content/translations/de/glossary/index.md | 2 +-
.../translations/de/governance/index.md | 2 +-
.../index.md | 7 +++--
.../de/guides/how-to-id-scam-tokens/index.md | 7 ++---
.../how-to-revoke-token-access/index.md | 5 +--
.../de/guides/how-to-swap-tokens/index.md | 3 +-
.../de/guides/how-to-use-a-bridge/index.md | 7 +++--
.../de/guides/how-to-use-a-wallet/index.md | 5 +--
.../content/translations/de/guides/index.md | 4 +--
public/content/translations/de/nft/index.md | 7 +++--
.../content/translations/de/payments/index.md | 15 +++++----
.../de/prediction-markets/index.md | 6 ++--
.../content/translations/de/privacy/index.md | 2 +-
.../de/real-world-assets/index.md | 12 +++----
public/content/translations/de/refi/index.md | 6 ++--
.../translations/de/restaking/index.md | 4 +--
.../de/roadmap/account-abstraction/index.md | 2 +-
.../de/roadmap/beacon-chain/index.md | 11 +++----
.../de/roadmap/danksharding/index.md | 8 +----
.../translations/de/roadmap/dencun/index.md | 2 +-
.../translations/de/roadmap/fusaka/index.md | 2 +-
.../de/roadmap/fusaka/peerdas/index.md | 2 +-
.../de/roadmap/future-proofing/index.md | 2 +-
.../translations/de/roadmap/merge/index.md | 18 +++++------
.../de/roadmap/merge/issuance/index.md | 18 ++++++++---
.../translations/de/roadmap/pbs/index.md | 6 ++--
.../de/roadmap/pectra/7702/index.md | 2 +-
.../translations/de/roadmap/pectra/index.md | 2 +-
.../de/roadmap/pectra/maxeb/index.md | 2 +-
.../translations/de/roadmap/scaling/index.md | 2 +-
.../roadmap/secret-leader-election/index.md | 4 +--
.../translations/de/roadmap/security/index.md | 2 +-
.../de/roadmap/single-slot-finality/index.md | 7 +++--
.../de/roadmap/statelessness/index.md | 5 +--
.../de/roadmap/user-experience/index.md | 2 +-
.../de/roadmap/verkle-trees/index.md | 2 --
.../content/translations/de/security/index.md | 2 +-
.../translations/de/smart-contracts/index.md | 2 +-
.../translations/de/social-networks/index.md | 6 ++--
.../translations/de/staking/dvt/index.md | 2 +-
.../translations/de/staking/pools/index.md | 14 +++++----
.../translations/de/staking/saas/index.md | 14 ++++++---
.../translations/de/staking/solo/index.md | 31 ++++++++++++-------
.../de/staking/withdrawals/index.md | 23 ++++++++------
public/content/translations/de/web3/index.md | 8 +++--
.../translations/de/what-are-apps/index.md | 5 ++-
.../translations/de/whitepaper/index.md | 2 +-
.../translations/de/wrapped-eth/index.md | 11 +++----
.../de/zero-knowledge-proofs/index.md | 6 ++--
227 files changed, 462 insertions(+), 470 deletions(-)
diff --git a/public/content/translations/de/about/index.md b/public/content/translations/de/about/index.md
index d076295981a..cfa92dbe050 100644
--- a/public/content/translations/de/about/index.md
+++ b/public/content/translations/de/about/index.md
@@ -1,6 +1,6 @@
---
-title: Über uns
-description: Über das Team, die Community und die Mission von ethereum.org
+title: "Über uns"
+description: "Über das Team, die Community und die Mission von ethereum.org"
lang: de
---
diff --git a/public/content/translations/de/ai-agents/index.md b/public/content/translations/de/ai-agents/index.md
index dec287cde4f..c35726ce1ad 100644
--- a/public/content/translations/de/ai-agents/index.md
+++ b/public/content/translations/de/ai-agents/index.md
@@ -1,16 +1,16 @@
---
title: KI-Agenten
metaTitle: KI-Agenten | KI-Agenten auf Ethereum
-description: Ein Überblick über KI-Agenten auf Ethereum
+description: "Ein Überblick über KI-Agenten auf Ethereum"
lang: de
template: use-cases
emoji: ":robot:"
sidebarDepth: 2
image: /images/ai-agents/hero-image.png
alt: An einem Terminaltisch versammelte Menschen
-summaryPoint1: KI, die mit der Blockchain interagiert und eigenständig handelt
+summaryPoint1: "KI, die mit der Blockchain interagiert und eigenständig handelt"
summaryPoint2: Kontrolliert On-Chain-Wallets und Guthaben
-summaryPoint3: Stellt Menschen oder andere Agenten für Arbeit ein
+summaryPoint3: "Stellt Menschen oder andere Agenten für Arbeit ein"
buttons:
- content: Was sind KI-Agenten?
toId: what-are-ai-agents
diff --git a/public/content/translations/de/bridges/index.md b/public/content/translations/de/bridges/index.md
index 1cbc5d4dd65..7ddc56f6374 100644
--- a/public/content/translations/de/bridges/index.md
+++ b/public/content/translations/de/bridges/index.md
@@ -1,6 +1,6 @@
---
-title: Einführung in Blockchain-Brücken
-description: Brücken erlauben es Benutzern, ihr Guthaben über verschiedene Blockchains zu verschieben
+title: "Einführung in Blockchain-Brücken"
+description: "Brücken erlauben es Benutzern, ihr Guthaben über verschiedene Blockchains zu verschieben"
lang: de
---
diff --git a/public/content/translations/de/community/code-of-conduct/index.md b/public/content/translations/de/community/code-of-conduct/index.md
index 65847054100..5d8e3c619c9 100644
--- a/public/content/translations/de/community/code-of-conduct/index.md
+++ b/public/content/translations/de/community/code-of-conduct/index.md
@@ -1,6 +1,6 @@
---
title: Verhaltenskodex
-description: Die grundlegenden Standards, die wir für alle Bereiche von ethereum.org anstreben.
+description: "Die grundlegenden Standards, die wir für alle Bereiche von ethereum.org anstreben."
lang: de
---
diff --git a/public/content/translations/de/community/get-involved/index.md b/public/content/translations/de/community/get-involved/index.md
index f1b063ff057..9fd31d783e1 100644
--- a/public/content/translations/de/community/get-involved/index.md
+++ b/public/content/translations/de/community/get-involved/index.md
@@ -1,6 +1,6 @@
---
title: Wie kann ich mich einbringen?
-description: So können Sie sich in der Ethereum-Community engagieren
+description: "So können Sie sich in der Ethereum-Community engagieren"
lang: de
---
diff --git a/public/content/translations/de/community/grants/index.md b/public/content/translations/de/community/grants/index.md
index 48597216382..e573a0d9680 100644
--- a/public/content/translations/de/community/grants/index.md
+++ b/public/content/translations/de/community/grants/index.md
@@ -1,6 +1,6 @@
---
-title: Ethereum Foundation & Förderprogramme der Community
-description: Eine Auflistung der Förderprogramme im gesamten Ethereum-Ökosystem.
+title: "Ethereum Foundation & Förderprogramme der Community"
+description: "Eine Auflistung der Förderprogramme im gesamten Ethereum-Ökosystem."
lang: de
---
@@ -12,7 +12,8 @@ Diese Liste wird von unserer Community verwaltet. Wenn Informationen fehlen oder
## Breites Ethereum-Ökosystem {#broad-ethereum-ecosystem}
diff --git a/public/content/translations/de/community/language-resources/index.md b/public/content/translations/de/community/language-resources/index.md
index 20dd73754a1..bc2ce395eea 100644
--- a/public/content/translations/de/community/language-resources/index.md
+++ b/public/content/translations/de/community/language-resources/index.md
@@ -1,6 +1,6 @@
---
title: Sprachressourcen
-description: Ressourcen in nicht englischer Sprache, um mehr über Ethereum zu erfahren
+description: "Ressourcen in nicht englischer Sprache, um mehr über Ethereum zu erfahren"
lang: de
---
diff --git a/public/content/translations/de/community/online/index.md b/public/content/translations/de/community/online/index.md
index b3b1f158368..21e64d64ce5 100644
--- a/public/content/translations/de/community/online/index.md
+++ b/public/content/translations/de/community/online/index.md
@@ -51,5 +51,5 @@ Wenn Sie der Meinung sind, dass eine Community auf Grundlage dieser Richtlinien
Erfahren Sie mehr über DAOs
-
+
diff --git a/public/content/translations/de/community/research/index.md b/public/content/translations/de/community/research/index.md
index 12672d7863a..e39761d27cd 100644
--- a/public/content/translations/de/community/research/index.md
+++ b/public/content/translations/de/community/research/index.md
@@ -1,6 +1,6 @@
---
title: Aktive Bereiche der Ethereum-Forschung
-description: Machen Sie sich mit den verschiedenen Bereichen der offenen Forschung vertraut und erfahren Sie, wie auch Sie sich beteiligen können.
+description: "Machen Sie sich mit den verschiedenen Bereichen der offenen Forschung vertraut und erfahren Sie, wie auch Sie sich beteiligen können."
lang: de
---
@@ -128,7 +128,7 @@ Sichere und leistungsfähige Brücken sind ein spezifischer Bereich der Ebene 2,
#### Aktuelle Forschung {#recent-research-3}
-- [Validierung von Brücken] (https://stonecoldpat.github.io/images/validatingbridges.pdf)
+- [Validierung von Brücken](https://stonecoldpat.github.io/images/validatingbridges.pdf)
### Sharding {#sharding}
@@ -195,7 +195,7 @@ Ethereum-Wallets können Browsererweiterungen, Desktop- und Handyapps oder Smart
#### Aktuelle Forschung {#recent-research-7}
-- [Validierungsorientierte Smart-Contract-Wallets] (https://ethereum-magicians.org/t/validation-focused-smart-contract-wallets/6603)
+- [Validierungsorientierte Smart-Contract-Wallets](https://ethereum-magicians.org/t/validation-focused-smart-contract-wallets/6603)
- [Die Zukunft von Konten](https://ethereum-magicians.org/t/validation-focused-smart-contract-wallets/6603)
- [EIP-3074: AUTH- und AUTHCALL-Opcodes](https://eips.ethereum.org/EIPS/eip-3074)
- [Veröffentlichung von Code unter einer EOA-Adresse](https://eips.ethereum.org/EIPS/eip-5003)
@@ -262,7 +262,7 @@ Validatoren nutzen Ethereums natives Asset (Ether) als Sicherheit vor unehrliche
#### Aktuelle Forschung {#recent-research-11}
- [Erhöhung der Zensurresistenz von Transaktionen im Rahmen der Proposer-Builder-Trennung (PBS)](https://notes.ethereum.org/s3JToeApTx6CKLJt8AbhFQ)
-- [Drei Angriffe auf PoS-Ethereum] (https://arxiv.org/abs/2110.10086)
+- [Drei Angriffe auf PoS-Ethereum](https://arxiv.org/abs/2110.10086)
### Liquid Staking und Derivate {#liquid-staking-and-derivatives}
@@ -276,7 +276,7 @@ Liquid Staking erlaubt Benutzern mit weniger als 32 ETH Stakingerträge zu erhal
#### Aktuelle Forschung {#recent-research-12}
-- [Abwicklung von Abhebungen von Lido] (https://ethresear.ch/t/handling-withdrawals-in-lidos-eth-liquid-staking-protocol/8873)
+- [Abwicklung von Abhebungen von Lido](https://ethresear.ch/t/handling-withdrawals-in-lidos-eth-liquid-staking-protocol/8873)
- [Anmeldeinformationen für Abhebungen](https://ethresear.ch/t/withdrawal-credential-rotation-from-bls-to-eth1/8722)
- [Die Risiken von Liquid Staking-Derivaten](https://notes.ethereum.org/@djrtwo/risks-of-lsd)
@@ -338,7 +338,7 @@ Ein bedeutender Anwendungsfall von Ethereum ist die Möglichkeit der Organisieru
#### Aktuelle Forschung {#recent-research-16}
-- [Zuordnung des DAO-Ökosystems] (https://www.researchgate.net/publication/358694594_Mapping_out_the_DAO_Ecosystem_and_Assessing_DAO_Autonomy)
+- [Zuordnung des DAO-Ökosystems](https://www.researchgate.net/publication/358694594_Mapping_out_the_DAO_Ecosystem_and_Assessing_DAO_Autonomy)
### Entwicklerwerkzeuge {#developer-tools}
diff --git a/public/content/translations/de/community/support/index.md b/public/content/translations/de/community/support/index.md
index 5c959335b8b..eabd1bf75d0 100644
--- a/public/content/translations/de/community/support/index.md
+++ b/public/content/translations/de/community/support/index.md
@@ -1,6 +1,6 @@
---
title: Ethereum-Support
-description: Support im Ethereum-Ökosystem erhalten
+description: "Support im Ethereum-Ökosystem erhalten"
lang: de
---
diff --git a/public/content/translations/de/contributing/adding-desci-projects/index.md b/public/content/translations/de/contributing/adding-desci-projects/index.md
index 6f779ad60df..58f3d3e45fb 100644
--- a/public/content/translations/de/contributing/adding-desci-projects/index.md
+++ b/public/content/translations/de/contributing/adding-desci-projects/index.md
@@ -1,6 +1,6 @@
---
-title: DeSci-Projekte hinzufügen
-description: Unsere Kriterien für das Hinzufügen von Projekt-Links auf der DeSci-Seite von ethereum.org
+title: "DeSci-Projekte hinzufügen"
+description: "Unsere Kriterien für das Hinzufügen von Projekt-Links auf der DeSci-Seite von ethereum.org"
lang: de
---
diff --git a/public/content/translations/de/contributing/adding-developer-tools/index.md b/public/content/translations/de/contributing/adding-developer-tools/index.md
index 8e0c0294b67..813788749a9 100644
--- a/public/content/translations/de/contributing/adding-developer-tools/index.md
+++ b/public/content/translations/de/contributing/adding-developer-tools/index.md
@@ -1,7 +1,7 @@
---
-title: Entwicklertools hinzufügen
+title: "Entwicklertools hinzufügen"
lang: de
-description: Unsere Kriterien für die Auflistung von Entwicklertools auf ethereum.org
+description: "Unsere Kriterien für die Auflistung von Entwicklertools auf ethereum.org"
---
# Hinzufügen von Entwickler-Tools {#contributing-to-ethereumorg-}
diff --git a/public/content/translations/de/contributing/adding-exchanges/index.md b/public/content/translations/de/contributing/adding-exchanges/index.md
index 928b3744754..184b9fd860d 100644
--- a/public/content/translations/de/contributing/adding-exchanges/index.md
+++ b/public/content/translations/de/contributing/adding-exchanges/index.md
@@ -1,6 +1,6 @@
---
-title: Handelsplätze hinzufügen
-description: Richtlinien für das Hinzufügen von Handelsplätzen auf ethereum.org
+title: "Handelsplätze hinzufügen"
+description: "Richtlinien für das Hinzufügen von Handelsplätzen auf ethereum.org"
lang: de
---
diff --git a/public/content/translations/de/contributing/adding-glossary-terms/index.md b/public/content/translations/de/contributing/adding-glossary-terms/index.md
index 7ca8a6464f8..47a0d5be67a 100644
--- a/public/content/translations/de/contributing/adding-glossary-terms/index.md
+++ b/public/content/translations/de/contributing/adding-glossary-terms/index.md
@@ -1,7 +1,7 @@
---
-title: Begriffe zum Glossar hinzufügen
+title: "Begriffe zum Glossar hinzufügen"
lang: de
-description: Unsere Kriterien für die Aufnahme neuer Begriffe in das Glossar von ethereum.org
+description: "Unsere Kriterien für die Aufnahme neuer Begriffe in das Glossar von ethereum.org"
---
# Glossarbegriffe hinzufügen {#contributing-to-ethereumorg-}
diff --git a/public/content/translations/de/contributing/adding-layer-2s/index.md b/public/content/translations/de/contributing/adding-layer-2s/index.md
index 35afddf5b2f..e013c2cd6a8 100644
--- a/public/content/translations/de/contributing/adding-layer-2s/index.md
+++ b/public/content/translations/de/contributing/adding-layer-2s/index.md
@@ -1,6 +1,6 @@
---
-title: Layer 2s hinzufügen
-description: Regeln zum Hinzufügen einer Ebene 2 zu ethereum.org
+title: "Layer 2s hinzufügen"
+description: "Regeln zum Hinzufügen einer Ebene 2 zu ethereum.org"
lang: de
---
diff --git a/public/content/translations/de/contributing/adding-products/index.md b/public/content/translations/de/contributing/adding-products/index.md
index 8626dc97ecf..ac24f76782e 100644
--- a/public/content/translations/de/contributing/adding-products/index.md
+++ b/public/content/translations/de/contributing/adding-products/index.md
@@ -1,6 +1,6 @@
---
-title: Produkte hinzufügen
-description: Die Richtlinie, die wir beim Hinzufügen von dApps zu ethereum.org verwenden
+title: "Produkte hinzufügen"
+description: "Die Richtlinie, die wir beim Hinzufügen von dApps zu ethereum.org verwenden"
lang: de
---
diff --git a/public/content/translations/de/contributing/adding-resources/index.md b/public/content/translations/de/contributing/adding-resources/index.md
index 113ed3e70a2..b5636688ac5 100644
--- a/public/content/translations/de/contributing/adding-resources/index.md
+++ b/public/content/translations/de/contributing/adding-resources/index.md
@@ -1,6 +1,6 @@
---
-title: Hinzufügen von Ressourcen
-description: Die Richtlinie, die wir beim Hinzufügen von Ressourcen zu ethereum.org anwenden
+title: "Hinzufügen von Ressourcen"
+description: "Die Richtlinie, die wir beim Hinzufügen von Ressourcen zu ethereum.org anwenden"
lang: de
---
diff --git a/public/content/translations/de/contributing/adding-staking-products/index.md b/public/content/translations/de/contributing/adding-staking-products/index.md
index c98487eeb69..300a1feeefd 100644
--- a/public/content/translations/de/contributing/adding-staking-products/index.md
+++ b/public/content/translations/de/contributing/adding-staking-products/index.md
@@ -1,6 +1,6 @@
---
-title: Staking-Produkte oder -Services hinzufügen
-description: Richtlinien, die wir beim Hinzufügen von Staking-Produkten oder -Dienstleistungen zu ethereum.org anwenden
+title: "Staking-Produkte oder -Services hinzufügen"
+description: "Richtlinien, die wir beim Hinzufügen von Staking-Produkten oder -Dienstleistungen zu ethereum.org anwenden"
lang: de
---
diff --git a/public/content/translations/de/contributing/adding-wallets/index.md b/public/content/translations/de/contributing/adding-wallets/index.md
index 4d3cf2abe3b..cf60128a537 100644
--- a/public/content/translations/de/contributing/adding-wallets/index.md
+++ b/public/content/translations/de/contributing/adding-wallets/index.md
@@ -1,6 +1,6 @@
---
-title: Wallets hinzufügen
-description: Richtlinien, die wir verwenden, wenn wir eine Wallet zu ethereum.org hinzufügen
+title: "Wallets hinzufügen"
+description: "Richtlinien, die wir verwenden, wenn wir eine Wallet zu ethereum.org hinzufügen"
lang: de
---
diff --git a/public/content/translations/de/contributing/content-resources/index.md b/public/content/translations/de/contributing/content-resources/index.md
index 1b80f5cb2a0..5241aeb7315 100644
--- a/public/content/translations/de/contributing/content-resources/index.md
+++ b/public/content/translations/de/contributing/content-resources/index.md
@@ -1,7 +1,7 @@
---
-title: Inhaltsressourcen hinzufügen
+title: "Inhaltsressourcen hinzufügen"
lang: de
-description: Unsere Kriterien für die Auflistung von Inhaltsressourcen auf ethereum.org
+description: "Unsere Kriterien für die Auflistung von Inhaltsressourcen auf ethereum.org"
---
# Hinzufügen von Inhaltsressourcen {#adding-content-resources}
diff --git a/public/content/translations/de/contributing/design-principles/index.md b/public/content/translations/de/contributing/design-principles/index.md
index 656c99128d0..603f3d1ad86 100644
--- a/public/content/translations/de/contributing/design-principles/index.md
+++ b/public/content/translations/de/contributing/design-principles/index.md
@@ -1,7 +1,7 @@
---
-title: Designgrundsätze
+title: "Designgrundsätze"
lang: de
-description: Die Grundsätze hinter den Entscheidungen über Design und Inhalt von ethereum.org
+description: "Die Grundsätze hinter den Entscheidungen über Design und Inhalt von ethereum.org"
---
# Unsere Design-Grundsätze {#contributing-to-ethereumorg-}
diff --git a/public/content/translations/de/contributing/design/adding-design-resources/index.md b/public/content/translations/de/contributing/design/adding-design-resources/index.md
index 95890364783..42a5413f124 100644
--- a/public/content/translations/de/contributing/design/adding-design-resources/index.md
+++ b/public/content/translations/de/contributing/design/adding-design-resources/index.md
@@ -1,6 +1,6 @@
---
-title: Design-Ressourcen hinzufügen
-description: Richtlinien und Anforderungen zur Gewährleistung der Qualität von Designmaterialien auf ethereum.org
+title: "Design-Ressourcen hinzufügen"
+description: "Richtlinien und Anforderungen zur Gewährleistung der Qualität von Designmaterialien auf ethereum.org"
lang: de
---
diff --git a/public/content/translations/de/contributing/index.md b/public/content/translations/de/contributing/index.md
index 4bf0f92e445..2c1bfa5c4ed 100644
--- a/public/content/translations/de/contributing/index.md
+++ b/public/content/translations/de/contributing/index.md
@@ -1,6 +1,6 @@
---
title: Mitwirken
-description: Mehr erfahren über die verschiedenen Wege, um einen Beitrag zu ethereum.org zu leisten
+description: "Mehr erfahren über die verschiedenen Wege, um einen Beitrag zu ethereum.org zu leisten"
lang: de
---
diff --git a/public/content/translations/de/contributing/quizzes/index.md b/public/content/translations/de/contributing/quizzes/index.md
index 50bfa7c63bd..427800c0525 100644
--- a/public/content/translations/de/contributing/quizzes/index.md
+++ b/public/content/translations/de/contributing/quizzes/index.md
@@ -1,6 +1,6 @@
---
-title: Quiz hinzufügen
-description: Die Richtlinie, die wir beim Hinzufügen von Quiz zu ethereum.org anwenden
+title: "Quiz hinzufügen"
+description: "Die Richtlinie, die wir beim Hinzufügen von Quiz zu ethereum.org anwenden"
lang: de
---
diff --git a/public/content/translations/de/contributing/translation-program/faq/index.md b/public/content/translations/de/contributing/translation-program/faq/index.md
index d828bf7136a..ea9daf104e7 100644
--- a/public/content/translations/de/contributing/translation-program/faq/index.md
+++ b/public/content/translations/de/contributing/translation-program/faq/index.md
@@ -1,7 +1,7 @@
---
-title: Häufig gestellte Fragen zum Übersetzungsprogramm (FAQ)
+title: "Häufig gestellte Fragen zum Übersetzungsprogramm (FAQ)"
lang: de
-description: Häufig gestellte Fragen zum Übersetzungprogramm von ethereum.org
+description: "Häufig gestellte Fragen zum Übersetzungprogramm von ethereum.org"
---
# Leitfaden zum Übersetzen von ethereum.org {#translating-ethereum-guide}
diff --git a/public/content/translations/de/contributing/translation-program/how-to-translate/index.md b/public/content/translations/de/contributing/translation-program/how-to-translate/index.md
index 9907daaf7eb..f0bc2f40c4f 100644
--- a/public/content/translations/de/contributing/translation-program/how-to-translate/index.md
+++ b/public/content/translations/de/contributing/translation-program/how-to-translate/index.md
@@ -1,7 +1,7 @@
---
-title: Übersetzen – so geht's
+title: "Übersetzen – so geht's"
lang: de
-description: Anweisungen für die Verwendung von Crowdin zur Übersetzung von ethereum.org
+description: "Anweisungen für die Verwendung von Crowdin zur Übersetzung von ethereum.org"
---
# Wie man übersetzt {#how-to-translate}
diff --git a/public/content/translations/de/contributing/translation-program/index.md b/public/content/translations/de/contributing/translation-program/index.md
index 7f5afe17a01..beffe87aff5 100644
--- a/public/content/translations/de/contributing/translation-program/index.md
+++ b/public/content/translations/de/contributing/translation-program/index.md
@@ -1,7 +1,7 @@
---
-title: Übersetzungsprogramm
+title: "Übersetzungsprogramm"
lang: de
-description: Informationen zum Übersetzungsprogramm von ethereum.org
+description: "Informationen zum Übersetzungsprogramm von ethereum.org"
---
# Übersetzungsprogramm {#translation-program}
diff --git a/public/content/translations/de/contributing/translation-program/mission-and-vision/index.md b/public/content/translations/de/contributing/translation-program/mission-and-vision/index.md
index e5a2c8124af..d86f50672d7 100644
--- a/public/content/translations/de/contributing/translation-program/mission-and-vision/index.md
+++ b/public/content/translations/de/contributing/translation-program/mission-and-vision/index.md
@@ -1,7 +1,7 @@
---
title: Mission und Vision
lang: de
-description: Aufgabe und Vision des Übersetzungsprogramms von ethereum.org
+description: "Aufgabe und Vision des Übersetzungsprogramms von ethereum.org"
---
# Mission und Vision {#mission-and-vision}
diff --git a/public/content/translations/de/contributing/translation-program/playbook/index.md b/public/content/translations/de/contributing/translation-program/playbook/index.md
index 80e949ffa2c..b6499de8688 100644
--- a/public/content/translations/de/contributing/translation-program/playbook/index.md
+++ b/public/content/translations/de/contributing/translation-program/playbook/index.md
@@ -1,7 +1,7 @@
---
-title: Playbook für das Übersetzungsprogramm
+title: "Playbook für das Übersetzungsprogramm"
lang: de
-description: Eine Sammlung von Tipps und wichtigen Überlegungen für die Einrichtung eines Übersetzungsprogramms
+description: "Eine Sammlung von Tipps und wichtigen Überlegungen für die Einrichtung eines Übersetzungsprogramms"
---
# Playbook für das Übersetzungsprogramm {#translation-program-playbook}
diff --git a/public/content/translations/de/contributing/translation-program/resources/index.md b/public/content/translations/de/contributing/translation-program/resources/index.md
index f04de0de2fa..28f63ea315a 100644
--- a/public/content/translations/de/contributing/translation-program/resources/index.md
+++ b/public/content/translations/de/contributing/translation-program/resources/index.md
@@ -1,7 +1,7 @@
---
-title: Ressourcen für Übersetzer/Innen
+title: "Ressourcen für Übersetzer/Innen"
lang: de
-description: Nützliche Ressourcen für ethereum.org-Übersetzer
+description: "Nützliche Ressourcen für ethereum.org-Übersetzer"
---
# Ressourcen {#resources}
diff --git a/public/content/translations/de/contributing/translation-program/translatathon/details/index.md b/public/content/translations/de/contributing/translation-program/translatathon/details/index.md
index fd3c1d45b07..20868de51c0 100644
--- a/public/content/translations/de/contributing/translation-program/translatathon/details/index.md
+++ b/public/content/translations/de/contributing/translation-program/translatathon/details/index.md
@@ -1,7 +1,7 @@
---
title: Details und Regeln
lang: de
-template: Übersetzungsmarathon
+template: "Übersetzungsmarathon"
---
diff --git a/public/content/translations/de/contributing/translation-program/translators-guide/index.md b/public/content/translations/de/contributing/translation-program/translators-guide/index.md
index 4ee9f2a3c2a..1afb0e2703e 100644
--- a/public/content/translations/de/contributing/translation-program/translators-guide/index.md
+++ b/public/content/translations/de/contributing/translation-program/translators-guide/index.md
@@ -1,7 +1,7 @@
---
-title: Übersetzungsleitfaden
+title: "Übersetzungsleitfaden"
lang: de
-description: Anweisungen und Tipps für ethereum.org-Übersetzer
+description: "Anweisungen und Tipps für ethereum.org-Übersetzer"
---
# Ethereum.org Übersetzungsleitfaden {#style-guide}
diff --git a/public/content/translations/de/dao/index.md b/public/content/translations/de/dao/index.md
index 57f195b7951..976af4f1437 100644
--- a/public/content/translations/de/dao/index.md
+++ b/public/content/translations/de/dao/index.md
@@ -1,16 +1,16 @@
---
title: Was ist ein DAO?
metaTitle: Was ist ein DAO? | Dezentralisierte Autonome Organisation
-description: Eine Übersicht über DAOs auf Ethereum
+description: "Eine Übersicht über DAOs auf Ethereum"
lang: de
template: use-cases
emoji: ":handshake:"
sidebarDepth: 2
image: /images/use-cases/dao-2.png
-alt: Eine Repräsentation einer DAO, wie sie über einen Vorschlag abstimmt.
-summaryPoint1: Communitys im Besitz ihrer Mitglieder ohne zentralisierte Führung.
-summaryPoint2: Eine sichere Möglichkeit der Zusammenarbeit mit Fremden im Internet.
-summaryPoint3: Ein Ort, an dem sich Geldmittel für einen bestimmten Zweck sicher bereitstellen lassen.
+alt: "Eine Repräsentation einer DAO, wie sie über einen Vorschlag abstimmt."
+summaryPoint1: "Communitys im Besitz ihrer Mitglieder ohne zentralisierte Führung."
+summaryPoint2: "Eine sichere Möglichkeit der Zusammenarbeit mit Fremden im Internet."
+summaryPoint3: "Ein Ort, an dem sich Geldmittel für einen bestimmten Zweck sicher bereitstellen lassen."
---
## Was sind DAOs? {#what-are-daos}
diff --git a/public/content/translations/de/decentralized-identity/index.md b/public/content/translations/de/decentralized-identity/index.md
index cf54c55261c..c66aaa25964 100644
--- a/public/content/translations/de/decentralized-identity/index.md
+++ b/public/content/translations/de/decentralized-identity/index.md
@@ -1,13 +1,13 @@
---
-title: Dezentralisierte Identität
-description: Was ist eine dezentralisierte Identität und warum ist sie wichtig?
+title: "Dezentralisierte Identität"
+description: "Was ist eine dezentralisierte Identität und warum ist sie wichtig?"
lang: de
template: use-cases
emoji: ":id:"
sidebarDepth: 2
image: /images/eth-gif-cat.png
-summaryPoint1: Traditionelle Identitätssysteme haben die Ausgabe, Wartung und Kontrolle Ihrer Identifikatoren zentralisiert.
-summaryPoint2: Eine dezentralisierte Identität beseitigt die Abhängigkeit von zentralisierten Dritten.
+summaryPoint1: "Traditionelle Identitätssysteme haben die Ausgabe, Wartung und Kontrolle Ihrer Identifikatoren zentralisiert."
+summaryPoint2: "Eine dezentralisierte Identität beseitigt die Abhängigkeit von zentralisierten Dritten."
summaryPoint3: Dank Krypto haben Benutzer jetzt die Werkzeuge, um ihre eigenen Identifikatoren und Bescheinigungen wieder auszugeben, zu halten und zu kontrollieren.
---
@@ -107,16 +107,14 @@ Eine Attestierung ist ein Anspruch einer Entität gegenüber einer anderen Entit
Attestierungen unterscheiden sich von Identifikatoren. Eine Attestierung _enthält_ Identifikatoren, um auf eine bestimmte Identität zu verweisen, und macht eine Aussage über ein Attribut, das mit dieser Identität zusammenhängt. Ihr Führerschein hat also Identifikatoren (Name, Geburtsdatum, Adresse), ist aber zugleich auch die Attestierung Ihres gesetzlichen Fahrrechts.
-### Was sind dezentralisierte Identifikatoren? Was sind dezentralisierte Identifikatoren? {#what-are-decentralized-identifiers}
-
+### Was sind dezentralisierte Identifikatoren? {#what-are-decentralized-identifiers}
Klassische Identifikatoren, wie beispielsweise Ihr bürgerlicher Name oder Ihre E-Mail-Adresse, sind von Dritten abhängig - von Regierungen und E-Mail-Anbietern. Dezentralisierte Identifikatoren (DIDs) sind anders - sie werden nicht von einer zentralen Stelle ausgegeben, verwaltet oder kontrolliert.
Dezentralisierte Identifikatoren werden von Individuen ausgegeben, gehalten und kontrolliert. Ein [Ethereum-Konto](/glossary/#account) ist ein Beispiel für einen dezentralisierten Identifikator. Sie haben die Möglichkeit, so viele Konten zu erstellen, wie Sie möchten, ohne dass Sie eine Erlaubnis von Dritten benötigen und ohne dass diese Konten in einem zentralen Register gespeichert werden müssen.
Dezentralisierte Identifikatoren werden auf Distributed Ledgers ([Blockchains](/glossary/#blockchain)) oder in [Peer-to-Peer-Netzwerken](/glossary/#peer-to-peer-network) gespeichert. Dies macht DIDs [weltweit einzigartig, mit hoher Verfügbarkeit auflösbar und kryptografisch verifizierbar](https://w3c-ccg.github.io/did-primer/). Ein dezentralisierter Identifikator kann mit verschiedenen Entitäten verknüpft werden, darunter Personen, Organisationen oder staatliche Einrichtungen.
-## Was ermöglicht dezentralisierte Identifikatoren? Was ermöglicht dezentralisierte Identifikatoren? {#what-makes-decentralized-identifiers-possible}
-
+## Was ermöglicht dezentralisierte Identifikatoren? {#what-makes-decentralized-identifiers-possible}
### 1. Public-Key-Kryptografie {#public-key-cryptography}
Public-Key-Kryptografie ist eine Informationssicherheitsmaßnahme, die einen [öffentlichen Schlüssel](/glossary/#public-key) und einen [privaten Schlüssel](/glossary/#private-key) für eine Entität generiert. Public-Key-[Kryptografie](/glossary/#cryptography) wird in Blockchain-Netzwerken verwendet, um Benutzeridentitäten zu authentifizieren und den Besitz von digitalen Vermögenswerten nachzuweisen.
diff --git a/public/content/translations/de/defi/index.md b/public/content/translations/de/defi/index.md
index 7739b1c333d..5756747de70 100644
--- a/public/content/translations/de/defi/index.md
+++ b/public/content/translations/de/defi/index.md
@@ -1,7 +1,7 @@
---
title: Dezentrale Finanzen (DeFi)
-metaTitle: Was ist DeFi? | Vorteile und Einsatzmöglichkeiten der dezentralen Finanzwirtschaft
-description: Eine Übersicht über DeFi auf Ethereum
+metaTitle: "Was ist DeFi? | Vorteile und Einsatzmöglichkeiten der dezentralen Finanzwirtschaft"
+description: "Eine Übersicht über DeFi auf Ethereum"
lang: de
template: use-cases
emoji: ":money_with_wings:"
@@ -9,7 +9,7 @@ image: /images/use-cases/defi.png
alt: Ein ETH-Logo aus Legosteinen.
sidebarDepth: 2
summaryPoint1: Eine globale, offene Alternative zum aktuellen Finanzsystem.
-summaryPoint2: Produkte, mit denen Sie sich Geld leihen, sparen, investieren sowie Handel treiben können und mehr.
+summaryPoint2: "Produkte, mit denen Sie sich Geld leihen, sparen, investieren sowie Handel treiben können und mehr."
summaryPoint3: Die Grundlage bildet Open-Source-Technologie, mit der jeder programmieren kann.
---
@@ -67,7 +67,8 @@ Das klingt seltsam ... „Warum sollte ich mein Geld programmieren wollen?“ Da
- Machen Sie sich mit unseren Vorschlägen für DeFi-Anwendungen vertraut und testen sie, wenn Sie neu bei Ethereum sind.
+ Machen Sie sich mit unseren Vorschlägen für DeFi-Anwendungen vertraut und testen sie, wenn Sie neu bei Ethereum sind.
+
DeFi-Apps entdecken
diff --git a/public/content/translations/de/desci/index.md b/public/content/translations/de/desci/index.md
index 397e4ad0f3e..f53aab41e7d 100644
--- a/public/content/translations/de/desci/index.md
+++ b/public/content/translations/de/desci/index.md
@@ -1,6 +1,6 @@
---
title: Dezentrale Wissenschaft (DeSci)
-description: Eine Übersicht über dezentralisierte Wissenschaft auf Ethereum
+description: "Eine Übersicht über dezentralisierte Wissenschaft auf Ethereum"
lang: de
template: use-cases
emoji: ":microscope:"
@@ -8,7 +8,7 @@ sidebarDepth: 2
image: /images/future_transparent.png
alt: ""
summaryPoint1: Eine globale, offene Alternative zum derzeitigen wissenschaftlichen System.
-summaryPoint2: Technologie, die es Wissenschaftlern ermöglicht, Finanzierung zu erhalten, Experimente durchzuführen, Daten zu teilen, Erkenntnisse zu verbreiten und vieles mehr.
+summaryPoint2: "Technologie, die es Wissenschaftlern ermöglicht, Finanzierung zu erhalten, Experimente durchzuführen, Daten zu teilen, Erkenntnisse zu verbreiten und vieles mehr."
summaryPoint3: Baut auf der Open-Science-Bewegung auf.
---
diff --git a/public/content/translations/de/developers/docs/accounts/index.md b/public/content/translations/de/developers/docs/accounts/index.md
index e475beb3483..642fa1efa76 100644
--- a/public/content/translations/de/developers/docs/accounts/index.md
+++ b/public/content/translations/de/developers/docs/accounts/index.md
@@ -1,6 +1,6 @@
---
title: Ethereum-Konten
-description: Eine Erklärung der Ethereum-Konten – ihre Datenstrukturen und ihre Beziehung zur Schlüsselpaar-Kryptografie.
+description: "Eine Erklärung der Ethereum-Konten – ihre Datenstrukturen und ihre Beziehung zur Schlüsselpaar-Kryptografie."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/apis/backend/index.md b/public/content/translations/de/developers/docs/apis/backend/index.md
index cb1ef85c75a..385abdc0f15 100644
--- a/public/content/translations/de/developers/docs/apis/backend/index.md
+++ b/public/content/translations/de/developers/docs/apis/backend/index.md
@@ -1,6 +1,6 @@
---
title: Backend-API-Bibliotheken
-description: Eine Einführung in die Ethereum-Client-APIs, über die Sie mit der Blockchain Ihrer Anwendung interagieren können.
+description: "Eine Einführung in die Ethereum-Client-APIs, über die Sie mit der Blockchain Ihrer Anwendung interagieren können."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/apis/javascript/index.md b/public/content/translations/de/developers/docs/apis/javascript/index.md
index d07f1a48a71..03b2681dacf 100644
--- a/public/content/translations/de/developers/docs/apis/javascript/index.md
+++ b/public/content/translations/de/developers/docs/apis/javascript/index.md
@@ -1,6 +1,6 @@
---
title: JavaScript-API-Bibliotheken
-description: Eine Einführung in die JavaScript-Client-Bibliotheken, über die Sie von Ihrer Anwendung aus mit der Blockchain interagieren können.
+description: "Eine Einführung in die JavaScript-Client-Bibliotheken, über die Sie von Ihrer Anwendung aus mit der Blockchain interagieren können."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/apis/json-rpc/index.md b/public/content/translations/de/developers/docs/apis/json-rpc/index.md
index fe8d61cb2d4..19a3559f1b1 100644
--- a/public/content/translations/de/developers/docs/apis/json-rpc/index.md
+++ b/public/content/translations/de/developers/docs/apis/json-rpc/index.md
@@ -1,6 +1,6 @@
---
title: JSON-RPC-API
-description: Ein zustandsloses, leichtgewichtiges Remote Procedure Call (RPC)-Protokoll für Ethereum-Clients
+description: "Ein zustandsloses, leichtgewichtiges Remote Procedure Call (RPC)-Protokoll für Ethereum-Clients"
lang: de
---
diff --git a/public/content/translations/de/developers/docs/blocks/index.md b/public/content/translations/de/developers/docs/blocks/index.md
index e43277f95ce..f9f679d6fd0 100644
--- a/public/content/translations/de/developers/docs/blocks/index.md
+++ b/public/content/translations/de/developers/docs/blocks/index.md
@@ -1,6 +1,6 @@
---
-title: Blöcke
-description: Eine Übersicht über Blöcke in der Ethereum Blockchain – ihre Datenstruktur, warum sie benötigt werden und wie sie erstellt werden.
+title: "Blöcke"
+description: "Eine Übersicht über Blöcke in der Ethereum Blockchain – ihre Datenstruktur, warum sie benötigt werden und wie sie erstellt werden."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/bridges/index.md b/public/content/translations/de/developers/docs/bridges/index.md
index 032faded200..d7bfe7514ac 100644
--- a/public/content/translations/de/developers/docs/bridges/index.md
+++ b/public/content/translations/de/developers/docs/bridges/index.md
@@ -1,6 +1,6 @@
---
-title: Brücken
-description: Eine Übersicht über Bridging für Entwickler
+title: "Brücken"
+description: "Eine Übersicht über Bridging für Entwickler"
lang: de
---
diff --git a/public/content/translations/de/developers/docs/consensus-mechanisms/index.md b/public/content/translations/de/developers/docs/consensus-mechanisms/index.md
index 37989263990..48bb1e6854c 100644
--- a/public/content/translations/de/developers/docs/consensus-mechanisms/index.md
+++ b/public/content/translations/de/developers/docs/consensus-mechanisms/index.md
@@ -1,6 +1,6 @@
---
title: Konsensmechanismus
-description: Eine Erklärung von Konsensprotokollen in verteilten Systemen und die Rolle, die sie in Ethereum spielen.
+description: "Eine Erklärung von Konsensprotokollen in verteilten Systemen und die Rolle, die sie in Ethereum spielen."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/consensus-mechanisms/poa/index.md b/public/content/translations/de/developers/docs/consensus-mechanisms/poa/index.md
index fbcee98d7b3..7c42287fa10 100644
--- a/public/content/translations/de/developers/docs/consensus-mechanisms/poa/index.md
+++ b/public/content/translations/de/developers/docs/consensus-mechanisms/poa/index.md
@@ -1,6 +1,6 @@
---
title: Proof-of-Authority (PoA)
-description: Eine Erklärung des Proof-of-Authority-Konsensprotokolls und seiner Rolle im Blockchain-Ökosystem.
+description: "Eine Erklärung des Proof-of-Authority-Konsensprotokolls und seiner Rolle im Blockchain-Ökosystem."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/consensus-mechanisms/pos/attack-and-defense/index.md b/public/content/translations/de/developers/docs/consensus-mechanisms/pos/attack-and-defense/index.md
index 3cbe5ca7e4a..88ca01a0f42 100644
--- a/public/content/translations/de/developers/docs/consensus-mechanisms/pos/attack-and-defense/index.md
+++ b/public/content/translations/de/developers/docs/consensus-mechanisms/pos/attack-and-defense/index.md
@@ -1,6 +1,6 @@
---
title: Angriff und Verteidigung im Proof-of-Stake-System auf Ethereum
-description: Lernen Sie die bekannten Angriffsvektoren im Proof-of-Stake-System auf Ethereum kennen und wie diese abgewehrt werden können.
+description: "Lernen Sie die bekannten Angriffsvektoren im Proof-of-Stake-System auf Ethereum kennen und wie diese abgewehrt werden können."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/consensus-mechanisms/pos/block-proposal/index.md b/public/content/translations/de/developers/docs/consensus-mechanisms/pos/block-proposal/index.md
index 57ce55665e2..dd5e61e6053 100644
--- a/public/content/translations/de/developers/docs/consensus-mechanisms/pos/block-proposal/index.md
+++ b/public/content/translations/de/developers/docs/consensus-mechanisms/pos/block-proposal/index.md
@@ -1,6 +1,6 @@
---
title: Block-Vorschlag
-description: Erklärung, wie Blöcke unter Proof-of-Stake-Ethereum vorgeschlagen werden.
+description: "Erklärung, wie Blöcke unter Proof-of-Stake-Ethereum vorgeschlagen werden."
lang: de
---
@@ -10,8 +10,7 @@ Blöcke sind die grundlegenden Einheiten der Blockchain. Blöcke sind diskrete I
Block-Proposals sind Teil des Proof-of-Stake-Protokolls. Um diese Seite besser zu verstehen, empfehlen wir dir, die Artikel über [Proof-of-Stake](/developers/docs/consensus-mechanisms/pos/) und [Blockarchitektur](/developers/docs/blocks/) zu lesen.
-## Wer produziert Blöcke? Wer produziert Blöcke? {#who-produces-blocks}
-
+## Wer produziert Blöcke? {#who-produces-blocks}
Konten von Validatoren schlagen Blöcke vor. Die Konten von Validatoren werden von Node-Operatoren verwaltet, die Validatorensoftware als Teil ihrer Ausführungs- und Konsens-Clients betreiben und mindestens 32 ETH in den Einzahlungsvertrag transferiert haben. Allerdings ist jeder Validator nur gelegentlich für das Vorschlagen eines Blocks zuständig. Ethereum misst die Zeit in Slots und Epochen. Jeder Slot ist zwölf Sekunden lang und 32 Slots (6,4 Minuten) ergeben eine Epoche. Jeder Slot bietet eine Möglichkeit, Ethereum einen neuen Block hinzuzufügen.
### Zufällige Auswahl {#random-selection}
diff --git a/public/content/translations/de/developers/docs/consensus-mechanisms/pos/faqs/index.md b/public/content/translations/de/developers/docs/consensus-mechanisms/pos/faqs/index.md
index 2acc4bfddca..5519dd8a861 100644
--- a/public/content/translations/de/developers/docs/consensus-mechanisms/pos/faqs/index.md
+++ b/public/content/translations/de/developers/docs/consensus-mechanisms/pos/faqs/index.md
@@ -1,6 +1,6 @@
---
-title: Häufig gestellte Fragen
-description: Häufig gestellte Fragen zu Proof-of-Stake-Ethereum.
+title: "Häufig gestellte Fragen"
+description: "Häufig gestellte Fragen zu Proof-of-Stake-Ethereum."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/consensus-mechanisms/pos/gasper/index.md b/public/content/translations/de/developers/docs/consensus-mechanisms/pos/gasper/index.md
index ea807aaaf08..3f5078050f5 100644
--- a/public/content/translations/de/developers/docs/consensus-mechanisms/pos/gasper/index.md
+++ b/public/content/translations/de/developers/docs/consensus-mechanisms/pos/gasper/index.md
@@ -1,6 +1,6 @@
---
title: Gasper
-description: Eine Erklärung des Gasper-Proof-of-Stake-Mechanismus.
+description: "Eine Erklärung des Gasper-Proof-of-Stake-Mechanismus."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/consensus-mechanisms/pos/index.md b/public/content/translations/de/developers/docs/consensus-mechanisms/pos/index.md
index f6a91ed7fe1..b490527f617 100644
--- a/public/content/translations/de/developers/docs/consensus-mechanisms/pos/index.md
+++ b/public/content/translations/de/developers/docs/consensus-mechanisms/pos/index.md
@@ -1,6 +1,6 @@
---
title: Proof-of-Stake (PoS)
-description: Eine Erklärung des Proof-of-Stake-Konsensprotokolls und seiner Rolle in Ethereum.
+description: "Eine Erklärung des Proof-of-Stake-Konsensprotokolls und seiner Rolle in Ethereum."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/consensus-mechanisms/pos/keys/index.md b/public/content/translations/de/developers/docs/consensus-mechanisms/pos/keys/index.md
index bc4a267c9e6..388ec30fc75 100644
--- a/public/content/translations/de/developers/docs/consensus-mechanisms/pos/keys/index.md
+++ b/public/content/translations/de/developers/docs/consensus-mechanisms/pos/keys/index.md
@@ -1,6 +1,6 @@
---
-title: Schlüssel im Proof-of-Stake-System auf Ethereum
-description: Eine Erklärung der Schlüssel, die im Proof-of-Stake-Konsensmechanismus auf Ethereum verwendet werden
+title: "Schlüssel im Proof-of-Stake-System auf Ethereum"
+description: "Eine Erklärung der Schlüssel, die im Proof-of-Stake-Konsensmechanismus auf Ethereum verwendet werden"
lang: de
---
diff --git a/public/content/translations/de/developers/docs/consensus-mechanisms/pos/rewards-and-penalties/index.md b/public/content/translations/de/developers/docs/consensus-mechanisms/pos/rewards-and-penalties/index.md
index 16ee84d899a..fd550554de5 100644
--- a/public/content/translations/de/developers/docs/consensus-mechanisms/pos/rewards-and-penalties/index.md
+++ b/public/content/translations/de/developers/docs/consensus-mechanisms/pos/rewards-and-penalties/index.md
@@ -1,6 +1,6 @@
---
title: Proof-of-Stake-Belohnungen und -Bestrafungen
-description: Erfahren Sie mehr über die protokollinternen Anreize auf Proof-of-Stake-Ethereum.
+description: "Erfahren Sie mehr über die protokollinternen Anreize auf Proof-of-Stake-Ethereum."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/consensus-mechanisms/pos/weak-subjectivity/index.md b/public/content/translations/de/developers/docs/consensus-mechanisms/pos/weak-subjectivity/index.md
index c9f74d9125b..d3eaa3cc0ce 100644
--- a/public/content/translations/de/developers/docs/consensus-mechanisms/pos/weak-subjectivity/index.md
+++ b/public/content/translations/de/developers/docs/consensus-mechanisms/pos/weak-subjectivity/index.md
@@ -1,6 +1,6 @@
---
-title: Schwache Subjektivität
-description: Eine Erklärung zur schwachen Subjektivität und deren Rolle in PoS-Ethereum.
+title: "Schwache Subjektivität"
+description: "Eine Erklärung zur schwachen Subjektivität und deren Rolle in PoS-Ethereum."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/consensus-mechanisms/pow/index.md b/public/content/translations/de/developers/docs/consensus-mechanisms/pow/index.md
index c2520f5d121..b2237c797cd 100644
--- a/public/content/translations/de/developers/docs/consensus-mechanisms/pow/index.md
+++ b/public/content/translations/de/developers/docs/consensus-mechanisms/pow/index.md
@@ -1,6 +1,6 @@
---
title: Proof-of-Work (PoW)
-description: Eine Erklärung für das Proof-of-Work-Konsensprotokoll und seine Rolle in Ethereum.
+description: "Eine Erklärung für das Proof-of-Work-Konsensprotokoll und seine Rolle in Ethereum."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md b/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md
index ff1ddddd9a1..97288464e5a 100644
--- a/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md
+++ b/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md
@@ -8,7 +8,7 @@ lang: de
- Ethash war der Proof-of-Work-Mining-Algorithmus von Ethereum. Proof-of-Work wurde mittlerweile **komplett abgeschaltet** und Ethereum wird nun durch [Proof-of-Stake](/developers/docs/consensus-mechanisms/pos/) gesichert. Lesen Sie mehr über [The Merge](/roadmap/merge/), [Proof-of-Stake](/developers/docs/consensus-mechanisms/pos/) und [Staking](/staking/). Diese Seite dient dem geschichtlichen Interesse!
+ Ethash war der Proof-of-Work-Mining-Algorithmus von Ethereum. Proof-of-Work wurde mittlerweile **komplett abgeschaltet** und Ethereum wird nun durch [Proof-of-Stake](/developers/docs/consensus-mechanisms/pos/) gesichert. Lesen Sie mehr über [The Merge](/roadmap/merge/), [Proof-of-Stake](/developers/docs/consensus-mechanisms/pos/) und [Staking](/staking/). Diese Seite dient dem geschichtlichen Interesse!
diff --git a/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md b/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md
index edbaeff9b34..db148ba0338 100644
--- a/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md
+++ b/public/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md
@@ -1,6 +1,6 @@
---
title: Mining-Algorithmen
-description: Ein detailierter Einblick in die Algorithmen, welche für das Ethereum-Mining eingesetzt werden.
+description: "Ein detailierter Einblick in die Algorithmen, welche für das Ethereum-Mining eingesetzt werden."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/data-and-analytics/block-explorers/index.md b/public/content/translations/de/developers/docs/data-and-analytics/block-explorers/index.md
index a3c1c947e08..d60e9da65c0 100644
--- a/public/content/translations/de/developers/docs/data-and-analytics/block-explorers/index.md
+++ b/public/content/translations/de/developers/docs/data-and-analytics/block-explorers/index.md
@@ -1,6 +1,6 @@
---
title: Block Explorer
-description: Eine Einführung in Block-Explorer, Ihr Portal in die Welt der Blockchain-Daten – dort können Sie Informationen über Transaktionen, Konten, Verträge und mehr abfragen
+description: "Eine Einführung in Block-Explorer, Ihr Portal in die Welt der Blockchain-Daten – dort können Sie Informationen über Transaktionen, Konten, Verträge und mehr abfragen"
lang: de
sidebarDepth: 3
---
diff --git a/public/content/translations/de/developers/docs/data-and-analytics/index.md b/public/content/translations/de/developers/docs/data-and-analytics/index.md
index fb8c57f8d9d..aea0d047944 100644
--- a/public/content/translations/de/developers/docs/data-and-analytics/index.md
+++ b/public/content/translations/de/developers/docs/data-and-analytics/index.md
@@ -1,6 +1,6 @@
---
title: Daten und Analysen
-description: Wie man On-Chain-Analysen und Daten für die Nutzung in deinen dApps erhält
+description: "Wie man On-Chain-Analysen und Daten für die Nutzung in deinen dApps erhält"
lang: de
---
diff --git a/public/content/translations/de/developers/docs/data-availability/blockchain-data-storage-strategies/index.md b/public/content/translations/de/developers/docs/data-availability/blockchain-data-storage-strategies/index.md
index 8e36ef2ec27..d2357f54175 100644
--- a/public/content/translations/de/developers/docs/data-availability/blockchain-data-storage-strategies/index.md
+++ b/public/content/translations/de/developers/docs/data-availability/blockchain-data-storage-strategies/index.md
@@ -1,6 +1,6 @@
---
title: Blockchain-Datenspeicherungsstrategien
-description: Es gibt verschiedene Möglichkeiten, Daten mithilfe der Blockchain zu speichern. Dieser Artikel wird die verschiedenen Strategien, ihre Kosten und Kompromisse sowie die Anforderungen für eine sichere Nutzung vergleichen.
+description: "Es gibt verschiedene Möglichkeiten, Daten mithilfe der Blockchain zu speichern. Dieser Artikel wird die verschiedenen Strategien, ihre Kosten und Kompromisse sowie die Anforderungen für eine sichere Nutzung vergleichen."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/data-availability/index.md b/public/content/translations/de/developers/docs/data-availability/index.md
index ca7d4cb701e..1ca309affb4 100644
--- a/public/content/translations/de/developers/docs/data-availability/index.md
+++ b/public/content/translations/de/developers/docs/data-availability/index.md
@@ -1,6 +1,6 @@
---
-title: Datenverfügbarkeit
-description: Ein Überblick über Probleme und Lösungen im Zusammenhang mit der Datenverfügbarkeit bei Ethereum
+title: "Datenverfügbarkeit"
+description: "Ein Überblick über Probleme und Lösungen im Zusammenhang mit der Datenverfügbarkeit bei Ethereum"
lang: de
---
@@ -26,11 +26,11 @@ Die Datenverfügbarkeit ist auch ein kritisches Anliegen für zukünftige ["zust
Das Data Availability Sampling (DAS) ist eine Überprüfungsmethode des Netzwerkes für die Datenverfügbarkeit, ohne dass die Arbeitsbelastung für jeden Knoten übermäßig hoch ist. Jeder Knoten (einschließlich der Knoten, die nicht für das Staking benannt wurden) ermöglicht das zufällige Herunterladen eines Teils des Datensatzes. Das erfolgreiche Herunterladen der Beispiele bestätigt mit hoher Sicherheit, dass alle Daten verfügbar sind. Dies beruht auf Erasure Coding (Fehlerkorrekturverfahren), das einen gegebenen Datensatz um redundante Informationen erweitert (dies geschieht, indem eine als _Polynom_ bekannte Funktion über die Daten angepasst und dieses Polynom an zusätzlichen Punkten ausgewertet wird). Dadurch können die ursprünglichen Daten bei Bedarf auf einem Datensatz, wo mehrere Kopien erfasst werden, erneut abgedeckt werden. Eine Konsequenz dieser Datenerstellung ist, dass, wenn _irgendwelche_ der ursprünglichen Daten nicht verfügbar sind, die _Hälfte_ der erweiterten Daten fehlen wird! Die Menge der von jedem Node heruntergeladenen Datenstichproben kann so angepasst werden, dass es _extrem_ wahrscheinlich ist, dass mindestens eines der von jedem Client abgetasteten Datenfragmente fehlt, _falls_ weniger als die Hälfte der Daten wirklich verfügbar ist.
-DAS wird verwendet, um sicherzustellen, dass Rollup-Betreiber ihre Transaktionsdaten verfügbar machen, nachdem [Full Danksharding](/roadmap/danksharding/#what-is-danksharding) implementiert wurde. Unter Verwendung der redundanten Daten aus der obigen Tabelle als Beweis für die Existenz der Daten werden die zu beprobenden Transaktionsdaten von den Ethereum-Knoten zufällig ausgewählt, die Batch-Ladungen von Datengruppen einrichten. Diese Technik kann auch verwendet werden, um Blockproduzenten die Möglichkeit zu geben, ihre Daten zur Verfügung zu stellen, um <> zu schützen. In ähnlicher Weise wäre bei der [Trennung von Blockvorschlagendem und -ersteller (PBS)](/roadmap/pbs) nur der Blockersteller verpflichtet, einen ganzen Block zu verarbeiten – andere Validatoren würden die Verifizierung mittels Datenverfügbarkeits-Sampling durchführen.
+DAS wird verwendet, um sicherzustellen, dass Rollup-Betreiber ihre Transaktionsdaten verfügbar machen, nachdem [Full Danksharding](/roadmap/danksharding/#what-is-danksharding) implementiert wurde. Unter Verwendung der redundanten Daten aus der obigen Tabelle als Beweis für die Existenz der Daten werden die zu beprobenden Transaktionsdaten von den Ethereum-Knoten zufällig ausgewählt, die Batch-Ladungen von Datengruppen einrichten. Diese Technik kann auch verwendet werden, um Blockproduzenten die Möglichkeit zu geben, ihre Daten zur Verfügung zu stellen, um «light clients» zu schützen. In ähnlicher Weise wäre bei der [Trennung von Blockvorschlagendem und -ersteller (PBS)](/roadmap/pbs) nur der Blockersteller verpflichtet, einen ganzen Block zu verarbeiten – andere Validatoren würden die Verifizierung mittels Datenverfügbarkeits-Sampling durchführen.
### Datenverfügbarkeitskomitees {#data-availability-committees}
-Datenschutzausschüsse (DACs), sind Ausschüsse, die sich aus Interessengruppen zusammensetzen, sie betonen die Notwendigkeit, Informationen über die Verfügbarkeit von Daten bereitzustellen und zu gewährleisten. DACs können anstelle von [oder in Kombination mit](https://hackmd.io/@vbuterin/sharding_proposal#Why-not-use-just-committees-and-not-DAS) DAS verwendet werden. Die von den Ausschüssen gebotenen Sicherheitsgarantien hängen von ihrer Umsetzung ab. Ethereum verwendet zufällig ausgewählte Stichproben von Unterklassen von Prüfern, die die Verfügbarkeit von zum Beispiel <> zusichern.
+Datenschutzausschüsse (DACs), sind Ausschüsse, die sich aus Interessengruppen zusammensetzen, sie betonen die Notwendigkeit, Informationen über die Verfügbarkeit von Daten bereitzustellen und zu gewährleisten. DACs können anstelle von [oder in Kombination mit](https://hackmd.io/@vbuterin/sharding_proposal#Why-not-use-just-committees-and-not-DAS) DAS verwendet werden. Die von den Ausschüssen gebotenen Sicherheitsgarantien hängen von ihrer Umsetzung ab. Ethereum verwendet zufällig ausgewählte Stichproben von Unterklassen von Prüfern, die die Verfügbarkeit von zum Beispiel «light nodes» zusichern.
DACs werden auch von einigen Validiums eingesetzt. Der DAC ist ein vertrauenswürdiger Satz von Knoten, der Datenkopien offline speichert. Die Umsetzung der DAC-Richtlinie wird für die Bereitstellung von Daten im Streitfall verlangt. Mitglieder des DAC veröffentlichen außerdem Offchain Bescheinigungen, um zu beweisen, dass die besagten Daten tatsächlich verfügbar sind. Einige Validiums ersetzen die DACs durch ein Proof-of-Stake (PoS)-Validierungssystem. Hier kann jeder zum Validator werden und Daten außerhalb der Kette speichern. Dennoch basieren die Anforderungen an die Datenübertragung auf einer "Vereinbarung", die in einem digitalen Protokoll hinterlegt ist. Im Falle einer böswilligen Absicht, wie zum Beispiel im Falle eines Datenlecks des Validators, könnte diese Vereinbarung gekündigt werden. Aufgrund ihrer Rolle, die ehrliches Verhalten fördert, verfügen Datenschutzausschüsse, die auf der Proof-of-Stake Methode basieren, über einen erheblich sichereren Speicherplatz als DACs.
@@ -38,15 +38,15 @@ DACs werden auch von einigen Validiums eingesetzt. Der DAC ist ein vertrauenswü
[Light Nodes](/developers/docs/nodes-and-clients/light-clients) müssen die Korrektheit der Block-Header, die sie empfangen, validieren, ohne die Blockdaten herunterzuladen. Diese Leichtigkeit hat ihren Preis: die Unfähigkeit, die Köpfe des Blocks (block headers) unabhängig zu überprüfen, indem neue Transaktionen lokal durchgeführt werden, wie es die Vollknoten derzeit tun.
-Ethereum Light Nodes vertrauen auf zufällige Sätze von 512 Validatoren, die einem _Synchronisierungskomitee_ zugewiesen wurden. Das Sync-Komitee, das als programmierte Investition (DCA) fungiert, weist die <> darauf hin, dass sie durch die Verwendung eines kryptografischen Algorithmus die im Header enthaltenen Daten validieren können. Der Beratungsausschuss führt tägliche Auffrischungen durch. Jeder Block-Header informiert Light Nodes darüber, von welchen Validatoren die Unterzeichnung des _nächsten_ Blocks zu erwarten ist, sodass sie nicht dazu verleitet werden können, einer bösartigen Gruppe zu vertrauen, die vorgibt, das echte Synchronisierungskomitee zu sein.
+Ethereum Light Nodes vertrauen auf zufällige Sätze von 512 Validatoren, die einem _Synchronisierungskomitee_ zugewiesen wurden. Das Sync-Komitee, das als programmierte Investition (DCA) fungiert, weist die «Light Clients» darauf hin, dass sie durch die Verwendung eines kryptografischen Algorithmus die im Header enthaltenen Daten validieren können. Der Beratungsausschuss führt tägliche Auffrischungen durch. Jeder Block-Header informiert Light Nodes darüber, von welchen Validatoren die Unterzeichnung des _nächsten_ Blocks zu erwarten ist, sodass sie nicht dazu verleitet werden können, einer bösartigen Gruppe zu vertrauen, die vorgibt, das echte Synchronisierungskomitee zu sein.
-Was passiert jedoch, wenn es einem Angreifer irgendwie _doch_ gelingt, einen bösartigen Block-Header an Light Clients weiterzugeben und sie davon zu überzeugen, dass er von einem ehrlichen Synchronisierungskomitee unterzeichnet wurde? In diesem Fall könnte der Angreifer Transaktionen hinzufügen, die nicht gültig gemacht wurden, was den <> dazu veranlassen würde, ihnen blind zu vertrauen und sie zu validieren, da sie nicht in der Lage sind, die im Block Header aufgezeichneten Statusänderungen unabhängig zu überprüfen. Der <> kann Beweismittel anlegen, um sich vor Betrug zu schützen.
+Was passiert jedoch, wenn es einem Angreifer irgendwie _doch_ gelingt, einen bösartigen Block-Header an Light Clients weiterzugeben und sie davon zu überzeugen, dass er von einem ehrlichen Synchronisierungskomitee unterzeichnet wurde? In diesem Fall könnte der Angreifer Transaktionen hinzufügen, die nicht gültig gemacht wurden, was den «Light Client» dazu veranlassen würde, ihnen blind zu vertrauen und sie zu validieren, da sie nicht in der Lage sind, die im Block Header aufgezeichneten Statusänderungen unabhängig zu überprüfen. Der «light client » kann Beweismittel anlegen, um sich vor Betrug zu schützen.
-Wie werden diese Anfragen zur automatischen Reproduktion der Transaktion in der Praxis weitergegeben? Ein vollständiger Knoten stellt fest, dass im Netzwerk über einen ungültigen Zustandsübergang getratscht wird, und beschließt daher, sofort kleine Datendateien zu generieren, in denen der Beweis enthalten ist, dass der fragliche Zustandsübergang nicht Teil einer Reihe von eingereichten Transaktionen sein kann, und diese Daten an seine Peers weiterzuleiten. Die <> können hingehen und die Ergebnisse der letzten Anfrage zur automatischen Reproduktion der Transaktion (fraud proofs) abrufen, um bösartige Header zu erkennen. Dadurch wird sichergestellt, dass es sich bei den Akteuren, die an der Wartung der Kette beteiligt sind, um ehrliche Akteure handelt, wie es bei vollständigen Knoten der Fall ist.
+Wie werden diese Anfragen zur automatischen Reproduktion der Transaktion in der Praxis weitergegeben? Ein vollständiger Knoten stellt fest, dass im Netzwerk über einen ungültigen Zustandsübergang getratscht wird, und beschließt daher, sofort kleine Datendateien zu generieren, in denen der Beweis enthalten ist, dass der fragliche Zustandsübergang nicht Teil einer Reihe von eingereichten Transaktionen sein kann, und diese Daten an seine Peers weiterzuleiten. Die «light nodes» können hingehen und die Ergebnisse der letzten Anfrage zur automatischen Reproduktion der Transaktion (fraud proofs) abrufen, um bösartige Header zu erkennen. Dadurch wird sichergestellt, dass es sich bei den Akteuren, die an der Wartung der Kette beteiligt sind, um ehrliche Akteure handelt, wie es bei vollständigen Knoten der Fall ist.
Diese basieren auf vollständigen Knoten, die Zugriff auf die vollständigen Daten der Blöcke haben. Ein Angreifer, der einen bösartigen Block-Header übermittelt und es nicht schafft, die Transaktionsdaten verfügbar zu machen, wäre dann in der Lage, die Erstellung einer Anfrage zur automatischen Reproduktion der Transaktion durch die vollständigen Knoten zu verhindern. Die vollständigen Knoten könnten zwar eine Warnung vor einem fehlerhaften Block signalisieren, sie könnten ihre Warnung jedoch nicht mit Beweisen untermauern, da die Daten zur Generierung des Beweises nicht zur Verfügung gestellt wurden!
-DAS: Die Lösung für das Problem der Datenverfügbarkeit. Die <> greifen auf vollständige Daten zurück, die aktualisiert wurden, um sehr kleine Blobs mit zufälligen Daten herunterladen zu können, die als Muster verwendet werden, um die Verfügbarkeit aller vollständigen Daten zu gewährleisten. Die tatsächliche Wahrscheinlichkeit, nach dem Herunterladen von N zufälligen Chunks fälschlicherweise von einer vollständigen Datenverfügbarkeit auszugehen, kann berechnet werden ([bei 100 Chunks liegt die Wahrscheinlichkeit bei 10^-30](https://dankradfeist.de/ethereum/2019/12/20/data-availability-checks.html), d. h. sie ist unglaublich gering).
+DAS: Die Lösung für das Problem der Datenverfügbarkeit. Die «light nodes» greifen auf vollständige Daten zurück, die aktualisiert wurden, um sehr kleine Blobs mit zufälligen Daten herunterladen zu können, die als Muster verwendet werden, um die Verfügbarkeit aller vollständigen Daten zu gewährleisten. Die tatsächliche Wahrscheinlichkeit, nach dem Herunterladen von N zufälligen Chunks fälschlicherweise von einer vollständigen Datenverfügbarkeit auszugehen, kann berechnet werden ([bei 100 Chunks liegt die Wahrscheinlichkeit bei 10^-30](https://dankradfeist.de/ethereum/2019/12/20/data-availability-checks.html), d. h. sie ist unglaublich gering).
Doch selbst unter diesem Szenario könnten Angriffe, die nur wenige Bytes zurückhalten, durchaus von den Kunden unbemerkt bleiben, die ihrerseits Abfragen mit zufälligen Daten stellen könnten. Löschen Coding behebt dieses Problem, indem es kleine fehlende Datenteile rekonstruiert, die zur Überprüfung vorgeschlagener Statusänderungen verwendet werden können. Mithilfe der rekonstruierten Daten könnte dann ein Betrugsnachweis erstellt werden, der verhindert, dass Light Nodes fehlerhafte Header akzeptieren.
diff --git a/public/content/translations/de/developers/docs/data-structures-and-encoding/index.md b/public/content/translations/de/developers/docs/data-structures-and-encoding/index.md
index bec0f01ae3f..6118423e1f0 100644
--- a/public/content/translations/de/developers/docs/data-structures-and-encoding/index.md
+++ b/public/content/translations/de/developers/docs/data-structures-and-encoding/index.md
@@ -1,6 +1,6 @@
---
title: Datenstrukturen und Kodierung
-description: Eine Übersicht über die grundlegenden Ethereum-Datenstrukturen.
+description: "Eine Übersicht über die grundlegenden Ethereum-Datenstrukturen."
lang: de
sidebarDepth: 2
---
diff --git a/public/content/translations/de/developers/docs/data-structures-and-encoding/patricia-merkle-trie/index.md b/public/content/translations/de/developers/docs/data-structures-and-encoding/patricia-merkle-trie/index.md
index 1525651bd56..e4d8a3af088 100644
--- a/public/content/translations/de/developers/docs/data-structures-and-encoding/patricia-merkle-trie/index.md
+++ b/public/content/translations/de/developers/docs/data-structures-and-encoding/patricia-merkle-trie/index.md
@@ -1,6 +1,6 @@
---
title: Merkle Patricia Trie
-description: Einführung in Merkle Patricia Trie.
+description: "Einführung in Merkle Patricia Trie."
lang: de
sidebarDepth: 2
---
@@ -79,7 +79,7 @@ Radix tries haben eine große Einschränkung: Sie sind ineffizient. Wenn Sie ein
Ein Knoten in einem Merkle Patricia Trie ist einer der folgenden:
1. `NULL` (dargestellt als leere Zeichenfolge)
-2. `branch` Ein 17-elementiger Knoten `[ v0 ...` v15, vt ]\`
+2. `branch` Ein 17-elementiger Knoten `[ v0 ...` v15, vt ]`
3. `leaf` Ein 2-elementiger Knoten `[ encodedPath, value ]`
4. `extension` Ein 2-elementiger Knoten `[ encodedPath, key ]`
diff --git a/public/content/translations/de/developers/docs/data-structures-and-encoding/rlp/index.md b/public/content/translations/de/developers/docs/data-structures-and-encoding/rlp/index.md
index cc95b6bef56..f608eb30064 100644
--- a/public/content/translations/de/developers/docs/data-structures-and-encoding/rlp/index.md
+++ b/public/content/translations/de/developers/docs/data-structures-and-encoding/rlp/index.md
@@ -1,6 +1,6 @@
---
title: RLP Serialisierung (Recursive Length Prefix)
-description: Eine Definition der RLP-Kodierung in der Ausführungsschicht von Ethereum.
+description: "Eine Definition der RLP-Kodierung in der Ausführungsschicht von Ethereum."
lang: de
sidebarDepth: 2
---
diff --git a/public/content/translations/de/developers/docs/data-structures-and-encoding/ssz/index.md b/public/content/translations/de/developers/docs/data-structures-and-encoding/ssz/index.md
index 96ca799aab9..f53dfebf338 100644
--- a/public/content/translations/de/developers/docs/data-structures-and-encoding/ssz/index.md
+++ b/public/content/translations/de/developers/docs/data-structures-and-encoding/ssz/index.md
@@ -1,6 +1,6 @@
---
title: Einfache Serialisierung
-description: Erklärung des SSZ Formats von Ethereum.
+description: "Erklärung des SSZ Formats von Ethereum."
lang: de
sidebarDepth: 2
---
diff --git a/public/content/translations/de/developers/docs/data-structures-and-encoding/web3-secret-storage/index.md b/public/content/translations/de/developers/docs/data-structures-and-encoding/web3-secret-storage/index.md
index 20665ad9a32..0e1b092e551 100644
--- a/public/content/translations/de/developers/docs/data-structures-and-encoding/web3-secret-storage/index.md
+++ b/public/content/translations/de/developers/docs/data-structures-and-encoding/web3-secret-storage/index.md
@@ -1,6 +1,6 @@
---
title: Speicherdefinition von Web3-Geheimnis
-description: Formale Definition für die geheime Speicherung von Web3
+description: "Formale Definition für die geheime Speicherung von Web3"
lang: de
sidebarDepth: 2
---
diff --git a/public/content/translations/de/developers/docs/design-and-ux/dex-design-best-practice/index.md b/public/content/translations/de/developers/docs/design-and-ux/dex-design-best-practice/index.md
index d0e14d0bc55..ebe0dc78f4c 100644
--- a/public/content/translations/de/developers/docs/design-and-ux/dex-design-best-practice/index.md
+++ b/public/content/translations/de/developers/docs/design-and-ux/dex-design-best-practice/index.md
@@ -1,6 +1,6 @@
---
-title: Bewährte Praktiken für das Design von dezentralen Börsen (DEX)
-description: Ein Leitfaden, der UX/UI-Entscheidungen für das Tauschen von Tokens erklärt.
+title: "Bewährte Praktiken für das Design von dezentralen Börsen (DEX)"
+description: "Ein Leitfaden, der UX/UI-Entscheidungen für das Tauschen von Tokens erklärt."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/design-and-ux/heuristics-for-web3/index.md b/public/content/translations/de/developers/docs/design-and-ux/heuristics-for-web3/index.md
index 3b8a508b5d5..5839f71f90b 100644
--- a/public/content/translations/de/developers/docs/design-and-ux/heuristics-for-web3/index.md
+++ b/public/content/translations/de/developers/docs/design-and-ux/heuristics-for-web3/index.md
@@ -1,6 +1,6 @@
---
-title: 7 Heuristiken für das Design von Web3-Schnittstellen
-description: Grundsätze zur Verbesserung der Benutzerfreundlichkeit von Web3
+title: "7 Heuristiken für das Design von Web3-Schnittstellen"
+description: "Grundsätze zur Verbesserung der Benutzerfreundlichkeit von Web3"
lang: de
---
diff --git a/public/content/translations/de/developers/docs/design-and-ux/index.md b/public/content/translations/de/developers/docs/design-and-ux/index.md
index ff950149d1a..4e0dde6f635 100644
--- a/public/content/translations/de/developers/docs/design-and-ux/index.md
+++ b/public/content/translations/de/developers/docs/design-and-ux/index.md
@@ -1,6 +1,6 @@
---
title: Design und UX in Web3
-description: Einführung in UX-Design und -Forschung im Web3-Bereich und Ethereum
+description: "Einführung in UX-Design und -Forschung im Web3-Bereich und Ethereum"
lang: de
---
diff --git a/public/content/translations/de/developers/docs/development-networks/index.md b/public/content/translations/de/developers/docs/development-networks/index.md
index ef9ea6ac8cc..a55d94b10b5 100644
--- a/public/content/translations/de/developers/docs/development-networks/index.md
+++ b/public/content/translations/de/developers/docs/development-networks/index.md
@@ -1,6 +1,6 @@
---
title: Entwicklungsnetzwerke
-description: Eine Übersicht über Entwicklungsnetzwerke und die zur Erstellung von Ethereum-Anwendungen verfügbaren Tools
+description: "Eine Übersicht über Entwicklungsnetzwerke und die zur Erstellung von Ethereum-Anwendungen verfügbaren Tools"
lang: de
---
diff --git a/public/content/translations/de/developers/docs/ethereum-stack/index.md b/public/content/translations/de/developers/docs/ethereum-stack/index.md
index b40a1e9533f..847690cb554 100644
--- a/public/content/translations/de/developers/docs/ethereum-stack/index.md
+++ b/public/content/translations/de/developers/docs/ethereum-stack/index.md
@@ -1,5 +1,5 @@
---
-title: Einführung in den Ethereum-Stack
+title: "Einführung in den Ethereum-Stack"
description: Eine Vorstellung der verschiedenen Ebenen des Ethereum-Stacks und wie sie zusammen passen
lang: de
---
diff --git a/public/content/translations/de/developers/docs/evm/index.md b/public/content/translations/de/developers/docs/evm/index.md
index e9dec99b553..a0ecbdd3412 100644
--- a/public/content/translations/de/developers/docs/evm/index.md
+++ b/public/content/translations/de/developers/docs/evm/index.md
@@ -1,6 +1,6 @@
---
title: Ethereum Virtuelle Maschine (EVM)
-description: Eine Einführung in die virtuelle Maschine von Ethereum und wie sie sich auf Zustand, Transaktionen und Smart Contracts bezieht.
+description: "Eine Einführung in die virtuelle Maschine von Ethereum und wie sie sich auf Zustand, Transaktionen und Smart Contracts bezieht."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/evm/opcodes/index.md b/public/content/translations/de/developers/docs/evm/opcodes/index.md
index a59b15c4543..a4e62fe6bc8 100644
--- a/public/content/translations/de/developers/docs/evm/opcodes/index.md
+++ b/public/content/translations/de/developers/docs/evm/opcodes/index.md
@@ -1,6 +1,6 @@
---
-title: Opcodes für die EVM
-description: Eine Liste aller verfügbaren Opcodes für die virtuelle Ethereum-Maschine (EVM).
+title: "Opcodes für die EVM"
+description: "Eine Liste aller verfügbaren Opcodes für die virtuelle Ethereum-Maschine (EVM)."
lang: de
---
@@ -84,7 +84,7 @@ Für Operationen mit dynamischen Gaskosten, siehe [gas.md](https://github.com/wo
| 54 | SLOAD | [A6](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a6-sload) | `key` | `storage[key]` | | Wort aus dem Speicher lesen | |
| 55 | SSTORE | [A7](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a7-sstore) | `key, val` | `.` | storage[key] := val | Wort in den Speicher schreiben | |
| 56 | JUMP | 8 | `dst` | `.` | | `$pc := dst` markiert, dass `pc` nur zugewiesen wird, wenn `dst` ein gültiges Sprungziel ist | |
-| 57 | JUMPI | 10 | `dst, condition` | `.` | | `$pc := condition ?` dst : $pc + 1\` | |
+| 57 | JUMPI | 10 | `dst, condition` | `.` | | `$pc := condition ?` dst : $pc + 1` | |
| 58 | PC | 2 | `.` | `$pc` | | Programm-Zähler | |
| 59 | MSIZE | 2 | `.` | `len(mem)` | | Größe des Speichers im aktuellen Ausführungskontext, in Bytes | |
| 5A | GAS | 2 | `.` | `gasRemaining` | | | |
diff --git a/public/content/translations/de/developers/docs/frameworks/index.md b/public/content/translations/de/developers/docs/frameworks/index.md
index 170f4b6fe13..649a1f8648e 100644
--- a/public/content/translations/de/developers/docs/frameworks/index.md
+++ b/public/content/translations/de/developers/docs/frameworks/index.md
@@ -1,6 +1,6 @@
---
title: dApp-Entwicklungs-Frameworks
-description: Mehr über die Vorteile von Frameworks erfahren und verfügbare Optionen vergleichen
+description: "Mehr über die Vorteile von Frameworks erfahren und verfügbare Optionen vergleichen"
lang: de
---
diff --git a/public/content/translations/de/developers/docs/gas/index.md b/public/content/translations/de/developers/docs/gas/index.md
index e308182b49e..f8360afde1c 100644
--- a/public/content/translations/de/developers/docs/gas/index.md
+++ b/public/content/translations/de/developers/docs/gas/index.md
@@ -1,7 +1,7 @@
---
-title: Gas und Gebühren
+title: "Gas und Gebühren"
metaTitle: "Ethereum Gas und Gebühren: Technische Übersicht"
-description: Informieren Sie sich über die Ethereum Gasgebühren, wie sie berechnet werden und welche Rolle sie für die Netzwerksicherheit und Transaktionsverarbeitung spielen.
+description: "Informieren Sie sich über die Ethereum Gasgebühren, wie sie berechnet werden und welche Rolle sie für die Netzwerksicherheit und Transaktionsverarbeitung spielen."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/ides/index.md b/public/content/translations/de/developers/docs/ides/index.md
index ef4c4ddbcd7..23bed3005a3 100644
--- a/public/content/translations/de/developers/docs/ides/index.md
+++ b/public/content/translations/de/developers/docs/ides/index.md
@@ -1,6 +1,6 @@
---
title: Integrierte Entwicklungsumgebungen (Integrated Development Environments, IDEs)
-description: Erfahren Sie mehr über webbasierte und Desktop IDEs für die Ethereum-Entwicklung, einschließlich Remix, VS Code und beliebte Plugins.
+description: "Erfahren Sie mehr über webbasierte und Desktop IDEs für die Ethereum-Entwicklung, einschließlich Remix, VS Code und beliebte Plugins."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/index.md b/public/content/translations/de/developers/docs/index.md
index 562e927953b..542dee198da 100644
--- a/public/content/translations/de/developers/docs/index.md
+++ b/public/content/translations/de/developers/docs/index.md
@@ -1,6 +1,6 @@
---
title: Dokumentation zur Ethereum-Entwicklung
-description: Einführung in die Entwicklerdokumentation zu ethereum.org.
+description: "Einführung in die Entwicklerdokumentation zu ethereum.org."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/intro-to-ether/index.md b/public/content/translations/de/developers/docs/intro-to-ether/index.md
index 628465f8af4..f899bd08bd8 100644
--- a/public/content/translations/de/developers/docs/intro-to-ether/index.md
+++ b/public/content/translations/de/developers/docs/intro-to-ether/index.md
@@ -1,6 +1,6 @@
---
title: "Ether: Eine technische Einführung"
-description: Eine Einführung für Entwickler in die Kryptowährung Ether.
+description: "Eine Einführung für Entwickler in die Kryptowährung Ether."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/intro-to-ethereum/index.md b/public/content/translations/de/developers/docs/intro-to-ethereum/index.md
index 293cb831280..ff4d3f77c59 100644
--- a/public/content/translations/de/developers/docs/intro-to-ethereum/index.md
+++ b/public/content/translations/de/developers/docs/intro-to-ethereum/index.md
@@ -1,6 +1,6 @@
---
-title: Technische Einführung zu Ethereum
-description: Die Einführung eines dApp Entwicklers in die Kernkonzepte von Ethereum.
+title: "Technische Einführung zu Ethereum"
+description: "Die Einführung eines dApp Entwicklers in die Kernkonzepte von Ethereum."
lang: de
---
@@ -42,8 +42,7 @@ Die Höhe der gezahlten ETH entspricht den für die Berechnung benötigten Resso
ETH wird auch verwendet, um dem Netzwerk auf drei Arten kryptoökonomische Sicherheit zu geben: 1) Es wird als Mittel zur Belohnung von Validierern verwendet, die Blöcke vorschlagen oder unehrliches Verhalten anderer Validierer aufdecken; 2) Es wird von Validierern als Sicherheit gegen unehrliches Verhalten eingesetzt – wenn Validierer versuchen, sich falsch zu verhalten, kann das die Zerstörung ihrer ETH zur Folge haben; 3) Es wird verwendet, um "Stimmen" für neu vorgeschlagene Blöcke abzuwägen, was in die Fork-Auswahl des Konsensmechanismus einfließt.
-## Was sind Smart Contracts? Was sind Smart Contracts? {#what-are-smart-contracts}
-
+## Was sind Smart Contracts? {#what-are-smart-contracts}
In der Praxis schreiben die Teilnehmenden nicht jedes Mal einen neuen Code, wenn sie eine Berechnung auf der EVM anfordern wollen. Vielmehr laden Anwendungsentwickler Programme (wiederverwendbare Codeschnipsel) in den EVM-Speicher hoch, und die Nutzer stellen Anfragen, um diese Codeschnipsel mit unterschiedlichen Parametern auszuführen. Wir nennen die Programme, die in das Netzwerk hochgeladen und von diesem ausgeführt werden, "Smart Contracts".
Ganz grundsätzlich können Sie sich einen Smart Contract wie eine Art Verkaufsautomat vorstellen: ein Skript, das, wenn es mit bestimmten Parametern aufgerufen wird, bestimmte Aktionen oder Berechnungen durchführt, wenn bestimmte Bedingungen erfüllt sind. Zum Beispiel könnte ein einfacher Verkäufer-Smart-Contract das Eigentum an einem digitalen Vermögenswert schaffen und zuweisen, wenn der Aufrufer ("caller") ETH an einen bestimmten Empfänger sendet.
diff --git a/public/content/translations/de/developers/docs/mev/index.md b/public/content/translations/de/developers/docs/mev/index.md
index f69d2a9d96b..d31f6f9fb77 100644
--- a/public/content/translations/de/developers/docs/mev/index.md
+++ b/public/content/translations/de/developers/docs/mev/index.md
@@ -1,6 +1,6 @@
---
title: Maximal extrahierbarer Wert (MEV)
-description: Einführung in den maximal extrahierbaren Wert (MEV)
+description: "Einführung in den maximal extrahierbaren Wert (MEV)"
lang: de
---
diff --git a/public/content/translations/de/developers/docs/networking-layer/index.md b/public/content/translations/de/developers/docs/networking-layer/index.md
index 5920b64b400..07be495162c 100644
--- a/public/content/translations/de/developers/docs/networking-layer/index.md
+++ b/public/content/translations/de/developers/docs/networking-layer/index.md
@@ -1,6 +1,6 @@
---
title: Netzwerkebene
-description: Eine Einführung in die Netzwerkschicht von Ethereum.
+description: "Eine Einführung in die Netzwerkschicht von Ethereum."
lang: de
sidebarDepth: 2
---
diff --git a/public/content/translations/de/developers/docs/networking-layer/network-addresses/index.md b/public/content/translations/de/developers/docs/networking-layer/network-addresses/index.md
index cfcf8b36275..ae26329711d 100644
--- a/public/content/translations/de/developers/docs/networking-layer/network-addresses/index.md
+++ b/public/content/translations/de/developers/docs/networking-layer/network-addresses/index.md
@@ -1,6 +1,6 @@
---
title: Netzwerkadressen
-description: Eine Einführung in Netzwerkadressen.
+description: "Eine Einführung in Netzwerkadressen."
lang: de
sidebarDepth: 2
---
diff --git a/public/content/translations/de/developers/docs/networking-layer/portal-network/index.md b/public/content/translations/de/developers/docs/networking-layer/portal-network/index.md
index cfb59858864..cc9cf568464 100644
--- a/public/content/translations/de/developers/docs/networking-layer/portal-network/index.md
+++ b/public/content/translations/de/developers/docs/networking-layer/portal-network/index.md
@@ -1,6 +1,6 @@
---
title: Das Portal-Netzwerk
-description: Ein Überblick über das Portal-Netzwerk – ein in der Entwicklung befindliches Netzwerk, das für die Unterstützung von Clients mit geringen Ressourcen konzipiert ist.
+description: "Ein Überblick über das Portal-Netzwerk – ein in der Entwicklung befindliches Netzwerk, das für die Unterstützung von Clients mit geringen Ressourcen konzipiert ist."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/networks/index.md b/public/content/translations/de/developers/docs/networks/index.md
index 3bc8ccb1db0..28bd92b7154 100644
--- a/public/content/translations/de/developers/docs/networks/index.md
+++ b/public/content/translations/de/developers/docs/networks/index.md
@@ -1,6 +1,6 @@
---
title: Netzwerke
-description: Eine Übersicht über Ethereums Netzwerke und wo man Testnet Ether (ETH) zum Testen neuer Anwendungen bekommt.
+description: "Eine Übersicht über Ethereums Netzwerke und wo man Testnet Ether (ETH) zum Testen neuer Anwendungen bekommt."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/nodes-and-clients/archive-nodes/index.md b/public/content/translations/de/developers/docs/nodes-and-clients/archive-nodes/index.md
index 5f482659143..99089619cac 100644
--- a/public/content/translations/de/developers/docs/nodes-and-clients/archive-nodes/index.md
+++ b/public/content/translations/de/developers/docs/nodes-and-clients/archive-nodes/index.md
@@ -1,6 +1,6 @@
---
title: Ethereum-Archivierungsknoten
-description: Ein Überblick über Archivierungsknoten
+description: "Ein Überblick über Archivierungsknoten"
lang: de
sidebarDepth: 2
---
diff --git a/public/content/translations/de/developers/docs/nodes-and-clients/bootnodes/index.md b/public/content/translations/de/developers/docs/nodes-and-clients/bootnodes/index.md
index ffbb4432a25..f3770e3a608 100644
--- a/public/content/translations/de/developers/docs/nodes-and-clients/bootnodes/index.md
+++ b/public/content/translations/de/developers/docs/nodes-and-clients/bootnodes/index.md
@@ -1,6 +1,6 @@
---
-title: Einführung zu Ethereum Bootnodes
-description: Grundlegend benötigte Informationen zum Verständnis von Bootnodes
+title: "Einführung zu Ethereum Bootnodes"
+description: "Grundlegend benötigte Informationen zum Verständnis von Bootnodes"
lang: de
---
diff --git a/public/content/translations/de/developers/docs/nodes-and-clients/client-diversity/index.md b/public/content/translations/de/developers/docs/nodes-and-clients/client-diversity/index.md
index b2109e4bb72..cf5d5d8d646 100644
--- a/public/content/translations/de/developers/docs/nodes-and-clients/client-diversity/index.md
+++ b/public/content/translations/de/developers/docs/nodes-and-clients/client-diversity/index.md
@@ -1,6 +1,6 @@
---
-title: Client-Diversität
-description: Eine ausführliche Erklärung über die Bedeutung der Client-Vielfalt für Ethereum.
+title: "Client-Diversität"
+description: "Eine ausführliche Erklärung über die Bedeutung der Client-Vielfalt für Ethereum."
lang: de
sidebarDepth: 2
---
diff --git a/public/content/translations/de/developers/docs/nodes-and-clients/index.md b/public/content/translations/de/developers/docs/nodes-and-clients/index.md
index 53574a4a8de..7187ec44729 100644
--- a/public/content/translations/de/developers/docs/nodes-and-clients/index.md
+++ b/public/content/translations/de/developers/docs/nodes-and-clients/index.md
@@ -1,6 +1,6 @@
---
title: Knotenpunkte (Nodes) und Anwendungen (Clients)
-description: Eine Übersicht über Ethereum-Nodes und Client-Software, wie eine Node eingerichtet wird und warum Sie dies tun sollten.
+description: "Eine Übersicht über Ethereum-Nodes und Client-Software, wie eine Node eingerichtet wird und warum Sie dies tun sollten."
lang: de
sidebarDepth: 2
---
@@ -84,8 +84,7 @@ Es gibt auch potenzielle Wege, um Light-Client-Daten über das [Gossip-Netzwerk]
Ethereum unterstützt noch keine große Population von leichten Nodes, jedoch ist die Unterstützung von leichten Nodes ein Bereich, der sich in naher Zukunft voraussichtlich schnell entwickeln wird. Insbesondere Clients wie [Nimbus](https://nimbus.team/), [Helios](https://github.com/a16z/helios) und [LodeStar](https://lodestar.chainsafe.io/) konzentrieren sich derzeit stark auf Light Nodes.
-## Warum sollte ich einen Ethereum-Node betreiben? Warum sollte ich einen Ethereum-Node betreiben? {#why-should-i-run-an-ethereum-node}
-
+## Warum sollte ich einen Ethereum-Node betreiben? {#why-should-i-run-an-ethereum-node}
Der Betrieb eines eigenen Knotens ermöglicht es Ihnen, Ethereum auf private, autarke und vertrauenswürdige Weise zu nutzen und gleichzeitig das Netz zu unterstützen, da es so robuster und dezentraler wird.
### Ihre Vorteile {#benefits-to-you}
diff --git a/public/content/translations/de/developers/docs/nodes-and-clients/light-clients/index.md b/public/content/translations/de/developers/docs/nodes-and-clients/light-clients/index.md
index 6402dff7e15..8879e93c0ba 100644
--- a/public/content/translations/de/developers/docs/nodes-and-clients/light-clients/index.md
+++ b/public/content/translations/de/developers/docs/nodes-and-clients/light-clients/index.md
@@ -1,6 +1,6 @@
---
title: Leichte Clients
-description: Einführung zu leichten Clients von Ethereum.
+description: "Einführung zu leichten Clients von Ethereum."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/nodes-and-clients/nodes-as-a-service/index.md b/public/content/translations/de/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
index 194988608b5..84329082e3b 100644
--- a/public/content/translations/de/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
+++ b/public/content/translations/de/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
@@ -1,6 +1,6 @@
---
title: Nodes als Dienstleistung
-description: Eine Einstiegsübersicht über Node-Dienste, die Vor- und Nachteile und beliebte Anbieter.
+description: "Eine Einstiegsübersicht über Node-Dienste, die Vor- und Nachteile und beliebte Anbieter."
lang: de
sidebarDepth: 2
---
diff --git a/public/content/translations/de/developers/docs/nodes-and-clients/run-a-node/index.md b/public/content/translations/de/developers/docs/nodes-and-clients/run-a-node/index.md
index d936d7faf20..b17b1724af5 100644
--- a/public/content/translations/de/developers/docs/nodes-and-clients/run-a-node/index.md
+++ b/public/content/translations/de/developers/docs/nodes-and-clients/run-a-node/index.md
@@ -1,6 +1,6 @@
---
title: Errichten Sie Ihren eigenen Ethereum-Node
-description: Allgemeine Einführung in den Betrieb einer eigenen Ethereum-Client-Instanz.
+description: "Allgemeine Einführung in den Betrieb einer eigenen Ethereum-Client-Instanz."
lang: de
sidebarDepth: 2
---
@@ -236,7 +236,7 @@ Dieser Abschnitt führt Sie durch die Einrichtung eines Ausführungsclients. Er
Bitte beachten Sie, dass dies nur ein einfaches Beispiel ist, alle anderen Einstellungen werden auf die Standardeinstellung gesetzt. Beachten Sie die Dokumentation der einzelnen Clients, um sich über standardmäßige Werte, Einstellungen und Funktionen zu informieren. Weitere Funktionen, z. B. zur Ausführung von Validatoren, zur Überwachung usw., finden Sie in der Dokumentation des jeweiligen Clients.
-> Beachten Sie, dass die Backslashes `\` in den Beispielen nur zu Formatierungszwecken dienen; Konfigurations-Flags können in einer einzigen Zeile definiert werden.
+> Beachten Sie, dass die Backslashes `` in den Beispielen nur zu Formatierungszwecken dienen; Konfigurations-Flags können in einer einzigen Zeile definiert werden.
##### Ausführen von Besu
diff --git a/public/content/translations/de/developers/docs/oracles/index.md b/public/content/translations/de/developers/docs/oracles/index.md
index 315bd1e9376..b1748597bd1 100644
--- a/public/content/translations/de/developers/docs/oracles/index.md
+++ b/public/content/translations/de/developers/docs/oracles/index.md
@@ -1,6 +1,6 @@
---
title: Orakel
-description: Orakel ermöglichen Ethereum-Smart-Contracts den Zugang zu Daten aus der realen Welt, was mehr Anwendungsfälle und einen größeren Nutzen für die Benutzer freischaltet.
+description: "Orakel ermöglichen Ethereum-Smart-Contracts den Zugang zu Daten aus der realen Welt, was mehr Anwendungsfälle und einen größeren Nutzen für die Benutzer freischaltet."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/programming-languages/dart/index.md b/public/content/translations/de/developers/docs/programming-languages/dart/index.md
index 02446271233..11afd519ad0 100644
--- a/public/content/translations/de/developers/docs/programming-languages/dart/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/dart/index.md
@@ -1,6 +1,6 @@
---
-title: Ethereum für Dart-Entwickler
-description: Lernen, wie Sie die Sprache Dart für die Entwicklung auf Ethereum nutzen
+title: "Ethereum für Dart-Entwickler"
+description: "Lernen, wie Sie die Sprache Dart für die Entwicklung auf Ethereum nutzen"
lang: de
incomplete: true
---
diff --git a/public/content/translations/de/developers/docs/programming-languages/delphi/index.md b/public/content/translations/de/developers/docs/programming-languages/delphi/index.md
index 2482c21b29b..dbf47d1aa52 100644
--- a/public/content/translations/de/developers/docs/programming-languages/delphi/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/delphi/index.md
@@ -1,6 +1,6 @@
---
-title: Ethereum für Delphi-Entwickler
-description: Lernen, mit der Programmiersprache Delphi für Ethereum zu entwickeln
+title: "Ethereum für Delphi-Entwickler"
+description: "Lernen, mit der Programmiersprache Delphi für Ethereum zu entwickeln"
lang: de
incomplete: true
---
diff --git a/public/content/translations/de/developers/docs/programming-languages/dot-net/index.md b/public/content/translations/de/developers/docs/programming-languages/dot-net/index.md
index fee6c345b75..f83d520c001 100644
--- a/public/content/translations/de/developers/docs/programming-languages/dot-net/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/dot-net/index.md
@@ -1,6 +1,6 @@
---
-title: Ethereum für .NET-Entwickler
-description: Lernen, wie Sie .NET-basierte Projekte und Tools für die Ethereum-Entwicklung nutzen können
+title: "Ethereum für .NET-Entwickler"
+description: "Lernen, wie Sie .NET-basierte Projekte und Tools für die Ethereum-Entwicklung nutzen können"
lang: de
incomplete: true
---
diff --git a/public/content/translations/de/developers/docs/programming-languages/elixir/index.md b/public/content/translations/de/developers/docs/programming-languages/elixir/index.md
index 0105be9105f..9c7ebffae5f 100644
--- a/public/content/translations/de/developers/docs/programming-languages/elixir/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/elixir/index.md
@@ -1,6 +1,6 @@
---
-title: Ethereum für Elixir-Entwickler
-description: Lernen Sie, wie Sie für Ethereum entwickeln, mit Elixir-basierten Projekten und Werkzeugen.
+title: "Ethereum für Elixir-Entwickler"
+description: "Lernen Sie, wie Sie für Ethereum entwickeln, mit Elixir-basierten Projekten und Werkzeugen."
lang: de
incomplete: false
---
diff --git a/public/content/translations/de/developers/docs/programming-languages/golang/index.md b/public/content/translations/de/developers/docs/programming-languages/golang/index.md
index 8c92290938f..5e4ba778b4d 100644
--- a/public/content/translations/de/developers/docs/programming-languages/golang/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/golang/index.md
@@ -1,6 +1,6 @@
---
-title: Ethereum für Go-Entwickler
-description: Lernen, wie Sie mit Go-basierten Projekten und Werkzeugen für Ethereum entwickeln können
+title: "Ethereum für Go-Entwickler"
+description: "Lernen, wie Sie mit Go-basierten Projekten und Werkzeugen für Ethereum entwickeln können"
lang: de
incomplete: true
---
diff --git a/public/content/translations/de/developers/docs/programming-languages/index.md b/public/content/translations/de/developers/docs/programming-languages/index.md
index 1a2899b4301..80eaad705c7 100644
--- a/public/content/translations/de/developers/docs/programming-languages/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/index.md
@@ -1,6 +1,6 @@
---
title: Programmiersprachen
-description: Entdecken Sie Ethereum-Entwicklungsressourcen für verschiedene Programmiersprachen, darunter JavaScript, Python, Go, Rust und mehr.
+description: "Entdecken Sie Ethereum-Entwicklungsressourcen für verschiedene Programmiersprachen, darunter JavaScript, Python, Go, Rust und mehr."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/programming-languages/java/index.md b/public/content/translations/de/developers/docs/programming-languages/java/index.md
index b573d6f5341..914e0da424c 100644
--- a/public/content/translations/de/developers/docs/programming-languages/java/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/java/index.md
@@ -1,6 +1,6 @@
---
-title: Ethereum für Java-Entwickler
-description: Lernen, wie Sie mit Java-basierten Projekten und Werkzeugen für Ethereum entwickeln können
+title: "Ethereum für Java-Entwickler"
+description: "Lernen, wie Sie mit Java-basierten Projekten und Werkzeugen für Ethereum entwickeln können"
lang: de
incomplete: true
---
diff --git a/public/content/translations/de/developers/docs/programming-languages/javascript/index.md b/public/content/translations/de/developers/docs/programming-languages/javascript/index.md
index 817db545e85..c3d8b533801 100644
--- a/public/content/translations/de/developers/docs/programming-languages/javascript/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/javascript/index.md
@@ -1,6 +1,6 @@
---
-title: Ethereum für JavaScript-Entwickler
-description: Lernen, wie Sie JavaScript-basierte Projekte und Tools für die Ethereum-Entwicklung nutzen können
+title: "Ethereum für JavaScript-Entwickler"
+description: "Lernen, wie Sie JavaScript-basierte Projekte und Tools für die Ethereum-Entwicklung nutzen können"
lang: de
---
diff --git a/public/content/translations/de/developers/docs/programming-languages/python/index.md b/public/content/translations/de/developers/docs/programming-languages/python/index.md
index dcb6cf77de9..196691d0750 100644
--- a/public/content/translations/de/developers/docs/programming-languages/python/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/python/index.md
@@ -1,6 +1,6 @@
---
-title: Ethereum für Python-Entwickler
-description: Erfahre, wie du mit Python-basierten Projekten und Werkzeugen für Ethereum entwickeln kannst
+title: "Ethereum für Python-Entwickler"
+description: "Erfahre, wie du mit Python-basierten Projekten und Werkzeugen für Ethereum entwickeln kannst"
lang: de
incomplete: true
---
diff --git a/public/content/translations/de/developers/docs/programming-languages/ruby/index.md b/public/content/translations/de/developers/docs/programming-languages/ruby/index.md
index bf5a417351c..ef72c64fb82 100644
--- a/public/content/translations/de/developers/docs/programming-languages/ruby/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/ruby/index.md
@@ -1,6 +1,6 @@
---
-title: Ethereum für Ruby-Entwickler
-description: Lernen, wie Sie mit Ruby-basierten Projekten und Tools für Ethereum entwickeln
+title: "Ethereum für Ruby-Entwickler"
+description: "Lernen, wie Sie mit Ruby-basierten Projekten und Tools für Ethereum entwickeln"
lang: de
incomplete: false
---
diff --git a/public/content/translations/de/developers/docs/programming-languages/rust/index.md b/public/content/translations/de/developers/docs/programming-languages/rust/index.md
index 437094e44c9..241e57b0654 100644
--- a/public/content/translations/de/developers/docs/programming-languages/rust/index.md
+++ b/public/content/translations/de/developers/docs/programming-languages/rust/index.md
@@ -1,6 +1,6 @@
---
-title: Ethereum für Rust-Entwickler
-description: Lernen, wie Sie mit Rust-basierten Projekten und Tools für Ethereum entwickeln können
+title: "Ethereum für Rust-Entwickler"
+description: "Lernen, wie Sie mit Rust-basierten Projekten und Tools für Ethereum entwickeln können"
lang: de
incomplete: true
---
diff --git a/public/content/translations/de/developers/docs/scaling/index.md b/public/content/translations/de/developers/docs/scaling/index.md
index 3f2e98dee3c..2d923664cab 100644
--- a/public/content/translations/de/developers/docs/scaling/index.md
+++ b/public/content/translations/de/developers/docs/scaling/index.md
@@ -1,6 +1,6 @@
---
title: Skalierung
-description: Eine Einführung in die verschiedenen Skalierungsoptionen, die derzeit von der Ethereum Community entwickelt werden.
+description: "Eine Einführung in die verschiedenen Skalierungsoptionen, die derzeit von der Ethereum Community entwickelt werden."
lang: de
sidebarDepth: 3
---
diff --git a/public/content/translations/de/developers/docs/scaling/optimistic-rollups/index.md b/public/content/translations/de/developers/docs/scaling/optimistic-rollups/index.md
index 2a892aee405..058468f9621 100644
--- a/public/content/translations/de/developers/docs/scaling/optimistic-rollups/index.md
+++ b/public/content/translations/de/developers/docs/scaling/optimistic-rollups/index.md
@@ -1,6 +1,6 @@
---
title: Optimistische Rollups (Optimistic Rollups)
-description: Eine Einführung in optimistische Rollups – eine Skalierungslösung, die von der Ethereum-Community verwendet wird.
+description: "Eine Einführung in optimistische Rollups – eine Skalierungslösung, die von der Ethereum-Community verwendet wird."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/scaling/plasma/index.md b/public/content/translations/de/developers/docs/scaling/plasma/index.md
index b511bf121c4..7990cb7ffb8 100644
--- a/public/content/translations/de/developers/docs/scaling/plasma/index.md
+++ b/public/content/translations/de/developers/docs/scaling/plasma/index.md
@@ -1,6 +1,6 @@
---
title: Plasma-Kette
-description: Eine Einführung in Plasma-Ketten als Skalierungslösung, die derzeit von der Ethereum-Community genutzt wird.
+description: "Eine Einführung in Plasma-Ketten als Skalierungslösung, die derzeit von der Ethereum-Community genutzt wird."
lang: de
incomplete: true
sidebarDepth: 3
diff --git a/public/content/translations/de/developers/docs/scaling/sidechains/index.md b/public/content/translations/de/developers/docs/scaling/sidechains/index.md
index 200cc6c3770..19d12d15c0b 100644
--- a/public/content/translations/de/developers/docs/scaling/sidechains/index.md
+++ b/public/content/translations/de/developers/docs/scaling/sidechains/index.md
@@ -1,6 +1,6 @@
---
title: Seitenketten
-description: Eine Einführung in Sidechains als Skalierungslösung, die derzeit von der Ethereum-Community genutzt wird.
+description: "Eine Einführung in Sidechains als Skalierungslösung, die derzeit von der Ethereum-Community genutzt wird."
lang: de
sidebarDepth: 3
---
diff --git a/public/content/translations/de/developers/docs/scaling/state-channels/index.md b/public/content/translations/de/developers/docs/scaling/state-channels/index.md
index d9760f369da..d1ab721d1df 100644
--- a/public/content/translations/de/developers/docs/scaling/state-channels/index.md
+++ b/public/content/translations/de/developers/docs/scaling/state-channels/index.md
@@ -1,6 +1,6 @@
---
-title: Zustandskanäle
-description: Eine Einführung in Zustandskanäle und Zahlungskanäle als Skalierungslösung, die derzeit von der Ethereum-Community genutzt wird.
+title: "Zustandskanäle"
+description: "Eine Einführung in Zustandskanäle und Zahlungskanäle als Skalierungslösung, die derzeit von der Ethereum-Community genutzt wird."
lang: de
sidebarDepth: 3
---
diff --git a/public/content/translations/de/developers/docs/scaling/validium/index.md b/public/content/translations/de/developers/docs/scaling/validium/index.md
index 2152955fccf..eaa4347f30c 100644
--- a/public/content/translations/de/developers/docs/scaling/validium/index.md
+++ b/public/content/translations/de/developers/docs/scaling/validium/index.md
@@ -1,6 +1,6 @@
---
title: Validium
-description: Eine Einführung in Validium als Skalierungslösung, die derzeit von der Ethereum-Community genutzt wird.
+description: "Eine Einführung in Validium als Skalierungslösung, die derzeit von der Ethereum-Community genutzt wird."
lang: de
sidebarDepth: 3
---
@@ -23,8 +23,7 @@ Allerdings können die Gelder der Validium-Nutzer eingefroren und Auszahlungen e
Dies ist der Hauptunterschied zwischen Validiums und ZK-Rollups – ihre Positionen im Datenverfügbarkeitsspektrum. Beide Lösungen gehen unterschiedlich mit der Datenspeicherung um, was Auswirkungen auf Sicherheit und Vertrauenswürdigkeit hat.
-## Wie interagieren Validiums mit Ethereum? Wie interagieren Validiums mit Ethereum? {#how-do-validiums-interact-with-ethereum}
-
+## Wie interagieren Validiums mit Ethereum? {#how-do-validiums-interact-with-ethereum}
Validiums sind Skalierungsprotokolle, die auf der bestehenden Ethereum-Blockchain aufgebaut sind. Obwohl die Transaktionen Off-Chain ausgeführt werden, wird eine Validium-Chain von mehreren Smart Contracts verwaltet, die im Mainnet eingesetzt sind, darunter:
1. **Verifier-Vertrag**: Der Verifier-Vertrag überprüft die Gültigkeit der vom Validium-Operator eingereichten Nachweise bei der Durchführung von Statusaktualisierungen. Das umfasst Gültigkeitsnachweise, die die Korrektheit der Offchain-Transaktionen belegen, sowie Datenverfügbarkeitsnachweise, die bestätigen, dass die Offchain-Transaktionsdaten vorhanden sind.
diff --git a/public/content/translations/de/developers/docs/scaling/zk-rollups/index.md b/public/content/translations/de/developers/docs/scaling/zk-rollups/index.md
index d09c9a071e6..97b0f20feaf 100644
--- a/public/content/translations/de/developers/docs/scaling/zk-rollups/index.md
+++ b/public/content/translations/de/developers/docs/scaling/zk-rollups/index.md
@@ -1,6 +1,6 @@
---
title: Zero-Knowledge Gruppierungen (Rollups)
-description: Eine Einführung in Zero-Knowledge-Rollups – eine Skalierungslösung, die von der Ethereum-Community verwendet wird.
+description: "Eine Einführung in Zero-Knowledge-Rollups – eine Skalierungslösung, die von der Ethereum-Community verwendet wird."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/smart-contracts/compiling/index.md b/public/content/translations/de/developers/docs/smart-contracts/compiling/index.md
index 8fde88df8df..f3ec0322ec6 100644
--- a/public/content/translations/de/developers/docs/smart-contracts/compiling/index.md
+++ b/public/content/translations/de/developers/docs/smart-contracts/compiling/index.md
@@ -1,6 +1,6 @@
---
title: Smart Contracts erstellen
-description: Eine Erklärung, warum Sie Smart Contracts kompilieren müssen und was bei der Kompilierung tatsächlich passiert
+description: "Eine Erklärung, warum Sie Smart Contracts kompilieren müssen und was bei der Kompilierung tatsächlich passiert"
lang: de
incomplete: true
---
diff --git a/public/content/translations/de/developers/docs/smart-contracts/composability/index.md b/public/content/translations/de/developers/docs/smart-contracts/composability/index.md
index 5c20f1f5861..c544a79b1fc 100644
--- a/public/content/translations/de/developers/docs/smart-contracts/composability/index.md
+++ b/public/content/translations/de/developers/docs/smart-contracts/composability/index.md
@@ -1,6 +1,6 @@
---
title: Smart-Contract-Kombinierbarkeit
-description: Erfahren Sie, wie Smart Contracts wie Legosteine kombiniert werden können, um durch die Wiederverwendung vorhandener Komponenten komplexe Dapps zu erstellen.
+description: "Erfahren Sie, wie Smart Contracts wie Legosteine kombiniert werden können, um durch die Wiederverwendung vorhandener Komponenten komplexe Dapps zu erstellen."
lang: de
incomplete: true
---
diff --git a/public/content/translations/de/developers/docs/smart-contracts/deploying/index.md b/public/content/translations/de/developers/docs/smart-contracts/deploying/index.md
index 8de1ee495fd..1d5b1664990 100644
--- a/public/content/translations/de/developers/docs/smart-contracts/deploying/index.md
+++ b/public/content/translations/de/developers/docs/smart-contracts/deploying/index.md
@@ -1,6 +1,6 @@
---
title: Smart Contracts bereitstellen
-description: Erfahren Sie, wie Sie Smart Contracts in Ethereum Netzwerken bereitstellen, einschließlich Voraussetzungen, Tools und Bereitstellungsschritten.
+description: "Erfahren Sie, wie Sie Smart Contracts in Ethereum Netzwerken bereitstellen, einschließlich Voraussetzungen, Tools und Bereitstellungsschritten."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/smart-contracts/formal-verification/index.md b/public/content/translations/de/developers/docs/smart-contracts/formal-verification/index.md
index 3a1059cea4b..74c22e54846 100644
--- a/public/content/translations/de/developers/docs/smart-contracts/formal-verification/index.md
+++ b/public/content/translations/de/developers/docs/smart-contracts/formal-verification/index.md
@@ -1,6 +1,6 @@
---
title: Formale Verifizierung von Smart Contracts
-description: Ein Überblick über die formale Verifizierung von Ethereum-Smart-Contracts
+description: "Ein Überblick über die formale Verifizierung von Ethereum-Smart-Contracts"
lang: de
---
diff --git a/public/content/translations/de/developers/docs/smart-contracts/index.md b/public/content/translations/de/developers/docs/smart-contracts/index.md
index d661d6a543c..64e1af8b3e9 100644
--- a/public/content/translations/de/developers/docs/smart-contracts/index.md
+++ b/public/content/translations/de/developers/docs/smart-contracts/index.md
@@ -1,11 +1,10 @@
---
-title: Einführung in Smart Contracts
-description: Eine Übersicht zu Smart Contracts mit dem Fokus auf ihre einzigartigen Besonderheiten und Beschränkungen
+title: "Einführung in Smart Contracts"
+description: "Eine Übersicht zu Smart Contracts mit dem Fokus auf ihre einzigartigen Besonderheiten und Beschränkungen"
lang: de
---
-## Was ist ein Smart Contract? Was ist ein Smart Contract? {#what-is-a-smart-contract}
-
+## Was ist ein Smart Contract? {#what-is-a-smart-contract}
Ein "Smart Contract" oder intelligenter Vertrag ist einfach ein Programm, das auf der Ethereum-Blockchain läuft. Es ist eine Sammlung von Anweisungen (seinen Funktionen) und Daten (seinem Zustand), die sich an einer bestimmten Adresse in der Ethereum-Blockchain befindet.
Smart Contracts sind eine Art [Ethereum-Konto](/developers/docs/accounts/). Das bedeutet, dass sie über ein Guthaben verfügen und Ziel von Transaktionen werden können. Allerdings werden sie nicht von einem Benutzer gesteuert, sondern im Netzwerk bereitgestellt und wie programmiert ausgeführt. Benutzerkonten können dann mit einem Smart Contract interagieren, indem sie Transaktionen übermitteln, die eine im Smart Contract definierte Funktion ausführt. Smart Contracts können, wie auch herkömmliche Verträge, Regeln definieren und diese mittels Programmierung automatisch durchsetzen. Standardmäßig können Smart Contracts nicht gelöscht werden und Interaktionen mit ihnen sind irreversibel.
diff --git a/public/content/translations/de/developers/docs/smart-contracts/languages/index.md b/public/content/translations/de/developers/docs/smart-contracts/languages/index.md
index aeb73970387..ea2f2498dde 100644
--- a/public/content/translations/de/developers/docs/smart-contracts/languages/index.md
+++ b/public/content/translations/de/developers/docs/smart-contracts/languages/index.md
@@ -1,6 +1,6 @@
---
title: Sprachen von Smart Contracts
-description: Übersicht und Vergleich der zwei wichtigsten Smart-Contract-Sprachen – Solidity und Vyper
+description: "Übersicht und Vergleich der zwei wichtigsten Smart-Contract-Sprachen – Solidity und Vyper"
lang: de
---
diff --git a/public/content/translations/de/developers/docs/smart-contracts/naming/index.md b/public/content/translations/de/developers/docs/smart-contracts/naming/index.md
index 79459bca3fa..b0eb6ffe2c8 100644
--- a/public/content/translations/de/developers/docs/smart-contracts/naming/index.md
+++ b/public/content/translations/de/developers/docs/smart-contracts/naming/index.md
@@ -1,6 +1,6 @@
---
title: Benennung von Smart Contracts
-description: Bewährte Praktiken für die Benennung von Ethereum Smart Contracts mit ENS
+description: "Bewährte Praktiken für die Benennung von Ethereum Smart Contracts mit ENS"
lang: de
---
diff --git a/public/content/translations/de/developers/docs/smart-contracts/security/index.md b/public/content/translations/de/developers/docs/smart-contracts/security/index.md
index 146e5115732..df3e7a9b06e 100644
--- a/public/content/translations/de/developers/docs/smart-contracts/security/index.md
+++ b/public/content/translations/de/developers/docs/smart-contracts/security/index.md
@@ -1,6 +1,6 @@
---
title: Sicherheit von Smart Contracts
-description: Ein Überblick über die Richtlinien für die Erstellung sicherer Ethereum Smart Contracts
+description: "Ein Überblick über die Richtlinien für die Erstellung sicherer Ethereum Smart Contracts"
lang: de
---
diff --git a/public/content/translations/de/developers/docs/smart-contracts/testing/index.md b/public/content/translations/de/developers/docs/smart-contracts/testing/index.md
index 17ed2830337..bafd2c0b896 100644
--- a/public/content/translations/de/developers/docs/smart-contracts/testing/index.md
+++ b/public/content/translations/de/developers/docs/smart-contracts/testing/index.md
@@ -1,6 +1,6 @@
---
title: Smart Contracts testen
-description: Ein Überblick über Techniken und Überlegungen zum Testen von Ethereum Smart Contracts.
+description: "Ein Überblick über Techniken und Überlegungen zum Testen von Ethereum Smart Contracts."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/smart-contracts/upgrading/index.md b/public/content/translations/de/developers/docs/smart-contracts/upgrading/index.md
index d2911dcc466..95653458f11 100644
--- a/public/content/translations/de/developers/docs/smart-contracts/upgrading/index.md
+++ b/public/content/translations/de/developers/docs/smart-contracts/upgrading/index.md
@@ -1,6 +1,6 @@
---
title: Aktualisierung von Smart Contracts
-description: Ein Überblick über Upgrade-Muster für Ethereum-Smart-Contracts
+description: "Ein Überblick über Upgrade-Muster für Ethereum-Smart-Contracts"
lang: de
---
@@ -14,8 +14,7 @@ Die zunehmende Forschung zur Verbesserung von Smart Contracts hat jedoch zur Ein
Sie sollten ein gutes Verständnis von [Smart Contracts](/developers/docs/smart-contracts/), der [Anatomie von Smart Contracts](/developers/docs/smart-contracts/anatomy/) und der [Ethereum Virtual Machine (EVM)](/developers/docs/evm/) haben. In diesem Leitfaden wird außerdem davon ausgegangen, dass die Leser über Kenntnisse in der Programmierung von Smart Contracts verfügen.
-## Was ist ein Smart-Contract-Upgrade? Was ist ein Smart-Contract-Upgrade? {#what-is-a-smart-contract-upgrade}
-
+## Was ist ein Smart-Contract-Upgrade? {#what-is-a-smart-contract-upgrade}
Bei einem Smart-Contract-Upgrade wird die Geschäftslogik eines Smart Contracts geändert, wobei der Zustand des Vertrags erhalten bleibt. Es ist wichtig, klarzustellen, dass Aktualisierbarkeit und Veränderbarkeit nicht dasselbe sind, insbesondere im Zusammenhang mit Smart Contracts.
Sie können ein Programm, das auf einer Adresse im Ethereum-Netzwerk veröffentlicht wird, trotzdem nicht ändern. Aber Sie können den Code ändern, der ausgeführt wird, wenn Benutzer mit einem Smart Contract interagieren.
diff --git a/public/content/translations/de/developers/docs/smart-contracts/verifying/index.md b/public/content/translations/de/developers/docs/smart-contracts/verifying/index.md
index 7ea6dd371a3..5850e50bc97 100644
--- a/public/content/translations/de/developers/docs/smart-contracts/verifying/index.md
+++ b/public/content/translations/de/developers/docs/smart-contracts/verifying/index.md
@@ -1,6 +1,6 @@
---
-title: Überprüfen von Smart Contracts
-description: Eine Übersicht über die Quellcodeverifizierung für Ethereum-Smart-Contracts
+title: "Überprüfen von Smart Contracts"
+description: "Eine Übersicht über die Quellcodeverifizierung für Ethereum-Smart-Contracts"
lang: de
---
diff --git a/public/content/translations/de/developers/docs/standards/index.md b/public/content/translations/de/developers/docs/standards/index.md
index dd2bfbdf8cd..9df51239f9b 100644
--- a/public/content/translations/de/developers/docs/standards/index.md
+++ b/public/content/translations/de/developers/docs/standards/index.md
@@ -1,6 +1,6 @@
---
title: Ethereum-Entwicklungsstandards
-description: Informieren Sie sich über Ethereum Standards, einschließlich EIPs, Token Standards wie ERC-20 und ERC-721 sowie Entwicklungskonventionen.
+description: "Informieren Sie sich über Ethereum Standards, einschließlich EIPs, Token Standards wie ERC-20 und ERC-721 sowie Entwicklungskonventionen."
lang: de
incomplete: true
---
diff --git a/public/content/translations/de/developers/docs/standards/tokens/erc-1155/index.md b/public/content/translations/de/developers/docs/standards/tokens/erc-1155/index.md
index 6d95d696d15..a387ee9d57f 100644
--- a/public/content/translations/de/developers/docs/standards/tokens/erc-1155/index.md
+++ b/public/content/translations/de/developers/docs/standards/tokens/erc-1155/index.md
@@ -1,6 +1,6 @@
---
title: ERC-1155 Token-Standard
-description: Erfahren Sie mehr über ERC-1155, einen Multi-Token-Standard, der fungible und nicht-fungible Token in einem einzigen Vertrag kombiniert.
+description: "Erfahren Sie mehr über ERC-1155, einen Multi-Token-Standard, der fungible und nicht-fungible Token in einem einzigen Vertrag kombiniert."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/standards/tokens/erc-1363/index.md b/public/content/translations/de/developers/docs/standards/tokens/erc-1363/index.md
index 2f10ca792ff..2250eb47bcf 100644
--- a/public/content/translations/de/developers/docs/standards/tokens/erc-1363/index.md
+++ b/public/content/translations/de/developers/docs/standards/tokens/erc-1363/index.md
@@ -1,6 +1,6 @@
---
title: ERC-1363 Zahlbarer Token-Standard
-description: ERC-1363 ist eine Erweiterungsschnittstelle für ERC-20-Token, die die Ausführung einer benutzerdefinierten Logik auf einem Empfängervertrag nach Übertragungen oder auf einem Spendervertrag nach Genehmigungen innerhalb einer einzigen Transaktion unterstützt.
+description: "ERC-1363 ist eine Erweiterungsschnittstelle für ERC-20-Token, die die Ausführung einer benutzerdefinierten Logik auf einem Empfängervertrag nach Übertragungen oder auf einem Spendervertrag nach Genehmigungen innerhalb einer einzigen Transaktion unterstützt."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/standards/tokens/erc-20/index.md b/public/content/translations/de/developers/docs/standards/tokens/erc-20/index.md
index 90cce601b6a..41f6fd1c4b2 100644
--- a/public/content/translations/de/developers/docs/standards/tokens/erc-20/index.md
+++ b/public/content/translations/de/developers/docs/standards/tokens/erc-20/index.md
@@ -1,6 +1,6 @@
---
title: ERC-20 Token-Standard
-description: Erfahren Sie mehr über ERC-20, den Standard für fungible Token auf Ethereum, der interoperable Token Anwendungen ermöglicht.
+description: "Erfahren Sie mehr über ERC-20, den Standard für fungible Token auf Ethereum, der interoperable Token Anwendungen ermöglicht."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/standards/tokens/erc-223/index.md b/public/content/translations/de/developers/docs/standards/tokens/erc-223/index.md
index ae2f12755e8..3d3df0d7aae 100644
--- a/public/content/translations/de/developers/docs/standards/tokens/erc-223/index.md
+++ b/public/content/translations/de/developers/docs/standards/tokens/erc-223/index.md
@@ -1,6 +1,6 @@
---
title: ERC-223 Token-Standard
-description: Eine Übersicht über den ERC-223-Fungible-Token-Standard, wie er funktioniert und ein Vergleich mit ERC-20.
+description: "Eine Übersicht über den ERC-223-Fungible-Token-Standard, wie er funktioniert und ein Vergleich mit ERC-20."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/standards/tokens/erc-4626/index.md b/public/content/translations/de/developers/docs/standards/tokens/erc-4626/index.md
index 8c201f22f71..64ce934e4bc 100644
--- a/public/content/translations/de/developers/docs/standards/tokens/erc-4626/index.md
+++ b/public/content/translations/de/developers/docs/standards/tokens/erc-4626/index.md
@@ -1,6 +1,6 @@
---
title: "ERC-4626 Tokenisierter Tresor Standard "
-description: Standard für Ertragstragende Gewölbe.
+description: "Standard für Ertragstragende Gewölbe."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/standards/tokens/erc-721/index.md b/public/content/translations/de/developers/docs/standards/tokens/erc-721/index.md
index 3c99b282389..a0d5f1d898b 100644
--- a/public/content/translations/de/developers/docs/standards/tokens/erc-721/index.md
+++ b/public/content/translations/de/developers/docs/standards/tokens/erc-721/index.md
@@ -1,6 +1,6 @@
---
title: ERC-721 Nicht-fungibler Token-Standard
-description: Erfahren Sie mehr über ERC-721, den Standard für nicht fungible Token (NFTs), die einzigartige digitale Assets auf Ethereum darstellen.
+description: "Erfahren Sie mehr über ERC-721, den Standard für nicht fungible Token (NFTs), die einzigartige digitale Assets auf Ethereum darstellen."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/standards/tokens/erc-777/index.md b/public/content/translations/de/developers/docs/standards/tokens/erc-777/index.md
index f472596eeaf..8516017d6ea 100644
--- a/public/content/translations/de/developers/docs/standards/tokens/erc-777/index.md
+++ b/public/content/translations/de/developers/docs/standards/tokens/erc-777/index.md
@@ -1,6 +1,6 @@
---
title: ERC-777 Token-Standard
-description: Erfahren Sie mehr über ERC-777, einen verbesserten fungiblen Token-Standard mit Hooks, obwohl aus Sicherheitsgründen ERC-20 empfohlen wird.
+description: "Erfahren Sie mehr über ERC-777, einen verbesserten fungiblen Token-Standard mit Hooks, obwohl aus Sicherheitsgründen ERC-20 empfohlen wird."
lang: de
---
diff --git a/public/content/translations/de/developers/docs/standards/tokens/index.md b/public/content/translations/de/developers/docs/standards/tokens/index.md
index 0415e4b8940..361f39b7572 100644
--- a/public/content/translations/de/developers/docs/standards/tokens/index.md
+++ b/public/content/translations/de/developers/docs/standards/tokens/index.md
@@ -1,6 +1,6 @@
---
title: Token-Standards
-description: Erkunden Sie Ethereum Token Standards, einschließlich ERC-20, ERC-721 und ERC-1155 für fungible und nicht fungible Token.
+description: "Erkunden Sie Ethereum Token Standards, einschließlich ERC-20, ERC-721 und ERC-1155 für fungible und nicht fungible Token."
lang: de
incomplete: true
---
diff --git a/public/content/translations/de/developers/docs/storage/index.md b/public/content/translations/de/developers/docs/storage/index.md
index d954c7933f2..85f3aa17cdf 100644
--- a/public/content/translations/de/developers/docs/storage/index.md
+++ b/public/content/translations/de/developers/docs/storage/index.md
@@ -1,6 +1,6 @@
---
title: Dezentrale Speicher
-description: Übersicht über dezentrale Speicher und verfügbare Tools für die Integration der Speicher in eine dApp
+description: "Übersicht über dezentrale Speicher und verfügbare Tools für die Integration der Speicher in eine dApp"
lang: de
---
diff --git a/public/content/translations/de/developers/docs/transactions/index.md b/public/content/translations/de/developers/docs/transactions/index.md
index 6b8eae1cdd9..565855a4df0 100644
--- a/public/content/translations/de/developers/docs/transactions/index.md
+++ b/public/content/translations/de/developers/docs/transactions/index.md
@@ -1,6 +1,6 @@
---
title: Transaktionen
-description: Eine Übersicht über die Transaktionen von Ethereum – wie sie arbeiten, ihre Datenstruktur und wie sie über eine App gesendet werden.
+description: "Eine Übersicht über die Transaktionen von Ethereum – wie sie arbeiten, ihre Datenstruktur und wie sie über eine App gesendet werden."
lang: de
---
diff --git a/public/content/translations/de/developers/tutorials/a-developers-guide-to-ethereum-part-one/index.md b/public/content/translations/de/developers/tutorials/a-developers-guide-to-ethereum-part-one/index.md
index ec6491a7a12..49f625b86b3 100644
--- a/public/content/translations/de/developers/tutorials/a-developers-guide-to-ethereum-part-one/index.md
+++ b/public/content/translations/de/developers/tutorials/a-developers-guide-to-ethereum-part-one/index.md
@@ -1,6 +1,6 @@
---
-title: Ethereum-Einführung für Python-Entwickler, Teil 1
-description: Eine Einführung in die Ethereum-Entwicklung, besonders nützlich für Personen mit Kenntnissen in der Programmiersprache Python
+title: "Ethereum-Einführung für Python-Entwickler, Teil 1"
+description: "Eine Einführung in die Ethereum-Entwicklung, besonders nützlich für Personen mit Kenntnissen in der Programmiersprache Python"
author: Marc Garreau
lang: de
tags: [ "Python", "web3.py" ]
diff --git a/public/content/translations/de/developers/tutorials/all-you-can-cache/index.md b/public/content/translations/de/developers/tutorials/all-you-can-cache/index.md
index 7645215f097..cb8dd2ab921 100644
--- a/public/content/translations/de/developers/tutorials/all-you-can-cache/index.md
+++ b/public/content/translations/de/developers/tutorials/all-you-can-cache/index.md
@@ -1,6 +1,6 @@
---
title: "Alles, was Sie cachen können"
-description: Erfahren Sie, wie Sie einen Caching-Vertrag für günstigere Rollup-Transaktionen erstellen und verwenden.
+description: "Erfahren Sie, wie Sie einen Caching-Vertrag für günstigere Rollup-Transaktionen erstellen und verwenden."
author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
tags: [ "Layer 2", "Caching", "Speicher" ]
skill: intermediate
diff --git a/public/content/translations/de/developers/tutorials/app-plasma/index.md b/public/content/translations/de/developers/tutorials/app-plasma/index.md
index df5ca6104a5..21a1c8014c0 100644
--- a/public/content/translations/de/developers/tutorials/app-plasma/index.md
+++ b/public/content/translations/de/developers/tutorials/app-plasma/index.md
@@ -1,6 +1,6 @@
---
-title: Schreiben Sie ein App-spezifisches Plasma, das die Privatsphäre wahrt
-description: In diesem Tutorial bauen wir eine halbgeheime Bank für Einlagen. Die Bank ist eine zentralisierte Komponente; sie kennt das Guthaben jedes Benutzers. Diese Informationen werden jedoch nicht onchain gespeichert. Stattdessen veröffentlicht die Bank einen Hash des Zustands. Jedes Mal, wenn eine Transaktion stattfindet, veröffentlicht die Bank den neuen Hash, zusammen mit einem Zero-Knowledge-Proof, dass sie eine signierte Transaktion hat, die den Hash-Zustand in den neuen ändert. Nach der Lektüre dieses Tutorials werden Sie nicht nur verstehen, wie man Zero-Knowledge-Proofs verwendet, sondern auch, warum man sie verwendet und wie man dies sicher tut.
+title: "Schreiben Sie ein App-spezifisches Plasma, das die Privatsphäre wahrt"
+description: "In diesem Tutorial bauen wir eine halbgeheime Bank für Einlagen. Die Bank ist eine zentralisierte Komponente; sie kennt das Guthaben jedes Benutzers. Diese Informationen werden jedoch nicht onchain gespeichert. Stattdessen veröffentlicht die Bank einen Hash des Zustands. Jedes Mal, wenn eine Transaktion stattfindet, veröffentlicht die Bank den neuen Hash, zusammen mit einem Zero-Knowledge-Proof, dass sie eine signierte Transaktion hat, die den Hash-Zustand in den neuen ändert. Nach der Lektüre dieses Tutorials werden Sie nicht nur verstehen, wie man Zero-Knowledge-Proofs verwendet, sondern auch, warum man sie verwendet und wie man dies sicher tut."
author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
tags:
[
@@ -226,7 +226,7 @@ Diese Funktion erstellt die `Transfer`-React-Komponente, die andere Dateien impo
]
```
-Dies sind die Kontoadressen, die durch die Passphrase `test ...` erstellt werden. test junk\` Passphrase. Wenn Sie Ihre eigenen Adressen verwenden möchten, ändern Sie einfach diese Definition.
+Dies sind die Kontoadressen, die durch die Passphrase `test ...` erstellt werden. test junk` Passphrase. Wenn Sie Ihre eigenen Adressen verwenden möchten, ändern Sie einfach diese Definition.
```tsx
const account = useAccount()
@@ -402,7 +402,7 @@ Eine Funktionsdefinition. Der Parameter ist eine `Account`-Information. Das Erge
];
```
-Der erste Wert im Array ist die Kontoadresse. Der zweite Wert enthält sowohl das Guthaben als auch die Nonce. Die `.into()`-Aufrufe ändern eine Zahl in den Datentyp, den sie haben muss. `account.nonce` ist ein `u32`-Wert, aber um ihn zu `account.balance << 32`, einem `u128`-Wert, hinzuzufügen, muss er ein `u128` sein. Das ist das erste `.into()`. Der zweite wandelt das `u128`-Ergebnis in ein `Field` um, damit es in das Array passt.
+Der erste Wert im Array ist die Kontoadresse. Der zweite Wert enthält sowohl das Guthaben als auch die Nonce. Die `.into()`-Aufrufe ändern eine Zahl in den Datentyp, den sie haben muss. `account.nonce` ist ein `u32`-Wert, aber um ihn zu `account.balance « 32`, einem `u128`-Wert, hinzuzufügen, muss er ein `u128` sein. Das ist das erste `.into()`. Der zweite wandelt das `u128`-Ergebnis in ein `Field` um, damit es in das Array passt.
```
flat
diff --git a/public/content/translations/de/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md b/public/content/translations/de/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md
index afadddb360d..40cd770e5c5 100644
--- a/public/content/translations/de/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md
+++ b/public/content/translations/de/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md
@@ -1,6 +1,6 @@
---
title: "Erstellen einer Benutzeroberfläche für Ihren Vertrag"
-description: Mithilfe moderner Komponenten wie TypeScript, React, Vite und Wagmi werden wir eine moderne, aber minimalistische Benutzeroberfläche durchgehen und lernen, wie man eine Wallet mit der Benutzeroberfläche verbindet, einen Smart Contract aufruft, um Informationen auszulesen, eine Transaktion an einen Smart Contract zu senden und Ereignisse von einem Smart Contract zu überwachen, um Änderungen zu erkennen.
+description: "Mithilfe moderner Komponenten wie TypeScript, React, Vite und Wagmi werden wir eine moderne, aber minimalistische Benutzeroberfläche durchgehen und lernen, wie man eine Wallet mit der Benutzeroberfläche verbindet, einen Smart Contract aufruft, um Informationen auszulesen, eine Transaktion an einen Smart Contract zu senden und Ereignisse von einem Smart Contract zu überwachen, um Änderungen zu erkennen."
author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
tags: [ "typescript", "react", "vite", "wagmi", "Frontend" ]
skill: beginner
@@ -143,7 +143,7 @@ Konventionsgemäß sind in React Funktionen, die `use...` heißen, [Hooks](https
<>
```
-Das JSX einer React-Komponente _muss_ eine Komponente zurückgeben. Wenn wir mehrere Komponenten haben und nichts haben, was sie "natürlich" umschließt, verwenden wir eine leere Komponente (`<> ...` \`), um sie zu einer einzigen Komponente zu machen.
+Das JSX einer React-Komponente _muss_ eine Komponente zurückgeben. Wenn wir mehrere Komponenten haben und nichts haben, was sie "natürlich" umschließt, verwenden wir eine leere Komponente (`<> ...` `), um sie zu einer einzigen Komponente zu machen.
```tsx
Greeter
@@ -158,7 +158,7 @@ Wir erhalten [die `ConnectButton`-Komponente](https://www.rainbowkit.com/docs/co
Wenn wir tatsächliches JavaScript (oder TypeScript, das zu JavaScript kompiliert wird) in ein JSX einfügen müssen, verwenden wir Klammern (`{}`).
-Die Syntax `a && b` ist eine Kurzform für [`a ?` b : a`](https://www.w3schools.com/react/react_es6_ternary.asp). Das heißt, wenn `a`wahr ist, wird es zu`b`ausgewertet, andernfalls zu`a`(was`false`, `0\` usw. sein kann). Dies ist eine einfache Möglichkeit, React mitzuteilen, dass eine Komponente nur dann angezeigt werden soll, wenn eine bestimmte Bedingung erfüllt ist.
+Die Syntax `a && b` ist eine Kurzform für [`a ?` b : a`](https://www.w3schools.com/react/react_es6_ternary.asp). Das heißt, wenn `a`wahr ist, wird es zu`b`ausgewertet, andernfalls zu`a`(was`false`, `0` usw. sein kann). Dies ist eine einfache Möglichkeit, React mitzuteilen, dass eine Komponente nur dann angezeigt werden soll, wenn eine bestimmte Bedingung erfüllt ist.
In diesem Fall wollen wir dem Benutzer `Greeter` nur dann anzeigen, wenn der Benutzer mit einer Blockchain verbunden ist.
diff --git a/public/content/translations/de/developers/tutorials/deploying-your-first-smart-contract/index.md b/public/content/translations/de/developers/tutorials/deploying-your-first-smart-contract/index.md
index 02240c82ca7..d9b688d7c9d 100644
--- a/public/content/translations/de/developers/tutorials/deploying-your-first-smart-contract/index.md
+++ b/public/content/translations/de/developers/tutorials/deploying-your-first-smart-contract/index.md
@@ -1,6 +1,6 @@
---
title: Deinen ersten Smart Contract bereitstellen
-description: Eine Einführung in die Bereitstellung deines ersten Smart Contracts in einem Ethereum-Testnetzwerk
+description: "Eine Einführung in die Bereitstellung deines ersten Smart Contracts in einem Ethereum-Testnetzwerk"
author: "jdourlens"
tags:
[
diff --git a/public/content/translations/de/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md b/public/content/translations/de/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md
index 334c9252b32..889b358a2fa 100644
--- a/public/content/translations/de/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md
+++ b/public/content/translations/de/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md
@@ -1,6 +1,6 @@
---
title: Wie man eine Dapp auf einem lokalen Multi-Client-Testnet entwickelt und testet
-description: Dieser Leitfaden führt Sie zunächst durch die Instanziierung und Konfiguration eines lokalen Multi-Client-Ethereum-Testnets, bevor Sie das Testnet zur Bereitstellung und zum Testen einer Dapp verwenden.
+description: "Dieser Leitfaden führt Sie zunächst durch die Instanziierung und Konfiguration eines lokalen Multi-Client-Ethereum-Testnets, bevor Sie das Testnet zur Bereitstellung und zum Testen einer Dapp verwenden."
author: "Tedi Mitiku"
tags:
[
diff --git a/public/content/translations/de/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/index.md b/public/content/translations/de/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/index.md
index 351c5e2f29c..36ab458ccfa 100644
--- a/public/content/translations/de/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/index.md
+++ b/public/content/translations/de/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/index.md
@@ -1,6 +1,6 @@
---
title: "Verträge verkleinern, um die Vertragsgrößenbeschränkung zu bekämpfen"
-description: Was kannst du tun, um zu verhindern, dass deine Smart Contracts zu groß werden?
+description: "Was kannst du tun, um zu verhindern, dass deine Smart Contracts zu groß werden?"
author: Markus Waas
lang: de
tags: [ "solidity", "intelligente Verträge", "Speicher" ]
diff --git a/public/content/translations/de/developers/tutorials/eip-1271-smart-contract-signatures/index.md b/public/content/translations/de/developers/tutorials/eip-1271-smart-contract-signatures/index.md
index 699fe68e374..79eb492e35a 100644
--- a/public/content/translations/de/developers/tutorials/eip-1271-smart-contract-signatures/index.md
+++ b/public/content/translations/de/developers/tutorials/eip-1271-smart-contract-signatures/index.md
@@ -1,6 +1,6 @@
---
title: "EIP-1271: Signieren und Verifizieren von Smart-Contract-Signaturen"
-description: Ein Überblick über die Erstellung und Verifizierung von Smart-Contract-Signaturen mit EIP-1271. Wir gehen auch die in Safe (ehemals Gnosis Safe) verwendete EIP-1271-Implementierung durch, um Smart-Contract-Entwicklern ein konkretes Beispiel zu geben, auf dem sie aufbauen können.
+description: "Ein Überblick über die Erstellung und Verifizierung von Smart-Contract-Signaturen mit EIP-1271. Wir gehen auch die in Safe (ehemals Gnosis Safe) verwendete EIP-1271-Implementierung durch, um Smart-Contract-Entwicklern ein konkretes Beispiel zu geben, auf dem sie aufbauen können."
author: Nathan H. Leung
lang: de
tags:
diff --git a/public/content/translations/de/developers/tutorials/erc-721-vyper-annotated-code/index.md b/public/content/translations/de/developers/tutorials/erc-721-vyper-annotated-code/index.md
index d5b05da914f..abffe7281ad 100644
--- a/public/content/translations/de/developers/tutorials/erc-721-vyper-annotated-code/index.md
+++ b/public/content/translations/de/developers/tutorials/erc-721-vyper-annotated-code/index.md
@@ -254,7 +254,7 @@ In Python und in Vyper können Sie auch einen Kommentar erstellen, indem Sie ein
self.minter = msg.sender
```
-Um auf Zustandsvariablen zuzugreifen, verwenden Sie \`self.\`\` (wiederum, wie in Python).
+Um auf Zustandsvariablen zuzugreifen, verwenden Sie `self.`` (wiederum, wie in Python).
#### View-Funktionen {#views}
diff --git a/public/content/translations/de/developers/tutorials/ethereum-for-web2-auth/index.md b/public/content/translations/de/developers/tutorials/ethereum-for-web2-auth/index.md
index 0778a28d7dd..946b991e134 100644
--- a/public/content/translations/de/developers/tutorials/ethereum-for-web2-auth/index.md
+++ b/public/content/translations/de/developers/tutorials/ethereum-for-web2-auth/index.md
@@ -1,6 +1,6 @@
---
-title: Verwendung von Ethereum für die Web2-Authentifizierung
-description: Nach der Lektüre dieses Tutorials kann ein Entwickler die Ethereum-Anmeldung (Web3) in die SAML-Anmeldung integrieren, einen in Web2 verwendeten Standard zur Bereitstellung von Single Sign-On und anderen damit verbundenen Diensten. Dies ermöglicht die Authentifizierung des Zugriffs auf Web2-Ressourcen durch Ethereum-Signaturen, wobei die Benutzerattribute aus Attestierungen stammen.
+title: "Verwendung von Ethereum für die Web2-Authentifizierung"
+description: "Nach der Lektüre dieses Tutorials kann ein Entwickler die Ethereum-Anmeldung (Web3) in die SAML-Anmeldung integrieren, einen in Web2 verwendeten Standard zur Bereitstellung von Single Sign-On und anderen damit verbundenen Diensten. Dies ermöglicht die Authentifizierung des Zugriffs auf Web2-Ressourcen durch Ethereum-Signaturen, wobei die Benutzerattribute aus Attestierungen stammen."
author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
tags: [ "web2", "authentifizierung", "eas" ]
skill: beginner
diff --git a/public/content/translations/de/developers/tutorials/guide-to-smart-contract-security-tools/index.md b/public/content/translations/de/developers/tutorials/guide-to-smart-contract-security-tools/index.md
index 32c6770712e..0b90d99a2a5 100644
--- a/public/content/translations/de/developers/tutorials/guide-to-smart-contract-security-tools/index.md
+++ b/public/content/translations/de/developers/tutorials/guide-to-smart-contract-security-tools/index.md
@@ -1,12 +1,12 @@
---
-title: Ein Leitfaden für Smart-Contract-Sicherheitstools
-description: Ein Überblick über drei verschiedene Test- und Programmanalysetechniken
+title: "Ein Leitfaden für Smart-Contract-Sicherheitstools"
+description: "Ein Überblick über drei verschiedene Test- und Programmanalysetechniken"
author: "Spuren von bits"
lang: de
tags: [ "solidity", "intelligente Verträge", "Sicherheit" ]
skill: intermediate
published: 07.09.2020
-source: Aufbau sicherer Verträge
+source: "Aufbau sicherer Verträge"
sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis
---
diff --git a/public/content/translations/de/developers/tutorials/hello-world-smart-contract-fullstack/index.md b/public/content/translations/de/developers/tutorials/hello-world-smart-contract-fullstack/index.md
index 82a4f3c33ff..616ee0f18c0 100644
--- a/public/content/translations/de/developers/tutorials/hello-world-smart-contract-fullstack/index.md
+++ b/public/content/translations/de/developers/tutorials/hello-world-smart-contract-fullstack/index.md
@@ -1,6 +1,6 @@
---
-title: Hello World Smart-Contract für Einsteiger – Fullstack
-description: Einführungstutorial zum Schreiben und Bereitstellen eines einfachen Smart Contracts auf Ethereum.
+title: "Hello World Smart-Contract für Einsteiger – Fullstack"
+description: "Einführungstutorial zum Schreiben und Bereitstellen eines einfachen Smart Contracts auf Ethereum."
author: "nstrike2"
tags:
[
@@ -57,7 +57,7 @@ Sie können MetaMask [hier](https://metamask.io/download) kostenlos herunterlade
Um Ihren Smart Contract im Testnet bereitzustellen, benötigen Sie einige Fake-ETH. Um ETH im Goerli-Netzwerk zu erhalten, gehen Sie zu einem Goerli-Faucet und geben Sie Ihre Goerli-Kontoadresse ein. Beachten Sie, dass Goerli-Faucets in letzter Zeit etwas unzuverlässig sein können – auf der [Seite der Testnets](/developers/docs/networks/#goerli) finden Sie eine Liste mit Optionen, die Sie ausprobieren können:
_Hinweis: Aufgrund von Netzwerküberlastung kann dies eine Weile dauern._
-\`\`
+``
### Schritt 5: Überprüfen Sie Ihr Guthaben {#step-5-check-your-balance}
@@ -833,8 +833,9 @@ return (
-
-
+
+
+
)
```
diff --git a/public/content/translations/de/developers/tutorials/hello-world-smart-contract/index.md b/public/content/translations/de/developers/tutorials/hello-world-smart-contract/index.md
index e021dee6f14..07e9a34ef7d 100644
--- a/public/content/translations/de/developers/tutorials/hello-world-smart-contract/index.md
+++ b/public/content/translations/de/developers/tutorials/hello-world-smart-contract/index.md
@@ -1,6 +1,6 @@
---
-title: Hello World-Smart Contract für Einsteiger
-description: Einführungstutorial zum Schreiben und Bereitstellen eines einfachen Smart Contracts auf Ethereum.
+title: "Hello World-Smart Contract für Einsteiger"
+description: "Einführungstutorial zum Schreiben und Bereitstellen eines einfachen Smart Contracts auf Ethereum."
author: "elanh"
tags:
[
diff --git a/public/content/translations/de/developers/tutorials/how-to-mint-an-nft/index.md b/public/content/translations/de/developers/tutorials/how-to-mint-an-nft/index.md
index e411d70a1ee..56823c7ccb3 100644
--- a/public/content/translations/de/developers/tutorials/how-to-mint-an-nft/index.md
+++ b/public/content/translations/de/developers/tutorials/how-to-mint-an-nft/index.md
@@ -1,6 +1,6 @@
---
-title: Wie man einen NFT prägt (Teil 2/3 der NFT-Tutorial-Reihe)
-description: In diesem Tutorial wird beschrieben, wie Sie einen NFT auf der Ethereum-Blockchain mit unserem Smart Contract und Web3 prägen können.
+title: "Wie man einen NFT prägt (Teil 2/3 der NFT-Tutorial-Reihe)"
+description: "In diesem Tutorial wird beschrieben, wie Sie einen NFT auf der Ethereum-Blockchain mit unserem Smart Contract und Web3 prägen können."
author: "Sumi Mudgil"
tags:
[
diff --git a/public/content/translations/de/developers/tutorials/how-to-mock-solidity-contracts-for-testing/index.md b/public/content/translations/de/developers/tutorials/how-to-mock-solidity-contracts-for-testing/index.md
index 20da987ce84..40d6220d0cb 100644
--- a/public/content/translations/de/developers/tutorials/how-to-mock-solidity-contracts-for-testing/index.md
+++ b/public/content/translations/de/developers/tutorials/how-to-mock-solidity-contracts-for-testing/index.md
@@ -1,6 +1,6 @@
---
-title: So simulieren Sie Solidity Smart Contracts für Testzwecke
-description: Warum Sie sich beim Testen über Ihre Verträge lustig machen sollten
+title: "So simulieren Sie Solidity Smart Contracts für Testzwecke"
+description: "Warum Sie sich beim Testen über Ihre Verträge lustig machen sollten"
author: Markus Waas
lang: de
tags:
diff --git a/public/content/translations/de/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/index.md b/public/content/translations/de/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/index.md
index c8af715fb23..896d8de3017 100644
--- a/public/content/translations/de/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/index.md
+++ b/public/content/translations/de/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/index.md
@@ -13,7 +13,7 @@ tags:
]
skill: advanced
published: 2020-04-10
-source: Aufbau sicherer Verträge
+source: "Aufbau sicherer Verträge"
sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/echidna
---
diff --git a/public/content/translations/de/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/index.md b/public/content/translations/de/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/index.md
index 642a506ae7c..8b0e2a7c02c 100644
--- a/public/content/translations/de/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/index.md
+++ b/public/content/translations/de/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/index.md
@@ -13,7 +13,7 @@ tags:
]
skill: advanced
published: 13.01.2020
-source: Aufbau sicherer Verträge
+source: "Aufbau sicherer Verträge"
sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/manticore
---
diff --git a/public/content/translations/de/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/index.md b/public/content/translations/de/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/index.md
index acd355d4efd..fa79c810ead 100644
--- a/public/content/translations/de/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/index.md
+++ b/public/content/translations/de/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/index.md
@@ -12,7 +12,7 @@ tags:
]
skill: advanced
published: 2020-06-09
-source: Aufbau sicherer Verträge
+source: "Aufbau sicherer Verträge"
sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/slither
---
diff --git a/public/content/translations/de/developers/tutorials/how-to-use-tellor-as-your-oracle/index.md b/public/content/translations/de/developers/tutorials/how-to-use-tellor-as-your-oracle/index.md
index 20b64b9aa74..e01437df73b 100644
--- a/public/content/translations/de/developers/tutorials/how-to-use-tellor-as-your-oracle/index.md
+++ b/public/content/translations/de/developers/tutorials/how-to-use-tellor-as-your-oracle/index.md
@@ -1,6 +1,6 @@
---
title: Wie Sie Tellor als Ihr Orakel einrichten
-description: Eine Anleitung für den Einstieg in die Integration des Tellor-Orakels in Ihr Protokoll
+description: "Eine Anleitung für den Einstieg in die Integration des Tellor-Orakels in Ihr Protokoll"
author: "Tellor"
lang: de
tags: [ "solidity", "intelligente Verträge", "Orakel" ]
diff --git a/public/content/translations/de/developers/tutorials/how-to-view-nft-in-metamask/index.md b/public/content/translations/de/developers/tutorials/how-to-view-nft-in-metamask/index.md
index 562d5176e24..343d763a224 100644
--- a/public/content/translations/de/developers/tutorials/how-to-view-nft-in-metamask/index.md
+++ b/public/content/translations/de/developers/tutorials/how-to-view-nft-in-metamask/index.md
@@ -1,6 +1,6 @@
---
title: So zeigen Sie Ihr NFT in Ihrem Wallet an (Teil 3/3 der NFT-Tutorialreihe)
-description: Dieses Tutorial beschreibt, wie Sie ein bestehendes NFT auf MetaMask anzeigen können!
+description: "Dieses Tutorial beschreibt, wie Sie ein bestehendes NFT auf MetaMask anzeigen können!"
author: "Sumi Mudgil"
tags: [ "ERC-721", "Alchemy", "Solidity" ]
skill: beginner
diff --git a/public/content/translations/de/developers/tutorials/how-to-write-and-deploy-an-nft/index.md b/public/content/translations/de/developers/tutorials/how-to-write-and-deploy-an-nft/index.md
index a96b1825106..df5a6043ea3 100644
--- a/public/content/translations/de/developers/tutorials/how-to-write-and-deploy-an-nft/index.md
+++ b/public/content/translations/de/developers/tutorials/how-to-write-and-deploy-an-nft/index.md
@@ -1,6 +1,6 @@
---
-title: So erstellen und veröffentlichen Sie einen NFT (Teil 1/3 der NFT-Tutorial-Reihe)
-description: Dieses Tutorial ist Teil 1 einer Serie über NFTs, die Ihnen Schritt für Schritt zeigt, wie Sie einen Non Fungible Token (ERC-721 Token) Smart Contract mit Ethereum und Inter Planetary File System (IPFS) erstellen und veröffentlichen.
+title: "So erstellen und veröffentlichen Sie einen NFT (Teil 1/3 der NFT-Tutorial-Reihe)"
+description: "Dieses Tutorial ist Teil 1 einer Serie über NFTs, die Ihnen Schritt für Schritt zeigt, wie Sie einen Non Fungible Token (ERC-721 Token) Smart Contract mit Ethereum und Inter Planetary File System (IPFS) erstellen und veröffentlichen."
author: "Sumi Mudgil"
tags: [ "ERC-721", "Alchemy", "Solidity", "Smart Contracts" ]
skill: beginner
diff --git a/public/content/translations/de/developers/tutorials/ipfs-decentralized-ui/index.md b/public/content/translations/de/developers/tutorials/ipfs-decentralized-ui/index.md
index b82d4d482d6..5a4a3c04c34 100644
--- a/public/content/translations/de/developers/tutorials/ipfs-decentralized-ui/index.md
+++ b/public/content/translations/de/developers/tutorials/ipfs-decentralized-ui/index.md
@@ -1,6 +1,6 @@
---
-title: IPFS für dezentralisierte Benutzeroberflächen
-description: Dieses Tutorial zeigt dem Leser, wie man IPFS nutzt, um die Benutzeroberfläche für eine Dapp zu speichern. Obwohl die Daten und die Geschäftslogik der Anwendung dezentralisiert sind, könnten Benutzer ohne eine zensurresistente Benutzeroberfläche trotzdem den Zugriff darauf verlieren.
+title: "IPFS für dezentralisierte Benutzeroberflächen"
+description: "Dieses Tutorial zeigt dem Leser, wie man IPFS nutzt, um die Benutzeroberfläche für eine Dapp zu speichern. Obwohl die Daten und die Geschäftslogik der Anwendung dezentralisiert sind, könnten Benutzer ohne eine zensurresistente Benutzeroberfläche trotzdem den Zugriff darauf verlieren."
author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
tags: [ "ipfs" ]
skill: beginner
diff --git a/public/content/translations/de/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md b/public/content/translations/de/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md
index e9232251e92..21e45c2af6c 100644
--- a/public/content/translations/de/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md
+++ b/public/content/translations/de/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md
@@ -1,6 +1,6 @@
---
title: Starte deine Dapp-Frontend-Entwicklung mit create-eth-app
-description: Ein Überblick über die Verwendung und Funktionen von create-eth-app
+description: "Ein Überblick über die Verwendung und Funktionen von create-eth-app"
author: "Markus Waas"
tags:
[
diff --git a/public/content/translations/de/developers/tutorials/learn-foundational-ethereum-topics-with-sql/index.md b/public/content/translations/de/developers/tutorials/learn-foundational-ethereum-topics-with-sql/index.md
index 8872be138ea..46a59320013 100644
--- a/public/content/translations/de/developers/tutorials/learn-foundational-ethereum-topics-with-sql/index.md
+++ b/public/content/translations/de/developers/tutorials/learn-foundational-ethereum-topics-with-sql/index.md
@@ -1,6 +1,6 @@
---
title: Grundlegende Ethereum-Themen mit SQL lernen
-description: Dieses Tutorial hilft Lesern, grundlegende Ethereum-Konzepte wie Transaktionen, Blöcke und Gas zu verstehen, indem sie On-Chain-Daten mit der Structured Query Language (SQL) abfragen.
+description: "Dieses Tutorial hilft Lesern, grundlegende Ethereum-Konzepte wie Transaktionen, Blöcke und Gas zu verstehen, indem sie On-Chain-Daten mit der Structured Query Language (SQL) abfragen."
author: "Paul Apivat"
tags: [ "SQL", "Abfragen", "Transaktionen" ]
skill: beginner
diff --git a/public/content/translations/de/developers/tutorials/logging-events-smart-contracts/index.md b/public/content/translations/de/developers/tutorials/logging-events-smart-contracts/index.md
index 12a4ea98838..bc37e712c09 100644
--- a/public/content/translations/de/developers/tutorials/logging-events-smart-contracts/index.md
+++ b/public/content/translations/de/developers/tutorials/logging-events-smart-contracts/index.md
@@ -1,6 +1,6 @@
---
title: Protokollierung von Daten aus Smart Contracts mit Ereignissen
-description: Eine Einführung in Smart-Contract-Ereignisse und wie Sie diese zur Datenprotokollierung verwenden können
+description: "Eine Einführung in Smart-Contract-Ereignisse und wie Sie diese zur Datenprotokollierung verwenden können"
author: "jdourlens"
tags:
[
diff --git a/public/content/translations/de/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md b/public/content/translations/de/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md
index a592da5e65d..cfaebd49b30 100644
--- a/public/content/translations/de/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md
+++ b/public/content/translations/de/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md
@@ -1,6 +1,6 @@
---
-title: Merkle-Beweise für Offline Datenintegrität
-description: Sicherstellung der Datenintegrität onchain für Daten, die größtenteils offchain gespeichert sind
+title: "Merkle-Beweise für Offline Datenintegrität"
+description: "Sicherstellung der Datenintegrität onchain für Daten, die größtenteils offchain gespeichert sind"
author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
tags: [ "Speicher" ]
skill: advanced
@@ -232,7 +232,7 @@ Diese Funktion erzeugt einen Paar-Hash. Es ist nur die Solidity-Übersetzung des
} // MarkleProof
```
-In mathematischer Notation sieht die Verifizierung eines Merkle-Beweises so aus: `H(proof_n, H(proof_n-1, H(proof_n-2, ...` H(proof_1, H(proof_0, value))...)))\`. Dieser Code implementiert sie.
+In mathematischer Notation sieht die Verifizierung eines Merkle-Beweises so aus: `H(proof_n, H(proof_n-1, H(proof_n-2, ...` H(proof_1, H(proof_0, value))...)))`. Dieser Code implementiert sie.
## Merkle-Beweise und Rollups vertragen sich nicht {#merkle-proofs-and-rollups}
diff --git a/public/content/translations/de/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/index.md b/public/content/translations/de/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/index.md
index 7f1a167d61d..eecc90e0410 100644
--- a/public/content/translations/de/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/index.md
+++ b/public/content/translations/de/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/index.md
@@ -1,6 +1,6 @@
---
-title: Überwachung von Geth mit InfluxDB und Grafana
-description: Richten Sie die Überwachung für Ihren Geth-Node mit InfluxDB und Grafana ein, um die Leistung zu verfolgen und Probleme zu identifizieren.
+title: "Überwachung von Geth mit InfluxDB und Grafana"
+description: "Richten Sie die Überwachung für Ihren Geth-Node mit InfluxDB und Grafana ein, um die Leistung zu verfolgen und Probleme zu identifizieren."
author: "Mario Havel"
tags: [ "Clients", "Nodes" ]
skill: intermediate
diff --git a/public/content/translations/de/developers/tutorials/nft-minter/index.md b/public/content/translations/de/developers/tutorials/nft-minter/index.md
index 639817b074a..0e2c455f72b 100644
--- a/public/content/translations/de/developers/tutorials/nft-minter/index.md
+++ b/public/content/translations/de/developers/tutorials/nft-minter/index.md
@@ -185,7 +185,7 @@ return (
NFT minten
{status}
-
+
)
```
diff --git a/public/content/translations/de/developers/tutorials/optimism-std-bridge-annotated-code/index.md b/public/content/translations/de/developers/tutorials/optimism-std-bridge-annotated-code/index.md
index 59a7e410e1c..55f5ac6afc7 100644
--- a/public/content/translations/de/developers/tutorials/optimism-std-bridge-annotated-code/index.md
+++ b/public/content/translations/de/developers/tutorials/optimism-std-bridge-annotated-code/index.md
@@ -1,6 +1,6 @@
---
title: "Walkthrough zum Vertrag der Optimism-Standard-Brücke"
-description: Wie funktioniert die Standard-Brücke für Optimism? Warum funktioniert sie auf diese Weise?
+description: "Wie funktioniert die Standard-Brücke für Optimism? Warum funktioniert sie auf diese Weise?"
author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
tags: [ "solidity", "Brücke", "Layer 2" ]
skill: intermediate
diff --git a/public/content/translations/de/developers/tutorials/run-node-raspberry-pi/index.md b/public/content/translations/de/developers/tutorials/run-node-raspberry-pi/index.md
index b443271c60c..69721c8aada 100644
--- a/public/content/translations/de/developers/tutorials/run-node-raspberry-pi/index.md
+++ b/public/content/translations/de/developers/tutorials/run-node-raspberry-pi/index.md
@@ -1,6 +1,6 @@
---
title: Betreibe einen Ethereum-Node auf einem Raspberry Pi 4
-description: Flashe deinen Raspberry Pi 4, stecke ein Ethernet-Kabel ein, schließe die SSD-Festplatte an und schalte das Gerät ein, um den Raspberry Pi 4 in einen vollwertigen Ethereum-Node + Validator zu verwandeln
+description: "Flashe deinen Raspberry Pi 4, stecke ein Ethernet-Kabel ein, schließe die SSD-Festplatte an und schalte das Gerät ein, um den Raspberry Pi 4 in einen vollwertigen Ethereum-Node + Validator zu verwandeln"
author: "EthereumOnArm"
tags:
[
diff --git a/public/content/translations/de/developers/tutorials/scam-token-tricks/index.md b/public/content/translations/de/developers/tutorials/scam-token-tricks/index.md
index 1f72cf3b464..7b7f86f44f4 100644
--- a/public/content/translations/de/developers/tutorials/scam-token-tricks/index.md
+++ b/public/content/translations/de/developers/tutorials/scam-token-tricks/index.md
@@ -1,6 +1,6 @@
---
title: "Einige Tricks, die von Betrugs-Tokens verwendet werden, und wie man sie erkennt"
-description: In diesem Tutorial analysieren wir einen Betrugs-Token, um einige der Tricks zu sehen, die Betrüger anwenden, wie sie sie implementieren und wie wir sie erkennen können.
+description: "In diesem Tutorial analysieren wir einen Betrugs-Token, um einige der Tricks zu sehen, die Betrüger anwenden, wie sie sie implementieren und wie wir sie erkennen können."
author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
tags:
[
diff --git a/public/content/translations/de/developers/tutorials/secret-state/index.md b/public/content/translations/de/developers/tutorials/secret-state/index.md
index be7d522918b..78414174214 100644
--- a/public/content/translations/de/developers/tutorials/secret-state/index.md
+++ b/public/content/translations/de/developers/tutorials/secret-state/index.md
@@ -1,6 +1,6 @@
---
-title: Verwendung von Zero-Knowledge für einen geheimen Zustand
-description: Onchain-Spiele sind begrenzt, da sie keine versteckten Informationen enthalten können. Nach der Lektüre dieses Tutorials ist der Leser in der Lage, Zero-Knowledge-Beweise und Serverkomponenten zu kombinieren, um verifizierbare Spiele mit einer geheimen Offchain-Zustandskomponente zu erstellen. Die Technik dafür wird durch die Erstellung eines Minesweeper-Spiels demonstriert.
+title: "Verwendung von Zero-Knowledge für einen geheimen Zustand"
+description: "Onchain-Spiele sind begrenzt, da sie keine versteckten Informationen enthalten können. Nach der Lektüre dieses Tutorials ist der Leser in der Lage, Zero-Knowledge-Beweise und Serverkomponenten zu kombinieren, um verifizierbare Spiele mit einer geheimen Offchain-Zustandskomponente zu erstellen. Die Technik dafür wird durch die Erstellung eines Minesweeper-Spiels demonstriert."
author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
tags:
[
diff --git a/public/content/translations/de/developers/tutorials/secure-development-workflow/index.md b/public/content/translations/de/developers/tutorials/secure-development-workflow/index.md
index 8053e043a96..b54fa5d3820 100644
--- a/public/content/translations/de/developers/tutorials/secure-development-workflow/index.md
+++ b/public/content/translations/de/developers/tutorials/secure-development-workflow/index.md
@@ -6,7 +6,7 @@ tags: [ "Smart Contracts", "Sicherheit", "Solidity" ]
skill: intermediate
lang: de
published: 07.09.2020
-source: Aufbau sicherer Verträge
+source: "Aufbau sicherer Verträge"
sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/workflow.md
---
diff --git a/public/content/translations/de/developers/tutorials/server-components/index.md b/public/content/translations/de/developers/tutorials/server-components/index.md
index 25859af76d9..b3784445bc1 100644
--- a/public/content/translations/de/developers/tutorials/server-components/index.md
+++ b/public/content/translations/de/developers/tutorials/server-components/index.md
@@ -1,6 +1,6 @@
---
title: "Server-Komponenten und Agenten für Web3-Apps"
-description: Nach dem Lesen dieses Tutorials können Sie TypeScript-Server schreiben, die auf Ereignisse auf einer Blockchain lauschen und entsprechend mit ihren eigenen Transaktionen reagieren. Dies ermöglicht es Ihnen, zentralisierte Anwendungen zu schreiben (da der Server ein Single Point of Failure ist), die jedoch mit Web3-Entitäten interagieren können. Die gleichen Techniken können auch verwendet werden, um einen Agenten zu schreiben, der auf On-Chain-Ereignisse ohne menschliches Eingreifen reagiert.
+description: "Nach dem Lesen dieses Tutorials können Sie TypeScript-Server schreiben, die auf Ereignisse auf einer Blockchain lauschen und entsprechend mit ihren eigenen Transaktionen reagieren. Dies ermöglicht es Ihnen, zentralisierte Anwendungen zu schreiben (da der Server ein Single Point of Failure ist), die jedoch mit Web3-Entitäten interagieren können. Die gleichen Techniken können auch verwendet werden, um einen Agenten zu schreiben, der auf On-Chain-Ereignisse ohne menschliches Eingreifen reagiert."
author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
lang: de
diff --git a/public/content/translations/de/developers/tutorials/short-abi/index.md b/public/content/translations/de/developers/tutorials/short-abi/index.md
index 7939010d55e..b1a8bc3c69f 100644
--- a/public/content/translations/de/developers/tutorials/short-abi/index.md
+++ b/public/content/translations/de/developers/tutorials/short-abi/index.md
@@ -1,6 +1,6 @@
---
title: "Kurze ABIs zur Calldata-Optimierung"
-description: Optimierung von Smart Contracts für Optimistic Rollups
+description: "Optimierung von Smart Contracts für Optimistic Rollups"
author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
lang: de
tags: [ "Layer 2" ]
diff --git a/public/content/translations/de/developers/tutorials/smart-contract-security-guidelines/index.md b/public/content/translations/de/developers/tutorials/smart-contract-security-guidelines/index.md
index c54e39a3bd8..56c9bcb29e3 100644
--- a/public/content/translations/de/developers/tutorials/smart-contract-security-guidelines/index.md
+++ b/public/content/translations/de/developers/tutorials/smart-contract-security-guidelines/index.md
@@ -1,12 +1,12 @@
---
title: Smart-Contract-Sicherheitsrichtlinien
-description: Eine Checkliste der Sicherheitsrichtlinien, die beim Erstellen Ihrer dapp berücksichtigt werden sollen
+description: "Eine Checkliste der Sicherheitsrichtlinien, die beim Erstellen Ihrer dapp berücksichtigt werden sollen"
author: "Spuren von bits"
tags: [ "solidity", "Smart Contracts", "Sicherheit" ]
skill: intermediate
lang: de
published: 06.09.2020
-source: Aufbau sicherer Verträge
+source: "Aufbau sicherer Verträge"
sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/guidelines.md
---
diff --git a/public/content/translations/de/developers/tutorials/the-graph-fixing-web3-data-querying/index.md b/public/content/translations/de/developers/tutorials/the-graph-fixing-web3-data-querying/index.md
index 230078a08f3..aa78539e4f7 100644
--- a/public/content/translations/de/developers/tutorials/the-graph-fixing-web3-data-querying/index.md
+++ b/public/content/translations/de/developers/tutorials/the-graph-fixing-web3-data-querying/index.md
@@ -1,6 +1,6 @@
---
title: "The Graph: Die Behebung der Datenabfrage in Web3"
-description: Eine Blockchain ist wie eine Datenbank, aber ohne SQL. Alle Daten sind vorhanden, aber es gibt keine Möglichkeit, auf sie zuzugreifen. Ich zeige Ihnen, wie Sie dies mit The Graph und GraphQL beheben können.
+description: "Eine Blockchain ist wie eine Datenbank, aber ohne SQL. Alle Daten sind vorhanden, aber es gibt keine Möglichkeit, auf sie zuzugreifen. Ich zeige Ihnen, wie Sie dies mit The Graph und GraphQL beheben können."
author: Markus Waas
lang: de
tags:
diff --git a/public/content/translations/de/developers/tutorials/token-integration-checklist/index.md b/public/content/translations/de/developers/tutorials/token-integration-checklist/index.md
index 988df33d2f3..c264f614f86 100644
--- a/public/content/translations/de/developers/tutorials/token-integration-checklist/index.md
+++ b/public/content/translations/de/developers/tutorials/token-integration-checklist/index.md
@@ -1,5 +1,5 @@
---
-title: Checkliste für die Token-Integration
+title: "Checkliste für die Token-Integration"
description: Eine Checkliste mit Punkten, die bei der Interaktion mit Token zu beachten sind
author: "Spuren von bits"
lang: de
@@ -12,7 +12,7 @@ tags:
]
skill: intermediate
published: 13.08.2020
-source: Aufbau sicherer Verträge
+source: "Aufbau sicherer Verträge"
sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/token_integration.md
---
diff --git a/public/content/translations/de/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md b/public/content/translations/de/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
index 9158ce84c8d..5803ab88ea2 100644
--- a/public/content/translations/de/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
+++ b/public/content/translations/de/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
@@ -1,6 +1,6 @@
---
-title: Übertragung und Genehmigung von ERC-20-Token aus einem Solidity-Smart-Contract
-description: Erstellen Sie einen DEX-Smart-Contract, der ERC-20-Token-Übertragungen und -Genehmigungen mit Solidity handhabt.
+title: "Übertragung und Genehmigung von ERC-20-Token aus einem Solidity-Smart-Contract"
+description: "Erstellen Sie einen DEX-Smart-Contract, der ERC-20-Token-Übertragungen und -Genehmigungen mit Solidity handhabt."
author: "jdourlens"
tags:
[
diff --git a/public/content/translations/de/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md b/public/content/translations/de/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md
index 75e8e9b6bec..c3dd25d25ad 100644
--- a/public/content/translations/de/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md
+++ b/public/content/translations/de/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md
@@ -1,6 +1,6 @@
---
title: Den ERC-20-Token-Smart-Contract verstehen
-description: Lernen Sie, wie Sie den ERC-20-Token-Standard mit einem vollständigen Solidity-Smart-Contract-Beispiel und einer Erklärung implementieren.
+description: "Lernen Sie, wie Sie den ERC-20-Token-Standard mit einem vollständigen Solidity-Smart-Contract-Beispiel und einer Erklärung implementieren."
author: "jdourlens"
tags:
[
diff --git a/public/content/translations/de/developers/tutorials/waffle-test-simple-smart-contract/index.md b/public/content/translations/de/developers/tutorials/waffle-test-simple-smart-contract/index.md
index 6001aab3ca5..f4f079b5062 100644
--- a/public/content/translations/de/developers/tutorials/waffle-test-simple-smart-contract/index.md
+++ b/public/content/translations/de/developers/tutorials/waffle-test-simple-smart-contract/index.md
@@ -1,6 +1,6 @@
---
title: Testen eines einfachen Smart Contracts mit der Waffle-Bibliothek
-description: Tutorial für Anfänger
+description: "Tutorial für Anfänger"
author: Ewa Kowalska
tags:
[
diff --git a/public/content/translations/de/developers/tutorials/yellow-paper-evm/index.md b/public/content/translations/de/developers/tutorials/yellow-paper-evm/index.md
index 799884b082f..3111f8ebfdc 100644
--- a/public/content/translations/de/developers/tutorials/yellow-paper-evm/index.md
+++ b/public/content/translations/de/developers/tutorials/yellow-paper-evm/index.md
@@ -1,6 +1,6 @@
---
-title: Verständnis der EVM-Spezifikationen des Yellow Papers
-description: Verständnis des Teils des Yellow Papers, den formalen Spezifikationen für Ethereum, der die Ethereum Virtual Machine (EVM) erklärt.
+title: "Verständnis der EVM-Spezifikationen des Yellow Papers"
+description: "Verständnis des Teils des Yellow Papers, den formalen Spezifikationen für Ethereum, der die Ethereum Virtual Machine (EVM) erklärt."
author: "qbzzt"
tags: [ "evm" ]
skill: intermediate
diff --git a/public/content/translations/de/eips/index.md b/public/content/translations/de/eips/index.md
index c072c24f11b..08ea56934c3 100644
--- a/public/content/translations/de/eips/index.md
+++ b/public/content/translations/de/eips/index.md
@@ -1,6 +1,6 @@
---
-title: Ethereum – Vorschläge zur Verbesserung (EIPs)
-description: Grundlegende Informationen, die Sie benötigen, um EIPs zu verstehen
+title: "Ethereum – Vorschläge zur Verbesserung (EIPs)"
+description: "Grundlegende Informationen, die Sie benötigen, um EIPs zu verstehen"
lang: de
---
diff --git a/public/content/translations/de/energy-consumption/index.md b/public/content/translations/de/energy-consumption/index.md
index a6c460f7d90..aebfde6a48b 100644
--- a/public/content/translations/de/energy-consumption/index.md
+++ b/public/content/translations/de/energy-consumption/index.md
@@ -1,6 +1,6 @@
---
title: Ethereums Energieverbrauch
-description: Grundlegende Informationen, um den generellen Energieverbrauch von Ethereum verstehen zu können
+description: "Grundlegende Informationen, um den generellen Energieverbrauch von Ethereum verstehen zu können"
lang: de
---
diff --git a/public/content/translations/de/eth/supply/index.md b/public/content/translations/de/eth/supply/index.md
index d6fc3e888d9..fd47c324d0d 100644
--- a/public/content/translations/de/eth/supply/index.md
+++ b/public/content/translations/de/eth/supply/index.md
@@ -1,5 +1,5 @@
---
-title: Ein Überblick über Angebot und Ausgabe von ETH
+title: "Ein Überblick über Angebot und Ausgabe von ETH"
description: Ein einsteigerfreundlicher Leitfaden zum ETH-Angebot und zur ETH-Emission, der zentrale Konzepte wie EIPs, PoS und EIP-1559 behandelt.
lang: de
---
diff --git a/public/content/translations/de/ethereum-forks/index.md b/public/content/translations/de/ethereum-forks/index.md
index 793aa8b62f1..bb9f5fa75b6 100644
--- a/public/content/translations/de/ethereum-forks/index.md
+++ b/public/content/translations/de/ethereum-forks/index.md
@@ -1,6 +1,6 @@
---
title: Zeitachse aller Ethereum-Forks (2014 bis heute)
-description: Eine Geschichte der Ethereum-Blockchain, einschließlich der wichtigsten Meilensteine, Veröffentlichungen und Abspaltungen.
+description: "Eine Geschichte der Ethereum-Blockchain, einschließlich der wichtigsten Meilensteine, Veröffentlichungen und Abspaltungen."
lang: de
sidebarDepth: 1
---
@@ -16,7 +16,6 @@ Forks entstehen, wenn wichtige technische Neuerungen oder Änderungen am Netzwer
Wenn für eine Standardsoftware eine Aktualisierung benötigt wird, veröffentlicht der Hersteller lediglich eine neue Version für den Endbenutzer. Blockchains arbeiten anders, da es keinen alleinigen Besitzer gibt. [Ethereum Anwendungen](/developers/docs/nodes-and-clients/) müssen die Software aktualisieren um neue Regeln zu implementieren. Plus Block Ersteller (Miner in einer Proof-of-Work Umgebung, Validatoren in einer Proof-of-Stake Umgebung) und Nodes erstellen neue Blöcke und müssen diese, entsprechend der neuen Richtlinien, validieren. [Mehr zu Konsensmechanismen](/developers/docs/consensus-mechanisms/)
Diese Regeländerungen können eine vorübergehende Spaltung des Netzwerks verursachen. Neue Blöcke konnen nach den neuen oder den alten Regeln erzeugt werden. Forks werden in der Regel im Voraus vereinbart, damit die Clients die Änderungen einheitlich übernehmen und der Fork mit den Upgrades zur Main Chain wird. In seltenen Fällen können jedoch Meinungsverschiedenheiten über Forks dazu führen, dass das Netzwerk dauerhaft gespalten wird – am bekanntesten ist die Entstehung von Ethereum Classic durch den DAO Fork.
-
@@ -62,7 +61,6 @@ Die Upgrades der Ausführungs- und Konsens-Ebene wurden ursprünglich zu untersc
| Cancun | Deneb | "Dencun" |
| Prag | Electra | "Pectra" |
| Osaka | Fulu | "Fusaka" |
-
Direkt zu den Informationen über einige der besonders wichtigen vergangenen Upgrades springen: [Die Beacon Chain](/roadmap/beacon-chain/); [The Merge](/roadmap/merge/); und [EIP-1559](#london)
@@ -116,7 +114,6 @@ Protokollverbesserungen und -sicherheitsverbesserungen:
- EIP-2935 - Historische Blockhashs im Zustand speichern
- EIP-7549 - Komiteeindex außerhalb der Bestätigung verschieben
-
- [Pectra.wtf](https://pectra.wtf)
@@ -148,7 +145,6 @@ Insbesondere enthält es EIP-4844, bekannt als **Proto-Danksharding**, das die K
- EIP-6780 –
SELFDESTRUCT nur in derselben Transaktion
- EIP-7516 -
BLOBBASEFEE Operationscode
-
- [Layer-2-Rollups](/layer-2/)
@@ -173,7 +169,6 @@ EIP-7514 führt zu einer Verschärfung der ETH-Ausgabe, indem die „Churn“-Ra
- EIP-7045 - Erhöhen Sie die maximale Bescheinigung für den Einschluss inkl. Slot
- EIP-7514 - Hinzufügen der maximalen Epochen-Abwanderungsgrenze
-
- [Lesen Sie die Deneb-Upgrade-Spezifikationen](https://github.com/ethereum/consensus-specs/blob/dev/specs/deneb/)
@@ -200,7 +195,6 @@ Das Shanghai-Update ebnete den Weg für Staking-Auszahlungen auf der Ausführung
- EIP-4895 – Beacon Chain Push-Abhebungen als Operationen
- EIP-6049 – Veraltet
SELFDESTRUCT
-
- [Lesen Sie die Shanghai-Upgrade-Spezifikation](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/shanghai.md)
@@ -236,7 +230,6 @@ Das Paris-Upgrade wurde ausgelöst, als die Proof-of-Work-Blockchain eine [termi
- EIP-3675 – Ermöglicht den Übergang des Ethereum-Netzwerks vom Konsensmechanismus Proof-of-Work (PoW) zum Proof-of-Stake (PoS).
- EIP-4399 – Die SCHWIERIGKEITEN mit der Wiederverwendung und Lesbarkeit des Opcodes werden durch den PREVRANDAO behoben
-
---
@@ -268,7 +261,6 @@ Das Gray Glacier-Netzwerk-Upgrade hat die [Schwierigkeitsbombe](/glossary/#diffi
- EIP-5133 – Verzögert die Explosion der Schwierigkeitsbombe bis Ende September 2022
-
- EIP-4345 – verzögert die Schwierigkeitsbombe bis Juni 2022
-
---
@@ -349,7 +340,6 @@ Dieses Video erklärt EIP-1559 und die Vorteile, die es mit sich bringt: [EIP-15
- EIP-3541 – verhindert die Bereitstellung von Verträgen, verhindert, die mit
0xEF beginnen
- EIP-3554 – plant, das Ice Age bis Dezember 2021 zu verlängern
-
---
@@ -373,7 +363,6 @@ Mit dem Berliner Upgrade wurden die Gaskosten für bestimmte EVM-Aktionen optimi
- EIP-2929 – Gaskostenerhöhung für Zustandszugriffs-Opcodes
- EIP-2930 – fügt eine optionale Zugriffsliste hinzu
-
- EIP-2384 – verzögert die Schwierigkeitsbombe um weitere 4.000.000 Blöcke, oder etwa 611 Tage.
-
- EIP-2200 –
weitere Änderungen der Gaspreisverfahrenscodes.
-
---
@@ -490,7 +477,6 @@ Die Constantinople-Fork:
- EIP-1052 – führt die
EXTCODEHASH-Anweisung ein, um den Hash des Codes eines anderen Vertrags abzurufen.
- EIP-1234 – stellt sicher, dass die Blockchain vor dem Übergang zu Proof-of-Stake nicht einfriert und reduziert die Blockbelohnung von 3 auf 2 ETH.
-
- EIP-100 – ändert die Formel für die Einstellung des Schwierigkeitsgrades.
- EIP-649 – verzögert [Difficulty Bomb](/glossary/#difficulty-bomb) um 1 Jahr und reduziert die Blockbelohnung von 5 auf 3 ETH.
-
- EIP-161 – ermöglicht das Löschen leerer Konten, die bei DOS-Attacken hinzugefügt wurden.
- EIP-170 – ändert die maximale Codegröße, die ein Vertrag in der Blockchain haben kann, in 24576 Bytes.
-
---
@@ -577,7 +561,6 @@ Die Tangerine-Whistle-Fork war die erste Reaktion auf die Denial-of-Service(DoS)
- EIP-150 – erhöht die Gaskosten der Verfahrenscodes, die bei Spam-Attacken verwendet werden können.
- EIP-158 – reduziert die Zustandsgröße, indem sie eine große Anzahl leerer Konten entfernt, die aufgrund von Fehlern in früheren Versionen des Ethereum-Protokolls ursprünglich minimale Transaktionsgebühren enthielten.
-
---
@@ -616,7 +599,6 @@ Die Homestead-Abspaltung, die in die Zukunft schaute. Sie enthielt mehrere Proto
führt einen neuen Verfahrenscode ein: DELEGATECALL
- EIP-8 – präsentiert DEVP2P zur Erfüllung der Kompatibilitätsanforderungen
-
- Wallet installiert?
Erfahren Sie, wie Sie sie verwenden.
+ Wallet installiert?
Erfahren Sie, wie Sie sie verwenden.
+
So verwenden Sie eine Wallet
diff --git a/public/content/translations/de/guides/how-to-id-scam-tokens/index.md b/public/content/translations/de/guides/how-to-id-scam-tokens/index.md
index 6e729d28045..ecaa167c1c0 100644
--- a/public/content/translations/de/guides/how-to-id-scam-tokens/index.md
+++ b/public/content/translations/de/guides/how-to-id-scam-tokens/index.md
@@ -1,6 +1,6 @@
---
-title: So erkennen Sie betrügerische Token
-description: Erkennen von betrügerischen Token, wie sie sich legitim erscheinen lassen und wie sie sich vermeiden lassen.
+title: "So erkennen Sie betrügerische Token"
+description: "Erkennen von betrügerischen Token, wie sie sich legitim erscheinen lassen und wie sie sich vermeiden lassen."
lang: de
---
@@ -20,7 +20,6 @@ title="Was ist ARB?"
contentPreview=''>
Arbitrum ist eine Organisation, die [Optimistic Rollups](/developers/docs/scaling/optimistic-rollups/) entwickelt und verwaltet. Ursprünglich war Arbitrum als gewinnorientiertes Unternehmen organisiert, unternahm dann aber Schritte zur Dezentralisierung. Als Teil dieses Prozesses haben sie einen handelbaren [Governance-Token](/dao/#token-based-membership) ausgegeben.
-
In Ethereum gibt es eine Konvention: Wird ein Asset erstellt, das nicht ERC-20-kompatibel ist, wird eine " Wrapped"-Version erstellt wird, deren Name mit "w" beginnt. So gibt es beispielsweise wBTC für Bitcoin und wETH für Ether.
Es ergibt keinen Sinn, eine Wrapped-Version eines ERC-20-Tokens zu erstellen, der bereits auf Ethereum vorhanden ist, aber Betrüger verlassen sich eher auf den Anschein von Legitimität als auf die zugrunde liegende Realität.
-
## Wie funktionieren betrügerische Token? {#how-do-scam-tokens-work}
@@ -42,7 +40,6 @@ title="Was sind Smart Contracts?"
contentPreview=''>
[Smart Contracts](/developers/docs/smart-contracts/) sind die Programme, die auf der Ethereum-Blockchain ausgeführt werden. Jeder ERC-20 Token ist beispielsweise als Smart Contract implementiert.
-
Genauer gesagt hat Arbitrum einen Vertrag bereitgestellt, der das Symbol `ARB` verwendet. Doch das hält andere Menschen nicht davon ab, ebenfalls einen Contract einzusetzen, der dasselbe oder ein ähnliches Symbol nutzt. Wer den Contract schreibt, kann bestimmen, wofür er verwendet wird.
diff --git a/public/content/translations/de/guides/how-to-revoke-token-access/index.md b/public/content/translations/de/guides/how-to-revoke-token-access/index.md
index ade47f4b6fd..59bf6b53032 100644
--- a/public/content/translations/de/guides/how-to-revoke-token-access/index.md
+++ b/public/content/translations/de/guides/how-to-revoke-token-access/index.md
@@ -1,6 +1,6 @@
---
title: So widerrufen Sie den Smart-Contract-Zugriff auf Ihre Krypto-Geldmittel
-description: Ein Leitfaden für den Widerruf des Zugriffs auf ausbeuterische Smart Contract Token
+description: "Ein Leitfaden für den Widerruf des Zugriffs auf ausbeuterische Smart Contract Token"
lang: de
---
@@ -49,7 +49,8 @@ Wir empfehlen Ihnen, das Widerrufs-Tool nach einigen Minuten zu aktualisieren un
- Möchten Sie mehr erfahren?
+ Möchten Sie mehr erfahren?
+
Sehen Sie unsere anderen Anleitungen
diff --git a/public/content/translations/de/guides/how-to-swap-tokens/index.md b/public/content/translations/de/guides/how-to-swap-tokens/index.md
index 7ee9ebedcf2..69b481ac259 100644
--- a/public/content/translations/de/guides/how-to-swap-tokens/index.md
+++ b/public/content/translations/de/guides/how-to-swap-tokens/index.md
@@ -52,7 +52,8 @@ Sie werden die getauschten Token automatisch in Ihrer Krypto-Wallet erhalten, we
- Möchten Sie mehr erfahren?
+ Möchten Sie mehr erfahren?
+
Sehen Sie unsere anderen Anleitungen
diff --git a/public/content/translations/de/guides/how-to-use-a-bridge/index.md b/public/content/translations/de/guides/how-to-use-a-bridge/index.md
index 8f49656896f..aa4fd9914cc 100644
--- a/public/content/translations/de/guides/how-to-use-a-bridge/index.md
+++ b/public/content/translations/de/guides/how-to-use-a-bridge/index.md
@@ -1,6 +1,6 @@
---
-title: Wie man Token auf die Layer 2 überträgt
-description: Ein Leitfaden, der erklärt, wie man Token von Ethereum mithilfe eines Übergangs zu Ebene 2 überträgt.
+title: "Wie man Token auf die Layer 2 überträgt"
+description: "Ein Leitfaden, der erklärt, wie man Token von Ethereum mithilfe eines Übergangs zu Ebene 2 überträgt."
lang: de
---
@@ -54,7 +54,8 @@ Sie können [chainlist.org](http://chainlist.org) verwenden, um die RPC-Details
- Möchten Sie mehr erfahren?
+ Möchten Sie mehr erfahren?
+
Sehen Sie unsere anderen Anleitungen
diff --git a/public/content/translations/de/guides/how-to-use-a-wallet/index.md b/public/content/translations/de/guides/how-to-use-a-wallet/index.md
index 2046f7ac5d0..4919ad467eb 100644
--- a/public/content/translations/de/guides/how-to-use-a-wallet/index.md
+++ b/public/content/translations/de/guides/how-to-use-a-wallet/index.md
@@ -1,6 +1,6 @@
---
title: So verwendest du eine Wallet
-metaTitle: Der richtige Umgang mit Ethereum-Wallets | Eine Schritt-für-Schritt-Anleitung
+metaTitle: "Der richtige Umgang mit Ethereum-Wallets | Eine Schritt-für-Schritt-Anleitung"
description: Ein Leitfaden zum Versenden, Empfangen von Token und Verbinden mit Web-3 Projekten.
lang: de
---
@@ -65,7 +65,8 @@ Ihre Adresse wird auf allen Ethereum Projekten dieselbe sein. Sie brauchen sich
- Möchten Sie mehr erfahren?
+ Möchten Sie mehr erfahren?
+
Sehen Sie unsere anderen Anleitungen
diff --git a/public/content/translations/de/guides/index.md b/public/content/translations/de/guides/index.md
index d08d6094dea..6d211e636cb 100644
--- a/public/content/translations/de/guides/index.md
+++ b/public/content/translations/de/guides/index.md
@@ -1,6 +1,6 @@
---
-title: Ethereum Leitfäden
-description: Eine Sammlung an praktischen Leitfäden, welche Anfängern die Grundlagen von Ethereum erklärt.
+title: "Ethereum Leitfäden"
+description: "Eine Sammlung an praktischen Leitfäden, welche Anfängern die Grundlagen von Ethereum erklärt."
lang: de
---
diff --git a/public/content/translations/de/nft/index.md b/public/content/translations/de/nft/index.md
index 885351eea9d..cdc97c65d59 100644
--- a/public/content/translations/de/nft/index.md
+++ b/public/content/translations/de/nft/index.md
@@ -1,7 +1,7 @@
---
title: Non Fungible Token (NFT)
metaTitle: Was sind NFTs? | Vorteile und Verwendung
-description: Ein Überblick über NFTs bei Ethereum
+description: "Ein Überblick über NFTs bei Ethereum"
lang: de
template: use-cases
emoji: ":frame_with_picture:"
@@ -10,7 +10,7 @@ image: /images/infrastructure_transparent.png
alt: Ein als Hologramm abgebildetes ETH-Logo.
summaryPoint1: Ein Weg, alles Einzigartige als eine Ethereum-basierte Anlage darzustellen.
summaryPoint2: NFTs geben Inhaltserstellern mehr Einfluss denn je.
-summaryPoint3: Auf Grundlage von intelligenten Verträgen auf der Ethereum-Blockchain.
+summaryPoint3: "Auf Grundlage von intelligenten Verträgen auf der Ethereum-Blockchain."
---
## Was sind NFTs? {#what-are-nfts}
@@ -58,7 +58,8 @@ Vielleicht sind Sie ein Künstler, der seine Werke mithilfe von NFTs verbreiten
- Entdecken, kaufen oder erstellen Sie Ihre eigene(n) NFT-Kunst/Sammelgegenstände ...
+ Entdecken, kaufen oder erstellen Sie Ihre eigene(n) NFT-Kunst/Sammelgegenstände ...
+
NFT-Kunst entdecken
diff --git a/public/content/translations/de/payments/index.md b/public/content/translations/de/payments/index.md
index 90a42389b02..3bf21207194 100644
--- a/public/content/translations/de/payments/index.md
+++ b/public/content/translations/de/payments/index.md
@@ -1,15 +1,15 @@
---
title: Ethereum-Zahlungen
metaTitle: Zahlungen auf Ethereum
-description: Ein Überblick über Zahlungen auf Ethereum
+description: "Ein Überblick über Zahlungen auf Ethereum"
lang: de
template: use-cases
emoji: ":frame_with_picture:"
sidebarDepth: 2
image: /images/impact_transparent.png
-alt: Ein ETH-Logo, das zusammen mit gebenden Händen abgebildet ist.
+alt: "Ein ETH-Logo, das zusammen mit gebenden Händen abgebildet ist."
summaryPoint1: Eine Welt, in der sich Geld so frei bewegt wie Informationen
-summaryPoint2: Offen und global, ermöglicht grenzenlose Transaktionen für alle
+summaryPoint2: "Offen und global, ermöglicht grenzenlose Transaktionen für alle"
summaryPoint3: Zahlungen, die innerhalb einer Minute eingehen
---
@@ -20,7 +20,6 @@ Dies ist kein ferner Traum – es geschieht heute auf Ethereum. Obwohl tradition
-
## Überweisungen: günstigere internationale Transfers {#remittances}
@@ -61,7 +60,8 @@ In Ländern, in denen ihre Zahlungsmittel vom Rest der Welt abgekoppelt wurden,
- Erstellen Sie noch heute Ihr Ethereum-Konto mit einer Wallet-App.
+ Erstellen Sie noch heute Ihr Ethereum-Konto mit einer Wallet-App.
+
Jetzt loslegen
@@ -143,7 +143,6 @@ Das Ergebnis? Über 6 Millionen Dollar wurden innerhalb weniger Tage gesammelt,
-
## Ethereum vs. Fiat {#ethereum-vs-fiat}
@@ -190,7 +189,6 @@ Mit Ethereum kann jeder sehen, wie sich Geld bewegt und wie Kosten umgesetzt wer
-
Während Fiat-Währungen den Vorteil der weit verbreiteten Akzeptanz und Stabilität haben, bietet Ethereum einzigartige Vorteile, die es zu einer attraktiven Option für bestimmte Arten von Transaktionen machen.
@@ -200,7 +198,8 @@ Von der Erleichterung der schnellen Katastrophenhilfe bis zur Stärkung globaler
- Zeit, Ihr eigenes Ethereum-Konto zu erstellen.
+ Zeit, Ihr eigenes Ethereum-Konto zu erstellen.
+
Jetzt loslegen!
diff --git a/public/content/translations/de/prediction-markets/index.md b/public/content/translations/de/prediction-markets/index.md
index 2058e16bd83..fce64fa499a 100644
--- a/public/content/translations/de/prediction-markets/index.md
+++ b/public/content/translations/de/prediction-markets/index.md
@@ -1,11 +1,11 @@
---
-title: Prognosemärkte
+title: "Prognosemärkte"
lang: de
template: use-cases
image: /images/use-cases/prediction-markets.png
sidebarDepth: 2
-summaryPoint1: Finanzielle Anreize für die Erstellung präziser Prognosen erhalten
-summaryPoint2: Hochwertige Vorhersagen zu zukünftigen Ereignissen
+summaryPoint1: "Finanzielle Anreize für die Erstellung präziser Prognosen erhalten"
+summaryPoint2: "Hochwertige Vorhersagen zu zukünftigen Ereignissen"
buttons:
- content: Mehr erfahren
toId: how-prediction-markets-work
diff --git a/public/content/translations/de/privacy/index.md b/public/content/translations/de/privacy/index.md
index 173ab4e4846..8bd6096d63d 100644
--- a/public/content/translations/de/privacy/index.md
+++ b/public/content/translations/de/privacy/index.md
@@ -1,6 +1,6 @@
---
title: Datenschutz auf Ethereum
-description: Werkzeuge und Techniken zum Schutz Ihrer Privatsphäre auf Ethereum
+description: "Werkzeuge und Techniken zum Schutz Ihrer Privatsphäre auf Ethereum"
lang: de
---
diff --git a/public/content/translations/de/real-world-assets/index.md b/public/content/translations/de/real-world-assets/index.md
index 8a83ac2e000..ceb6a3272f0 100644
--- a/public/content/translations/de/real-world-assets/index.md
+++ b/public/content/translations/de/real-world-assets/index.md
@@ -1,16 +1,16 @@
---
-title: Real wertige Vermögenswerte (RWAs)
-metaTitle: Was sind Real-World-Assets (RWAs)? | Vorteile und Einsatzmöglichkeiten von Real-World Assets (RWAs)
-description: Ein Überblick über Real-World Assets (RWAs) auf Ethereum
+title: "Real wertige Vermögenswerte (RWAs)"
+metaTitle: "Was sind Real-World-Assets (RWAs)? | Vorteile und Einsatzmöglichkeiten von Real-World Assets (RWAs)"
+description: "Ein Überblick über Real-World Assets (RWAs) auf Ethereum"
lang: de
template: use-cases
emoji: ":house_buildings:"
image: /images/man-and-dog-playing.png
alt: Mann und Hund beim Spielen.
sidebarDepth: 2
-summaryPoint1: Eine Methode, um wertvolle Güter in digitale Token umzuwandeln.
-summaryPoint2: Es ist nun möglich, Anteile an realen Objekten oder Vermögenswerten zu erwerben, anstatt eine vollständige Immobilie oder ein gesamtes Objekt kaufen zu müssen.
-summaryPoint3: Verbindet die traditionelle Finanzwelt mit dem Blockchain-Ökosystem.
+summaryPoint1: "Eine Methode, um wertvolle Güter in digitale Token umzuwandeln."
+summaryPoint2: "Es ist nun möglich, Anteile an realen Objekten oder Vermögenswerten zu erwerben, anstatt eine vollständige Immobilie oder ein gesamtes Objekt kaufen zu müssen."
+summaryPoint3: "Verbindet die traditionelle Finanzwelt mit dem Blockchain-Ökosystem."
---
Reale Vermögenswerte (RWAs) sind Token, die bestehende Formen von Vermögen repräsentieren, wie etwa Immobilien, Gold, Aktien, Kunstwerke, Maschinen oder Sammlerstücke. Die Tokenisierung dieser Vermögenswerte überführt sie in digitale Form, wodurch eine Aufteilung auf mehrere Eigentümer ermöglicht und ihr Handel erleichtert wird.
diff --git a/public/content/translations/de/refi/index.md b/public/content/translations/de/refi/index.md
index a6f4475bac3..a1e2ba3c180 100644
--- a/public/content/translations/de/refi/index.md
+++ b/public/content/translations/de/refi/index.md
@@ -1,6 +1,6 @@
---
title: Regenerative Finanzen (ReFi)
-description: Ein Überblick über ReFi und die aktuellen Anwendungsfälle.
+description: "Ein Überblick über ReFi und die aktuellen Anwendungsfälle."
lang: de
template: use-cases
emoji: ":recycle:"
@@ -8,8 +8,8 @@ sidebarDepth: 2
image: /images/future_transparent.png
alt: ""
summaryPoint1: Ein alternatives, auf regenerativen Prinzipien beruhendes Wirtschaftssystem
-summaryPoint2: Ein Versuch, Ethereum für die Lösung globaler Koordinationskrisen wie dem Klimawandel nutzbar zu machen
-summaryPoint3: Ein Werkzeug zur drastischen Skalierung von Vermögenswerten mit ökologischem Nutzen, wie z. B. verifizierten Kohlenstoffgutschriften
+summaryPoint2: "Ein Versuch, Ethereum für die Lösung globaler Koordinationskrisen wie dem Klimawandel nutzbar zu machen"
+summaryPoint3: "Ein Werkzeug zur drastischen Skalierung von Vermögenswerten mit ökologischem Nutzen, wie z. B. verifizierten Kohlenstoffgutschriften"
---
## Was ist ReFi? {#what-is-refi}
diff --git a/public/content/translations/de/restaking/index.md b/public/content/translations/de/restaking/index.md
index bbe7292e275..95c3b9bdd3e 100644
--- a/public/content/translations/de/restaking/index.md
+++ b/public/content/translations/de/restaking/index.md
@@ -1,14 +1,14 @@
---
title: Restaking
metaTitle: Was ist Restaking? | Vorteile und Nutzung von Restaking
-description: Verwenden Sie gestakte ETH, um andere dezentralisierte Dienste abzusichern und zusätzliche Belohnungen zu verdienen.
+description: "Verwenden Sie gestakte ETH, um andere dezentralisierte Dienste abzusichern und zusätzliche Belohnungen zu verdienen."
lang: de
template: use-cases
emoji: ":recycle:"
image: /images/use-cases/restaking.png
alt: Eine visuelle Darstellung des Restakings auf Ethereum.
sidebarDepth: 2
-summaryPoint1: Verwenden Sie gestakte ETH, um andere dezentralisierte Dienste abzusichern und zusätzliche Belohnungen zu verdienen.
+summaryPoint1: "Verwenden Sie gestakte ETH, um andere dezentralisierte Dienste abzusichern und zusätzliche Belohnungen zu verdienen."
buttons:
- content: Was ist Restaking?
toId: what-is-restaking
diff --git a/public/content/translations/de/roadmap/account-abstraction/index.md b/public/content/translations/de/roadmap/account-abstraction/index.md
index 4a9f869ab7d..b4d4f568f69 100644
--- a/public/content/translations/de/roadmap/account-abstraction/index.md
+++ b/public/content/translations/de/roadmap/account-abstraction/index.md
@@ -1,6 +1,6 @@
---
title: Kontoabstraktion
-description: Ein Überblick über die Pläne von Ethereum, Nutzerkonten einfacher und sicherer zu machen
+description: "Ein Überblick über die Pläne von Ethereum, Nutzerkonten einfacher und sicherer zu machen"
lang: de
summaryPoints:
- Account-Abstraktion macht es deutlich einfacher, Smart-Contract-Wallets zu bauen
diff --git a/public/content/translations/de/roadmap/beacon-chain/index.md b/public/content/translations/de/roadmap/beacon-chain/index.md
index f447de61f69..20c2f249734 100644
--- a/public/content/translations/de/roadmap/beacon-chain/index.md
+++ b/public/content/translations/de/roadmap/beacon-chain/index.md
@@ -1,13 +1,13 @@
---
title: Die Beacon-Chain
-description: Informieren Sie sich über die Beacon Chain – das Upgrade, mit dem Proof-of-Stake für Ethereum eingeführt wurde
+description: "Informieren Sie sich über die Beacon Chain – das Upgrade, mit dem Proof-of-Stake für Ethereum eingeführt wurde"
lang: de
template: upgrade
image: /images/upgrades/core.png
alt:
-summaryPoint1: Mit der Bacon Chain wurde Proof-of-Stake in das Ethereum-Ökosystem eingeführt.
-summaryPoint2: Sie wurde im September 2022 mit der ursprünglichen Proof-of-Work-Blockchain von Ethereum vereinigt.
-summaryPoint3: Mit der Beacon Chain wurde die Konsenslogik und das Block-Gossip-Protokoll eingeführt, die heute für die Sicherheit von Ethereum sorgen.
+summaryPoint1: "Mit der Bacon Chain wurde Proof-of-Stake in das Ethereum-Ökosystem eingeführt."
+summaryPoint2: "Sie wurde im September 2022 mit der ursprünglichen Proof-of-Work-Blockchain von Ethereum vereinigt."
+summaryPoint3: "Mit der Beacon Chain wurde die Konsenslogik und das Block-Gossip-Protokoll eingeführt, die heute für die Sicherheit von Ethereum sorgen."
---
@@ -18,8 +18,7 @@ summaryPoint3: Mit der Beacon Chain wurde die Konsenslogik und das Block-Gossip-
Die Beacon Chain ist der Name der ursprünglichen Proof-of-Stake (Anteilsnachweis) Blockchain, die im Jahr 2020 eingeführt wurde. Sie wurde geschaffen, um sicherzustellen, dass die Proof-of-Stake Konsenslogik sicher und nachhaltig ist, bevor sie auf dem Ethereum Mainnet eingeführt wurde. Sie wurde daher neben dem ursprünglichen Proof-of-Work Konsens für Ethereum betrieben. Die Beacon Chain bestand aus 'leeren' Blöcken. Die Umstellung von Proof-of-Work (Arbeitsnachweis) auf den Proof-of-Stake (Anteilsnachweis) Mechanismus auf Ethereum erforderte jedoch, dass die Beacon Chain angewiesen wurde, Transaktionsdaten von Ausführungsklienten anzunehmen, sie zu Blockbündeln zusammenzuführen und sie dann mithilfe eines auf dem Proof-of-Stake-Mechanismus basierenden Konsensverfahrens in eine Blockchain zu organisieren. Zur gleichen Zeit haben die ursprünglichen Ethereum Clients ihr Mining, die Blockausbreitung und die Konsenslogik abgeschaltet und alles an die Beacon Chain übergeben. Dieses Ereignis war als [The Merge](/roadmap/merge/) bekannt. Nachdem das Merge (Fusion)-Ereignis erfolgreich abgeschlossen war, existierten keine zwei Blockchains mehr. Stattdessen existierte nur noch ein Proof-of-Stake Ethereum, für das nun pro Knoten zwei verschiedene Klienten erforderlich waren. Die Beacon Chain ist nun die Konsensus-Ebene, ein Peer-to-Peer-Netzwerk von Konsens-Clients, das für den Block-Tratsch und die Konsensus-Logik zuständig ist, während die ursprünglichen Clients die Ausführungs-Ebene bilden, die für den Tratsch und die Ausführung von Transaktionen sowie die Verwaltung des Ethereum-Status verantwortlich ist. Die beiden Schichten können über die Engine-API miteinander kommunizieren.
-## Welche Funktion hat die Beacon Chain? Welche Funktion hat die Beacon Chain? {#what-does-the-beacon-chain-do}
-
+## Welche Funktion hat die Beacon Chain? {#what-does-the-beacon-chain-do}
Die Beacon Chain ist die Bezeichnung für ein Hauptbuch von Konten, das das Netzwerk der Ethereum-[Staker](/staking/) betrieb und koordinierte, bevor diese Staker mit der Validierung echter Ethereum-Blöcke begannen. Es werden jedoch keine Transaktionen verarbeitet oder Smart-Contract-Interaktionen abgewickelt, da dies in der Ausführungs-Ebene geschieht.
Die Beacon Chain ist verantwortlich für Dinge wie die Handhabung von Blöcken und Bescheinigungen, die Ausführung des Fork-Choice-Algorithmus und die Verwaltung von Belohnungen und Strafen.
Lesen Sie mehr auf unserer [Seite zur Node-Architektur](/developers/docs/nodes-and-clients/node-architecture/#node-comparison).
diff --git a/public/content/translations/de/roadmap/danksharding/index.md b/public/content/translations/de/roadmap/danksharding/index.md
index ea39ade36f7..b35f8fccdce 100644
--- a/public/content/translations/de/roadmap/danksharding/index.md
+++ b/public/content/translations/de/roadmap/danksharding/index.md
@@ -1,6 +1,6 @@
---
title: Danksharding
-description: Erfahre mehr über Proto-Danksharding und Danksharding - zwei aufeinanderfolgende Upgrades zur Skalierung von Ethereum.
+description: "Erfahre mehr über Proto-Danksharding und Danksharding - zwei aufeinanderfolgende Upgrades zur Skalierung von Ethereum."
lang: de
summaryPoints:
- Danksharding ist ein mehrphasiges Upgrade, um die Skalierbarkeit und Kapazität von Ethereum zu verbessern.
@@ -22,13 +22,11 @@ Das ist teuer, weil die Daten von allen Ethereum-Nodes verarbeitet werden und f
Rollups sind eine Möglichkeit, Ethereum zu skalieren, indem Transaktionen offchain gebatcht und die Ergebnisse dann auf Ethereum gepostet werden. Ein Rollup besteht im Wesentlichen aus zwei Teilen: Daten und Ausführungsprüfung. Die Daten sind die vollständige Abfolge von Transaktionen, die von einem Rollup verarbeitet werden, um die Zustandsänderung zu erzeugen, die zu Ethereum gepostet wird. Die Ausführungsprüfung ist die Wiederholung dieser Transaktionen durch einen ehrlichen Akteur (einen "Prover"), um sicherzustellen, dass die vorgeschlagene Zustandsänderung korrekt ist. Um die Ausführungsprüfung durchführen zu können, müssen die Transaktionsdaten lange genug verfügbar sein, damit sie von jedem heruntergeladen und überprüft werden können. Das bedeutet, dass jedes unehrliche Verhalten des Rollup-Sequenzierers vom Beweiser erkannt und herausgefordert werden kann. Allerdings muss es nicht für immer verfügbar sein.
-
Rollups veröffentlichen onchain Commitments zu ihren Transaktionsdaten und stellen die eigentlichen Daten in Daten-Blobs zur Verfügung. Das bedeutet, dass Beweiser überprüfen können, ob die Verpflichtungen gültig sind, oder Daten herausfordern können, von denen sie glauben, dass sie falsch sind. Auf Node-Ebene werden die Datenblobs im Konsens-Client gehalten. Die Konsens-Clients bezeugen, dass sie die Daten gesehen haben und dass sie im Netzwerk verbreitet wurden. Wenn die Daten für immer aufbewahrt würden, würden diese Clients aufgebläht und zu hohen Hardwareanforderungen für den Betrieb von Nodes führen. Stattdessen werden die Daten alle 18 Tage automatisch aus dem Node gelöscht. Die Beglaubigungen des Konsens-Clients belegen, dass Beweisende ausreichend Gelegenheit hatten, die Daten zu überprüfen. Die eigentlichen Daten können von Rollup-Betreibern, Benutzern oder anderen offchain gespeichert werden.
-
### Wie werden Blob-Daten überprüft? {#how-are-blobs-verified}
@@ -48,13 +46,11 @@ Die EIP-4844 KZG-Zeremonie war für die Öffentlichkeit zugänglich. Zehntausend
Wenn ein Rollup Daten in einem Blob postet, stellt es ein "Commitment" zur Verfügung, das onchain gepostet wird. Dieses Commitment ist das Ergebnis der Auswertung eines an die Daten angepassten Polynoms an bestimmten Punkten. Diese Punkte werden durch die in der KZG-Zeremonie erzeugten Zufallszahlen definiert. Beweiser können dann das Polynom an denselben Punkten auswerten, um die Daten zu überprüfen - wenn sie zu denselben Werten kommen, dann sind die Daten korrekt.
-
Wenn jemand die zufälligen Stellen kennt, die für das Commitment verwendet werden, ist es einfach, ein neues Polynom zu erzeugen, das an diesen spezifischen Punkten passt (d. h. eine "Kollision"). Das bedeutet, sie könnten Daten zum Blob hinzufügen oder daraus entfernen und dennoch einen gültigen Nachweis liefern. Um dies zu verhindern, erhalten die Beweiser statt der tatsächlichen geheimen Positionen diese Positionen eingehüllt in eine kryptographische "Black Box" unter Verwendung elliptischer Kurven. Diese verzerren die Werte effektiv auf eine Weise, dass die ursprünglichen Werte nicht rückentwickelt werden können, aber mit einiger cleverer Algebra können Beweiser und Verifizierer immer noch Polynome an den Punkten auswerten, die sie repräsentieren.
-
@@ -70,13 +66,11 @@ Dies funktioniert, indem die an die Blöcke angehängten Blobs von sechs (6) bei
Die Trennung von Vorschlagenden und Erstellenden ist notwendig, um zu verhindern, dass einzelne Validatoren teure Verpflichtungen und Nachweise für 32MB Blob-Daten erzeugen müssen. Dies würde zu einer zu großen Belastung für Heim-Staker führen und sie dazu zwingen, in leistungsfähigere Hardware zu investieren, was die Dezentralisierung beeinträchtigen würde. Stattdessen übernehmen spezialisierte Blockersteller die Verantwortung für diese aufwändige Rechenarbeit. Dann stellen sie ihre Blöcke den Blockvorschlägern zur Verfügung, um sie zu senden. Der Blockvorschläger wählt einfach den Block aus, der am rentabelsten ist. Jeder kann die Blobs kostengünstig und schnell überprüfen, was bedeutet, dass jeder normale Validator überprüfen kann, ob die Blockersteller ehrlich handeln. Dies ermöglicht die Verarbeitung der großen Blobs, ohne die Dezentralisierung zu opfern. Block Builder, die sich schlecht verhalten, könnten einfach aus dem Netzwerk geworfen und bestraft werden - andere würden ihren Platz einnehmen, weil Block Building eine profitable Tätigkeit ist.
-
Validators only have to download a small piece of each blob in order to verify its availability, rather than the entire thing. Mithilfe des Data Availability Samplings können die Validatoren sehr sicher sein, dass die Blob-Daten verfügbar waren und korrekt bestätigt wurden. Jeder Validator kann zufällig nur einige Datenpunkte abrufen und einen Nachweis erstellen, was bedeutet, dass kein Validator den gesamten Blob überprüfen muss. Fehlen irgendwelche Daten, wird dies schnell erkannt und der Blob abgelehnt.
-
### Aktueller Fortschritt {#current-progress}
diff --git a/public/content/translations/de/roadmap/dencun/index.md b/public/content/translations/de/roadmap/dencun/index.md
index 2032036d02f..64087ab051d 100644
--- a/public/content/translations/de/roadmap/dencun/index.md
+++ b/public/content/translations/de/roadmap/dencun/index.md
@@ -1,6 +1,6 @@
---
title: FAQs zu Cancun-Deneb (Dencun)
-description: Häufig gestellte Fragen zum Netzwerk-Upgrade Cancun-Deneb (Dencun)
+description: "Häufig gestellte Fragen zum Netzwerk-Upgrade Cancun-Deneb (Dencun)"
lang: de
---
diff --git a/public/content/translations/de/roadmap/fusaka/index.md b/public/content/translations/de/roadmap/fusaka/index.md
index 3f88caaea2d..ea4d90f7205 100644
--- a/public/content/translations/de/roadmap/fusaka/index.md
+++ b/public/content/translations/de/roadmap/fusaka/index.md
@@ -1,6 +1,6 @@
---
title: Fulu-Osaka (Fusaka)
-description: Erfahren Sie mehr über das Fusaka-Protokoll-Upgrade
+description: "Erfahren Sie mehr über das Fusaka-Protokoll-Upgrade"
lang: de
---
diff --git a/public/content/translations/de/roadmap/fusaka/peerdas/index.md b/public/content/translations/de/roadmap/fusaka/peerdas/index.md
index bc39e0641db..b77a2af24da 100644
--- a/public/content/translations/de/roadmap/fusaka/peerdas/index.md
+++ b/public/content/translations/de/roadmap/fusaka/peerdas/index.md
@@ -1,6 +1,6 @@
---
title: PeerDAS
-description: Erfahren Sie mehr über PeerDAS als Teil des Fusaka-Ethereum-Protokoll-Upgrades
+description: "Erfahren Sie mehr über PeerDAS als Teil des Fusaka-Ethereum-Protokoll-Upgrades"
lang: de
---
diff --git a/public/content/translations/de/roadmap/future-proofing/index.md b/public/content/translations/de/roadmap/future-proofing/index.md
index 8267831e776..0f48902bfe5 100644
--- a/public/content/translations/de/roadmap/future-proofing/index.md
+++ b/public/content/translations/de/roadmap/future-proofing/index.md
@@ -1,6 +1,6 @@
---
title: Zukunftssicherung von Ethereum
-description: Diese Verbesserungen festigen Ethereum als widerstandsfähige und dezentrale Grundlage für die ungewisse Zukunft.
+description: "Diese Verbesserungen festigen Ethereum als widerstandsfähige und dezentrale Grundlage für die ungewisse Zukunft."
lang: de
image: /images/roadmap/roadmap-future.png
alt: "Ethereum-Roadmap"
diff --git a/public/content/translations/de/roadmap/merge/index.md b/public/content/translations/de/roadmap/merge/index.md
index 56eee057a37..963c03b3739 100644
--- a/public/content/translations/de/roadmap/merge/index.md
+++ b/public/content/translations/de/roadmap/merge/index.md
@@ -1,13 +1,13 @@
---
title: Der Zusammenschluss
-description: Erfahren Sie mehr über die Zusammenführung, als Mainnet Ethereum Proof-of-Stake einführte.
+description: "Erfahren Sie mehr über die Zusammenführung, als Mainnet Ethereum Proof-of-Stake einführte."
lang: de
template: upgrade
image: /images/upgrades/merge.png
alt:
summaryPoint1: Im Ethereum Mainnet wird Proof-of-Stake verwendet, aber dies war nicht immer der Fall.
-summaryPoint2: Der Wechsel vom ursprünglichen Proof-of-Work-Mechanismus zu Proof-of-Stake wurde The Merge genannt.
-summaryPoint3: The Merge bezieht sich darauf, dass das ursprüngliche Ethereum Mainnet mit einer separaten Proof-of-Stake-Blockchain namens Beacon Chain zusammengeführt wurde und somit nun beide als eine Blockchain existieren.
+summaryPoint2: "Der Wechsel vom ursprünglichen Proof-of-Work-Mechanismus zu Proof-of-Stake wurde The Merge genannt."
+summaryPoint3: "The Merge bezieht sich darauf, dass das ursprüngliche Ethereum Mainnet mit einer separaten Proof-of-Stake-Blockchain namens Beacon Chain zusammengeführt wurde und somit nun beide als eine Blockchain existieren."
summaryPoint4: Nach The Merge reduzierte sich Ethereums Energieverbrauch um ~99,95 %.
---
@@ -70,7 +70,8 @@ Zu den Schlüsselaktionen gehören:
Wenn Sie die ersten beiden obigen Elemente nicht abschließen, wird Ihre Node als "offline" betrachtet, bis beide Ebenen synchronisiert und authentifiziert sind.
-Wenn kein "Gebührenempfänger" gesetzt wird, kann sich dein Validator wie üblich verhalten, aber Sie werden auf unverbrannte Gebührentipps verzichten und alle MEV, die Sie sonst in Blöcken verdient hätten, die Ihr Validator vorschlägt.
+Wenn kein "Gebührenempfänger" gesetzt wird, kann sich dein Validator wie üblich verhalten, aber Sie werden auf unverbrannte Gebührentipps verzichten und alle MEV, die Sie sonst in Blöcken verdient hätten, die Ihr Validator vorschlägt.
+
Weitere Informationen findest Du in diesem Blogartikel von Tim Heiko zum Thema The Merge Update: Welche Auswirkungen hat das Ereignis auf die Ethereum-Execution Layer?.
-
## Die Zusammenführung und der Energieverbrauch {#merge-and-energy}
@@ -134,7 +133,6 @@ Jeder kann einen Knoten betreiben, der allerdings nicht erlaubt, andere Blöcke
Die Möglichkeit für jeden, einen eigenen Node zu betreiben, ist absolut essentiell zur Aufrechterhaltung der Dezentralisierung des Ethereum-Netzwerks.
[Mehr zum Betreiben Ihrer eigenen Node](/run-a-node/)
-
Rollup-zentrierten Roadmap konzentrieren sich die Bemühungen auf die Skalierung der Benutzeraktivität auf [Ebene 2](/layer-2/), während das Mainnet der Ebene 1 als sichere dezentrale Abwicklungsebene aktiviert wird, die für die Speicherung von Rollup-Daten optimiert ist, um Rollup-Transaktionen exponentiell günstiger zu machen. Der Übergang zu Proof-of-Stake ist ein entscheidender Vorläufer für die Umsetzung. [Mehr zu Gas und Gebühren.](/developers/docs/gas/)
-
Abhebungsadresse um automatische Auszahlungen von überschüssigem für Staking eingesetzten ETH zu erhalten (ETH über 32 aus Protokollbelohnungen). Mit diesem Upgrade wurde auch die Möglichkeit geschaffen, dass ein Validator sein gesamtes Guthaben beim Verlassen des Netzwerkes entsperren und zurückfordern kann.
[Mehr zu Staking-Auszahlungen](/staking/withdrawals/)
-
+Der effektive Jahreszins ist auch bewusst dynamisch, damit ein Markt von Stakern abwägen kann, wie viel sie bereit sind, für die Sicherung des Netzwerks zu zahlen. Wenn die Rate zu niedrig ist, werden die Validatoren mit einer durch das Protokoll begrenzten Rate aussteigen. Nach und nach wird dadurch die APR für alle erhöht, die bleiben und wieder neue oder wiederkehrende Staker anziehen.
+
## Was ist mit „Eth2“ passiert? {#eth2}
diff --git a/public/content/translations/de/roadmap/merge/issuance/index.md b/public/content/translations/de/roadmap/merge/issuance/index.md
index 35ab26c04ed..b5562115967 100644
--- a/public/content/translations/de/roadmap/merge/issuance/index.md
+++ b/public/content/translations/de/roadmap/merge/issuance/index.md
@@ -1,6 +1,6 @@
---
title: Wie hat The Merge das ETH-Angebot beeinflusst
-description: Aufschlüsselung darüber, wie The Merge das ETH-Angebot beeinflusst hat
+description: "Aufschlüsselung darüber, wie The Merge das ETH-Angebot beeinflusst hat"
lang: de
---
@@ -23,7 +23,6 @@ title="ETH-Emission kurz erklärt">
- Die genaue Staking-Emission schwankt je nach der Gesamtmenge der gestaketen ETH.
- **Seit The Merge verbleiben nur noch die ~1.700 ETH/Tag, wodurch die gesamte neue ETH-Emission um ~88 % sinkt.**
- Die Verbrennung: Diese schwankt je nach Netzwerknachfrage. _Wenn_ für einen bestimmten Tag ein durchschnittlicher Gaspreis von mindestens 16 Gwei beobachtet wird, kompensiert dies effektiv die ~1.700 ETH, die an die Validatoren ausgegeben werden, und bringt die Netto-ETH-Inflation für diesen Tag auf Null oder weniger.
-
## Vor dem Merge (historisch) {#pre-merge}
@@ -61,7 +60,10 @@ Gesamtes ETH-Angebot: **~120.520.000 ETH** (zum Zeitpunkt von The Merge im Septe
**~88,7 %** der Emission ging an Miner auf der Ausführungsebene (4,09 / 4,61 \* 100)
-**~11,3 %** wurden an Staker auf der Konsensebene emittiert (0,52 / 4,61 \* 100)
+**~11,3 %** wurden an Staker auf der Konsensebene emittiert (0,52 / 4,61 \* 100)
+
+
+
## Nach dem Merge (heute) {#post-merge}
@@ -92,7 +94,10 @@ Wenn mehr Validatoren aussteigen, wird die maximale Anzahl der ausscheidenden Va
Gesamte annualisierte Emissionsrate: **~0,52 %**
-Nettorückgang der jährlichen ETH-Emission: **~88,7 %** ((4,61 % - 0,52 %) / 4,61 % \* 100)
+Nettorückgang der jährlichen ETH-Emission: **~88,7 %** ((4,61 % - 0,52 %) / 4,61 % \* 100)
+
+
+
##
-Das Verbrennen von Gebühren wurde mit dem [London-Upgrade](/ethereum-forks/#london) im August 2021 eingeführt und ist seit The Merge unverändert.
+Das Verbrennen von Gebühren wurde mit dem [London-Upgrade](/ethereum-forks/#london) im August 2021 eingeführt und ist seit The Merge unverändert.
+
+
+
Zusätzlich zu den Gebühren, die durch das London Upgrade verbrannt werden, können Validatoren auch mit Strafen belegt werden, wenn sie offline sind, oder schlimmer noch, ihr Stake kann gekürzt werden, wenn sie gegen bestimmte Regeln verstoßen, die die Netzsicherheit gefährden. Diese Strafen führen zu einer Verringerung des ETH-Guthabens dieses Validators, das nicht auf ein anderes Konto überwiesen wird, sondern effektiv verbrannt/aus dem Verkehr gezogen wird.
diff --git a/public/content/translations/de/roadmap/pbs/index.md b/public/content/translations/de/roadmap/pbs/index.md
index a5f0b4ea8a5..5f56b2c803d 100644
--- a/public/content/translations/de/roadmap/pbs/index.md
+++ b/public/content/translations/de/roadmap/pbs/index.md
@@ -1,6 +1,6 @@
---
title: Proposer-Builder-Trennung
-description: Lerne wie und warum die Ethereum-Validatoren ihre Verantwortung für die Blockproduktion und Blockübertragung aufteilen.
+description: "Lerne wie und warum die Ethereum-Validatoren ihre Verantwortung für die Blockproduktion und Blockübertragung aufteilen."
lang: de
---
@@ -21,7 +21,6 @@ Ein Beispiel hierfür sind Einschlusslisten, die verwendet werden können, damit
Einflussreiche Organisationen können Validatoren dazu drängen, Transaktionen zu zensieren, die von oder zu bestimmten Adressen erfolgen. Die Validatoren geben diesem Druck nach, indem sie Adressen auf der schwarzen Liste in ihrem Transaktionspool erkennen und sie auf den von ihnen vorgeschlagenen Blöcken auslassen. Nach der Einführung von PBS wird dies nicht mehr möglich sein, da Block-Vorschlagende nicht mehr wissen werden, welche Transaktionen sie in ihren Blöcken übertragen. Für bestimmte Personen oder Anwendungen könnte es wichtig sein, die Zensurvorschriften einzuhalten, z. B. wenn sie in ihrer Region gesetzlich vorgeschrieben sind. In solchen Fällen erfolgt die Einhaltung auf Anwendungsebene, während das Protokoll weiterhin erlaubnis- und zensurfrei bleibt.
-
## PBS und MEV {#pbs-and-mev}
@@ -32,7 +31,8 @@ Das PBS löst dieses Problem, indem es die Wirtschaftlichkeit von MEV neu konfig
-Aufgrund der verbesserten Belohnungen durch ausgeklügelte MEV-Strategien könnten Einzelpersonen dazu angeregt werden, sich Pools anzuschließen, anstatt alleine zu staken. Die Trennung der Block-Erstellung vom Block-Vorschlagsverfahren führt dazu, dass die extrahierte MEV auf eine größere Anzahl von Validatoren verteilt wird, anstatt sich bei dem effektivsten MEV-Sucher zu zentralisieren. Gleichzeitig nimmt das Erlauben von spezialisierten Blockproduzenten die Last der Blockerstellung weg vom Einzelnen und verhindert das Stehlen von MEV einzelner für sich selber, während die Anzahl individueller, unabhängiger Validatoren, die Blöcke auf ehrliche weise überprüfen, maximiert wird. Das wichtige Konzept ist die "Beweiser-Verifizierer Asymetrie", welche die Idee beschreibt, dass zentralisierte Blockproduktion okay ist, solange es ein robustes und maximal dezentralisiertes Netzwerk von ehrlichen Validatoren gibt, die die Blöcke überprüfen. Dezentralisierung ist ein Mittel, kein Endziel - worauf es uns ankommt, sind ehrliche Blöcke.
+Aufgrund der verbesserten Belohnungen durch ausgeklügelte MEV-Strategien könnten Einzelpersonen dazu angeregt werden, sich Pools anzuschließen, anstatt alleine zu staken. Die Trennung der Block-Erstellung vom Block-Vorschlagsverfahren führt dazu, dass die extrahierte MEV auf eine größere Anzahl von Validatoren verteilt wird, anstatt sich bei dem effektivsten MEV-Sucher zu zentralisieren. Gleichzeitig nimmt das Erlauben von spezialisierten Blockproduzenten die Last der Blockerstellung weg vom Einzelnen und verhindert das Stehlen von MEV einzelner für sich selber, während die Anzahl individueller, unabhängiger Validatoren, die Blöcke auf ehrliche weise überprüfen, maximiert wird. Das wichtige Konzept ist die "Beweiser-Verifizierer Asymetrie", welche die Idee beschreibt, dass zentralisierte Blockproduktion okay ist, solange es ein robustes und maximal dezentralisiertes Netzwerk von ehrlichen Validatoren gibt, die die Blöcke überprüfen. Dezentralisierung ist ein Mittel, kein Endziel - worauf es uns ankommt, sind ehrliche Blöcke.
+
## PBS und Danksharding {#pbs-and-danksharding}
diff --git a/public/content/translations/de/roadmap/pectra/7702/index.md b/public/content/translations/de/roadmap/pectra/7702/index.md
index d673a6204f1..8ff65bd87dd 100644
--- a/public/content/translations/de/roadmap/pectra/7702/index.md
+++ b/public/content/translations/de/roadmap/pectra/7702/index.md
@@ -1,6 +1,6 @@
---
title: Pectra 7702-Richtlinien
-description: Erfahren Sie mehr über 7702 in der Pectra-Version
+description: "Erfahren Sie mehr über 7702 in der Pectra-Version"
lang: de
---
diff --git a/public/content/translations/de/roadmap/pectra/index.md b/public/content/translations/de/roadmap/pectra/index.md
index f0484d5ff48..f8401707961 100644
--- a/public/content/translations/de/roadmap/pectra/index.md
+++ b/public/content/translations/de/roadmap/pectra/index.md
@@ -1,6 +1,6 @@
---
title: Prag-Electra (Pectra)
-description: Erfahre mehr über das Pectra-Protokoll-Upgrade
+description: "Erfahre mehr über das Pectra-Protokoll-Upgrade"
lang: de
---
diff --git a/public/content/translations/de/roadmap/pectra/maxeb/index.md b/public/content/translations/de/roadmap/pectra/maxeb/index.md
index cb909971712..21b9253d02e 100644
--- a/public/content/translations/de/roadmap/pectra/maxeb/index.md
+++ b/public/content/translations/de/roadmap/pectra/maxeb/index.md
@@ -1,6 +1,6 @@
---
title: Pectra MaxEB
-description: Erfahren Sie mehr über MaxEB in der Pectra-Version
+description: "Erfahren Sie mehr über MaxEB in der Pectra-Version"
lang: de
---
diff --git a/public/content/translations/de/roadmap/scaling/index.md b/public/content/translations/de/roadmap/scaling/index.md
index 083067283dc..997847da60b 100644
--- a/public/content/translations/de/roadmap/scaling/index.md
+++ b/public/content/translations/de/roadmap/scaling/index.md
@@ -1,6 +1,6 @@
---
title: Ethereum zu skalieren
-description: Durch das Bündeln von Transaktionen off-chain verringern Rollups die Kosten für den Anwender. Die derzeitige Art und Weise, wie Rollups Daten verwenden, ist jedoch zu teuer und schränkt ein, wie günstig Transaktionen sein könnten. Proto-Danksharding behebt das.
+description: "Durch das Bündeln von Transaktionen off-chain verringern Rollups die Kosten für den Anwender. Die derzeitige Art und Weise, wie Rollups Daten verwenden, ist jedoch zu teuer und schränkt ein, wie günstig Transaktionen sein könnten. Proto-Danksharding behebt das."
lang: de
image: /images/roadmap/roadmap-transactions.png
alt: "Ethereum-Roadmap"
diff --git a/public/content/translations/de/roadmap/secret-leader-election/index.md b/public/content/translations/de/roadmap/secret-leader-election/index.md
index 2537e8e604b..907d7607163 100644
--- a/public/content/translations/de/roadmap/secret-leader-election/index.md
+++ b/public/content/translations/de/roadmap/secret-leader-election/index.md
@@ -1,6 +1,6 @@
---
-title: Geheime Führungswahl
-description: Erklärung wie geheime Führungswahlen helfen können, Validatoren von Angreifen zu schützen
+title: "Geheime Führungswahl"
+description: "Erklärung wie geheime Führungswahlen helfen können, Validatoren von Angreifen zu schützen"
lang: de
summaryPoints:
- Die IP-Adresse von Blockantragstellern (Proposern) kann im Vorne herein bekannt sein, was sie Angriffen aussetzt
diff --git a/public/content/translations/de/roadmap/security/index.md b/public/content/translations/de/roadmap/security/index.md
index ddd71c58df3..718d56ee887 100644
--- a/public/content/translations/de/roadmap/security/index.md
+++ b/public/content/translations/de/roadmap/security/index.md
@@ -1,6 +1,6 @@
---
title: Ein sichereres Ethereum Netzwerk
-description: Ethereum ist die sicherste und dezentralisierte Smart-Contract-Plattform, die es gibt. Es gibt jedoch immer noch Verbesserungen, die vorgenommen werden können, um Ethereum bis weit in die Zukunft hinein gegen jegliche Art von Angriffen zu wappnen.
+description: "Ethereum ist die sicherste und dezentralisierte Smart-Contract-Plattform, die es gibt. Es gibt jedoch immer noch Verbesserungen, die vorgenommen werden können, um Ethereum bis weit in die Zukunft hinein gegen jegliche Art von Angriffen zu wappnen."
lang: de
image: /images/roadmap/roadmap-security.png
alt: "Ethereum-Roadmap"
diff --git a/public/content/translations/de/roadmap/single-slot-finality/index.md b/public/content/translations/de/roadmap/single-slot-finality/index.md
index ce1bc16c003..833e15c5bad 100644
--- a/public/content/translations/de/roadmap/single-slot-finality/index.md
+++ b/public/content/translations/de/roadmap/single-slot-finality/index.md
@@ -1,6 +1,6 @@
---
-title: Einzelplatzfinalität (single slot finality)
-description: Erklärung von Einzelplatzfinalität (single slot finality)
+title: "Einzelplatzfinalität (single slot finality)"
+description: "Erklärung von Einzelplatzfinalität (single slot finality)"
lang: de
---
@@ -39,7 +39,8 @@ Der derzeitige Konsensmechanismus verbindet Attestierungen mehrerer Validatoren,
Dieser Prozess gibt für jeden Validatoren ausreichende Kapazität, in jeder Epoche abzustimmen, da 32 Plätze \* 64 Komitees \* 256 Validator pro Komitee 524 288 Validatoren pro Epoche ergeben. Zum Zeitpunkt der Erstellung dieses Artikels (Februar 2023) gibt es ~513 000 aktive Validatoren.
-In diesem Schema ist es für jeden Validatoren möglich für einen Block abzustimmen, indem er seine Attestierungen über die gesamte Epoche verteilen. Jedoch gibt es potentielle Wege diesen Mechanismus zu verbessern, sodass _jeder Validator die Chance hat in jedem Platz zu attestieren_.
+In diesem Schema ist es für jeden Validatoren möglich für einen Block abzustimmen, indem er seine Attestierungen über die gesamte Epoche verteilen. Jedoch gibt es potentielle Wege diesen Mechanismus zu verbessern, sodass _jeder Validator die Chance hat in jedem Platz zu attestieren_.
+
Seit der Ethereum Konsensmechanismus entwickelt wurde, hat sich das Unterschriften-Aggregationsschema (BLS) als deutlich skalierbarer als erwartet erwiesen, dabei wurde auch die Fähigkeit von Clients, die Unterschriften zu verarbeiten und unterschreiben, verbessert. Es stellt sich heraus, dass das Verarbeiten von Attestierungen in großer Anzahl von Validatoren in einem einzelnen Platz möglich ist. Zum Beispiel müssten Nodes, bei einer Million Validatoren, die zweimal pro Platz wählen und dem Verändern von der Zeit pro Slot (Platz) auf 16 Sekunden, Unterschriften mit mindestens 125 000 Aggregationen pro Sekunde funktionieren, um alle Attestierungen innerhalb des Platzes zu verarbeiten. In Wirklichkeit benötigt ein gewöhnlicher Computer ungefähr 500 Nanosekunden um eine Unterschrift zu verifizieren, das heißt, dass 125 000 Verifikationen in ~62,5 ms durchgeführt werden könnten. Das wäre weit unter der Ein-Sekunden-Grenze.
diff --git a/public/content/translations/de/roadmap/statelessness/index.md b/public/content/translations/de/roadmap/statelessness/index.md
index 8d179ad2404..72b96654c0c 100644
--- a/public/content/translations/de/roadmap/statelessness/index.md
+++ b/public/content/translations/de/roadmap/statelessness/index.md
@@ -1,6 +1,6 @@
---
title: Zustandslosigkeit, Zustandsverfall und Verfall des Vergangenen (history expiry)
-description: Erklärung vom Verfall des Vergangenen (history expiry) und der Zustandslosigkeit auf Ethereum
+description: "Erklärung vom Verfall des Vergangenen (history expiry) und der Zustandslosigkeit auf Ethereum"
lang: de
---
@@ -72,7 +72,8 @@ Damit dies geschehen kann, müssen [Verkle-Trees](/roadmap/verkle-trees/) bereit
Zustandslosigkeit stützt sich auf Blockerzeuger, welche eine Kopie der vollen Zustandsdaten pflegen, sodass sie Zeugen generieren können, welche genutzt werden um Blöcke zu verifizieren. Andere Nodes müssen die Zustandsdaten nicht abrufen, da alle benötigten Informationen für das Verifizieren eines Blocks im Zeugen vorhanden sind. Das erzeugt eine Situation, in der das Vorschlagen eines Blocks teuer, das Verifizieren jedoch günstig ist, was bedeutet, das weniger Operatoren einen blockvorschlagenden Node betreiben werden. Jedoch ist die Dezentralisation von Block Proposern nicht kritisch, solange möglichst viele Teilnehmende unabhängig voneinander verifizieren können, dass der vorgeschlagene Block valide ist.
-Lesen Sie mehr in Dankrads Notizen
+Lesen Sie mehr in Dankrads Notizen
+
Block Proposer nutzen die Zustandsdaten, um "Zeugen" zu erzeugen - die minimale Menge an Daten, die die Werte des Zustands beweisen, welche während einer Transaktion in einem Block geändert werden. Andere Validatoren halten nicht den Zustand, sie speichern nur die Wurzel des Zustands (state root) (einen Hash des gesamten Zustands). Sie erhalten einen Block und einen Zeugen und nutzen diese, um ihre Wurzel des Zustands zu aktualisieren. Das macht einen validierenden Node extrem leichtgewichtig.
diff --git a/public/content/translations/de/roadmap/user-experience/index.md b/public/content/translations/de/roadmap/user-experience/index.md
index 84901f49964..54bc14a5972 100644
--- a/public/content/translations/de/roadmap/user-experience/index.md
+++ b/public/content/translations/de/roadmap/user-experience/index.md
@@ -1,6 +1,6 @@
---
title: Verbesserung der Benutzererfahrung
-description: Für die meisten Menschen ist es immer noch zu kompliziert Ethereum zu benutzen. Um die Massenakzeptanz von Ethereum zu fördern, müssen die Eintrittsbarrieren drastisch gesenkt werden - die Nutzer müssen die Vorteile eines dezentralisierten, erlaubnisfreien und zensurresistenten Zugangs zu Ethereum nutzen können, der jedoch so reibungslos sein muss wie die Nutzung einer herkömmlichen Web2-App.
+description: "Für die meisten Menschen ist es immer noch zu kompliziert Ethereum zu benutzen. Um die Massenakzeptanz von Ethereum zu fördern, müssen die Eintrittsbarrieren drastisch gesenkt werden - die Nutzer müssen die Vorteile eines dezentralisierten, erlaubnisfreien und zensurresistenten Zugangs zu Ethereum nutzen können, der jedoch so reibungslos sein muss wie die Nutzung einer herkömmlichen Web2-App."
lang: de
image: /images/roadmap/roadmap-ux.png
alt: "Ethereum-Roadmap"
diff --git a/public/content/translations/de/roadmap/verkle-trees/index.md b/public/content/translations/de/roadmap/verkle-trees/index.md
index 8dc8eabc9a0..b529c4a6431 100644
--- a/public/content/translations/de/roadmap/verkle-trees/index.md
+++ b/public/content/translations/de/roadmap/verkle-trees/index.md
@@ -18,7 +18,6 @@ Verkle Bäume sind ein kritischer Schritt hin zu Zustandsfreien Ethereum Clients
Ethereum Clients nutzen momentan eine Datenstruktur, die als Patricia Merkle Trie bekannt ist, um ihre Zustandsdaten zu speichern. Informationen über einzelne Accounts sind als Blätter auf der Baumstruktur gespeichert und Paare von Blättern werden wiederholt gehashed, bis nur ein einzelner Hash bleibt. Der endgültige Hash ist bekannt als die "Wurzel". Um Blöcke zu überprüfen, führen Ethereum Clients alle Transaktionen in einem Block aus und aktualisieren ihren lokalen Zustandsbaum. Der Block wird als gültig angesehen, wenn die Wurzel des lokalen Baumes identisch zu der vom Block-Vorschlagenden ist, weil jeder Unterschied in der Berechnung des Block-Vorschlagenden und der überprüfenden Node einen komplett anderen Wurzelhash ergeben würde. Das Problem hierbei ist, dass die Überprüfung der Blockchain erfordert, dass jeder Client den gesamten Zustandsbaum des Kopf-Blocks und mehrere historische Blöcke (der Standard in Geth ist, die Zustandsdaten für 128 Blöcke hinter dem Kopf zu behalten) erfordert. Dies setzt voraus, dass Clients über große Mengen an Speicherplatz verfügen, was wiederum eine Barriere für günstige ressourcenschonende Hardware ist. Eine Lösung hierfür ist ein Update des Zutandsbaumes auf eine effizientere Struktur (Verkle Tree), die Daten effizient über kleine "Zeugen" teilen kann, anstatt den vollständigen Zustand von Ethereum zu übertragen. Den Datenzustand in Verkle Trees umzuschreiben, ist ein großer Schritt hin zu Zustandsfreien Clients.
-
## Was ist ein Zeuge und warum brauchen wir sie? {#what-is-a-witness}
@@ -34,7 +33,6 @@ In einem Polynombindungs-Schema haben die Zeugen überschaubare Größen, die le
Die Größe des Zeugen variiert abhängig von der Anzahl der Blätter, die er enthält. Davon ausgehend, dass ein Zeuge 1000 Blätter abdeckt, wäre ein Zeuge für einen Merkle Baum ungefähr 3,5 MB (von 7 Ebenen im Trie ausgehend). Ein Zeuge für die selben Daten in einem Verkle Baum (von 4 Ebenen zum Baum ausgehend) würde ungefähr 150 kB an Daten ergeben -**etwa 23x kleiner**. Diese Reduktion der Zeugengröße wird Zeugen in zustandsfreien Clients ermöglichen, akzeptabel klein zu sein. Polynomzeugen sind 0,128–1 kB groß; abhängig davon, welches spezifische Polynom-Commitment verwendet wird.
-
## Wie sieht die Struktur von Verkle Bäumen aus? Was ist die Struktur eines Verkle-Trees? {#what-is-the-structure-of-a-verkle-tree}
diff --git a/public/content/translations/de/security/index.md b/public/content/translations/de/security/index.md
index 609c15b8a28..ae63e484602 100644
--- a/public/content/translations/de/security/index.md
+++ b/public/content/translations/de/security/index.md
@@ -1,5 +1,5 @@
---
-title: Ethereum – Sicherheits- und Betrugsvorbeugung
+title: "Ethereum – Sicherheits- und Betrugsvorbeugung"
description: Ethereum sicher nutzen
lang: de
---
diff --git a/public/content/translations/de/smart-contracts/index.md b/public/content/translations/de/smart-contracts/index.md
index 2d6b14bad01..d4e94949277 100644
--- a/public/content/translations/de/smart-contracts/index.md
+++ b/public/content/translations/de/smart-contracts/index.md
@@ -1,7 +1,7 @@
---
title: Smart Contracts
metaTitle: "Smart Contracts: Was sie sind und ihre Vorteile"
-description: Eine nicht-technische Einführung in Smart Contracts
+description: "Eine nicht-technische Einführung in Smart Contracts"
lang: de
---
diff --git a/public/content/translations/de/social-networks/index.md b/public/content/translations/de/social-networks/index.md
index 219d95dfd67..fc9b2ffa397 100644
--- a/public/content/translations/de/social-networks/index.md
+++ b/public/content/translations/de/social-networks/index.md
@@ -1,13 +1,13 @@
---
title: Dezentralisierte soziale Netzwerke
-description: Eine Übersicht über dezentralisierte soziale Netzwerke in der Ethereum-Blockchain
+description: "Eine Übersicht über dezentralisierte soziale Netzwerke in der Ethereum-Blockchain"
lang: de
template: use-cases
emoji: ":mega:"
sidebarDepth: 2
image: /images/ethereum-learn.png
-summaryPoint1: Blockchain-basierte Plattformen für soziale Interaktionen und Content-Erstellung und -Verteilung.
-summaryPoint2: Dezentralisierte Social-Media-Netzwerke schützen die Privatsphäre der Benutzer und erhöhen Datensicherheit.
+summaryPoint1: "Blockchain-basierte Plattformen für soziale Interaktionen und Content-Erstellung und -Verteilung."
+summaryPoint2: "Dezentralisierte Social-Media-Netzwerke schützen die Privatsphäre der Benutzer und erhöhen Datensicherheit."
summaryPoint3: Token und NFTs erschaffen neue Wege zur Monetarisierung von Inhalten.
---
diff --git a/public/content/translations/de/staking/dvt/index.md b/public/content/translations/de/staking/dvt/index.md
index 1362f42de9d..9c848501488 100644
--- a/public/content/translations/de/staking/dvt/index.md
+++ b/public/content/translations/de/staking/dvt/index.md
@@ -1,6 +1,6 @@
---
title: Verteilte Validierungstechnologie (VVT)
-description: Verteilte Validierungstechnologie (VVT) ermöglicht den verteilten Betrieb eines Ethereum-Validators durch mehrere Parteien.
+description: "Verteilte Validierungstechnologie (VVT) ermöglicht den verteilten Betrieb eines Ethereum-Validators durch mehrere Parteien."
lang: de
---
diff --git a/public/content/translations/de/staking/pools/index.md b/public/content/translations/de/staking/pools/index.md
index d8961d00818..cdf8d71f63e 100644
--- a/public/content/translations/de/staking/pools/index.md
+++ b/public/content/translations/de/staking/pools/index.md
@@ -1,6 +1,6 @@
---
title: Gepooltes Staking
-description: Erfahren Sie mehr über Staking-Pools
+description: "Erfahren Sie mehr über Staking-Pools"
lang: de
template: staking
emoji: ":money_with_wings:"
@@ -13,8 +13,7 @@ summaryPoints:
- Halten Sie Staking-Token in Ihrer eigenen Wallet
---
-## Was sind Staking-Pools? Was sind Staking-Pools? {#what-are-staking-pools}
-
+## Was sind Staking-Pools? {#what-are-staking-pools}
Staking-Pools sind ein kollaborativer Ansatz, um es vielen Menschen mit kleineren ETH-Beträgen zu ermöglichen, die 32 ETH zu erhalten, die zur Aktivierung eines Satzes von Validator-Schlüsseln erforderlich sind. Die Pooling-Funktionalität wird innerhalb des Protokolls nicht nativ unterstützt, daher wurden separate Lösungen entwickelt, um diesen Bedarf zu decken.
Einige Pools arbeiten mit Smart Contracts, bei denen Gelder in einen Vertrag eingezahlt werden können, der Ihren Einsatz (Stake) vertrauenswürdig verwaltet und verfolgt und Ihnen einen Token ausstellt, der diesen Wert widerspiegelt. Andere Pools beinhalten möglicherweise keine Smart-Contracts und werden stattdessen off-chain vermittelt.
@@ -68,13 +67,16 @@ Sofort! Die Aktualisierung des Netzwerks auf Shanghai/Capella erfolgte im April
Alternativ dazu ermöglichen Pools, die einen ERC-20 Staking-Token verwenden, den Handel mit diesem Token auf dem freien Markt, so dass Sie Ihre Staking-Position verkaufen können, ohne tatsächlich ETH aus dem Staking-Vertrag zu entnehmen.
-Mehr zu Staking-Auszahlungen \n
+Mehr zu Staking-Auszahlungen \n
+
-\nEs gibt viele Ähnlichkeiten zwischen diesen gepoolten Staking-Optionen und zentralisierten Börsen, wie z. B. die Möglichkeit, kleine ETH-Beträge zu staken und sie zu bündeln, um Validatoren zu aktivieren.
+
+\nEs gibt viele Ähnlichkeiten zwischen diesen gepoolten Staking-Optionen und zentralisierten Börsen, wie z. B. die Möglichkeit, kleine ETH-Beträge zu staken und sie zu bündeln, um Validatoren zu aktivieren.
Im Gegensatz zu zentralisierten Börsen nutzen viele andere gepoolte Staking-Optionen Smart Contracts und/oder Staking-Token, bei denen es sich in der Regel um ERC-20-Token handelt, die Sie in Ihrer eigenen Wallet halten und wie jeden anderen Token kaufen oder verkaufen können. Dies bietet eine gewisse Souveränität und Sicherheit, da Sie die Kontrolle über Ihre Token besitzen. Allerdings haben Sie immer noch keine direkte Kontrolle über den Validator-Client, der in Ihrem Namen im Hintergrund Attestierungen ausgibt.
-Einige Pooling-Optionen sind im Hinblick auf die Nodes, die sie unterstützen, stärker dezentralisiert als andere. Um die Gesundheit und Dezentralisierung des Netzwerks zu fördern, werden Staker immer dazu ermutigt, einen Pooling-Service auszuwählen, der eine genehmigungsfreie, dezentrale Gruppe von Node-Betreibern ermöglicht.
+Einige Pooling-Optionen sind im Hinblick auf die Nodes, die sie unterstützen, stärker dezentralisiert als andere. Um die Gesundheit und Dezentralisierung des Netzwerks zu fördern, werden Staker immer dazu ermutigt, einen Pooling-Service auszuwählen, der eine genehmigungsfreie, dezentrale Gruppe von Node-Betreibern ermöglicht.
+
## Weiterführende Lektüre {#further-reading}
diff --git a/public/content/translations/de/staking/saas/index.md b/public/content/translations/de/staking/saas/index.md
index 826943a8f9e..c141b6873c9 100644
--- a/public/content/translations/de/staking/saas/index.md
+++ b/public/content/translations/de/staking/saas/index.md
@@ -1,6 +1,6 @@
---
title: Staking als Service
-description: Erfahren Sie mehr über Staking als Service
+description: "Erfahren Sie mehr über Staking als Service"
lang: de
template: staking
emoji: ":money_with_wings:"
@@ -70,20 +70,24 @@ Das Aktualisieren der Auszahlungsberechtigungen ist ein erforderlicher Schritt,
Stellen Sie sicher, dass Sie diese Seed-Phrase sicher aufbewahren, sonst können Sie Ihre Auszahlungsschlüssel nicht generieren, wenn es soweit ist.
-\*Staker, die bei der Ersteinzahlung eine Auszahlungsadresse angegeben haben, müssen dies nicht festlegen. Bitte wenden Sie sich an Ihren SaaS-Anbieter, um Unterstützung bei der Vorbereitung Ihres Validators zu erhalten.
+\*Staker, die bei der Ersteinzahlung eine Auszahlungsadresse angegeben haben, müssen dies nicht festlegen. Bitte wenden Sie sich an Ihren SaaS-Anbieter, um Unterstützung bei der Vorbereitung Ihres Validators zu erhalten.
+
-\nStaker müssen (sofern nicht bereits bei der Ersteinzahlung geschehen) eine Auszahlungsadresse bereitstellen. Belohnungen werden daraufhin automatisch alle paar Tage in regelmäßigen Abständen ausgezahlt.
+
+\nStaker müssen (sofern nicht bereits bei der Ersteinzahlung geschehen) eine Auszahlungsadresse bereitstellen. Belohnungen werden daraufhin automatisch alle paar Tage in regelmäßigen Abständen ausgezahlt.
Validatoren haben auch die Möglichkeit, ihre Tätigkeit als Validator zu beenden. Das ermöglicht die Auszahlung ihres restlichen ETH-Guthabens. Konten, die eine Auszahlungsadresse angegeben und den Austrittsprozess abgeschlossen haben, erhalten ihr gesamtes Guthaben bei der nächsten Validatorendurchsicht auf die angegebene Auszahlungsadresse.
-Mehr zu Staking-Auszahlungen \n
+Mehr zu Staking-Auszahlungen \n
+
Durch die Nutzung eines SaaS-Anbieters vertrauen Sie den Betrieb Ihrer Nodes jemand anderem an. Dies birgt das Risiko einer schlechten Node-Leistung, auf die Sie keinen Einfluss haben. Falls Ihr Validator geslashed wird, wird Ihr Validator-Guthaben bestraft und zwangsweise aus dem Validator-Pool entfernt.
Nach Abschluss des Slashing-/Austrittsprozesses werden diese Mittel an die dem Validator zugewiesene Auszahlungsadresse übertragen. Dies erfordert die Angabe einer Auszahlungsadresse zur Aktivierung. Diese Adresse kann bei der anfänglichen Einzahlung angegeben worden sein. Falls nicht, müssen die Auszahlungsschlüssel des Validators verwendet werden, um eine Nachricht zu unterschreiben, die eine Auszahlungsadresse angibt. Wenn keine Auszahlungsadresse angegeben wurde, bleibt das Guthaben bis zur Angabe gesperrt.
-Für weitere Informationen zu Garantien oder Versicherungsoptionen sowie zur Anleitung zur Bereitstellung einer Abhebungsadresse wenden Sie sich bitte an Ihren individuellen SaaS-Anbieter. Wenn Sie lieber die volle Kontrolle über Ihr Validator Setup haben möchten, [erfahren Sie mehr darüber, wie Sie Ihr ETH alleine einsetzen](/staking/solo/).
+Für weitere Informationen zu Garantien oder Versicherungsoptionen sowie zur Anleitung zur Bereitstellung einer Abhebungsadresse wenden Sie sich bitte an Ihren individuellen SaaS-Anbieter. Wenn Sie lieber die volle Kontrolle über Ihr Validator Setup haben möchten, [erfahren Sie mehr darüber, wie Sie Ihr ETH alleine einsetzen](/staking/solo/).
+
## Weiterführende Lektüre {#further-reading}
diff --git a/public/content/translations/de/staking/solo/index.md b/public/content/translations/de/staking/solo/index.md
index d0f31e3ad77..0770029cc61 100644
--- a/public/content/translations/de/staking/solo/index.md
+++ b/public/content/translations/de/staking/solo/index.md
@@ -1,6 +1,6 @@
---
title: Setzen Sie Ihre ETH zu Hause ein
-description: Eine Übersicht über die ersten Schritte beim Home-Staking Ihres ETH
+description: "Eine Übersicht über die ersten Schritte beim Home-Staking Ihres ETH"
lang: de
template: staking
emoji: ":money_with_wings:"
@@ -43,17 +43,20 @@ So sehr wir uns auch wünschen, dass Home-Staking für jeden zugänglich und ris
Wenn Sie Ihren eigenen Knoten betreiben, sollten Sie sich etwas Zeit nehmen, um zu lernen, wie Sie die von Ihnen gewählte Software verwenden. Dazu gehört das Lesen der relevanten Dokumentation und die Kenntnis der Kommunikationskanäle dieser Entwicklerteams.
-Je mehr Sie über die von Ihnen verwendete Software und die Funktionsweise von Proof-of-Stake verstehen, desto weniger riskant ist es als Staker und desto einfacher wird es, als Knotenbetreiber alle auftretenden Probleme zu beheben.
+Je mehr Sie über die von Ihnen verwendete Software und die Funktionsweise von Proof-of-Stake verstehen, desto weniger riskant ist es als Staker und desto einfacher wird es, als Knotenbetreiber alle auftretenden Probleme zu beheben.
+
Das Einrichten von Knoten erfordert einen gewissen Grad an Vertrautheit im Umgang mit Computern, obwohl neue Tools dies im Laufe der Zeit einfacher machen. Das Verständnis der Kommandozeilenschnittstelle ist hilfreich, aber nicht mehr zwingend erforderlich.
-Es erfordert auch eine sehr einfache Hardware-Einrichtung und ein gewisses Verständnis der empfohlenen Mindestspezifikationen.
+Es erfordert auch eine sehr einfache Hardware-Einrichtung und ein gewisses Verständnis der empfohlenen Mindestspezifikationen.
+
So wie private Schlüssel Ihre Ethereum-Adresse sichern, müssen Sie auch speziell für Ihren Validator Schlüssel generieren. Sie müssen verstehen, wie Sie Seed-Phrases oder private Schlüssel sicher aufbewahren.{' '}
-[Ethereum-Sicherheit und Betrugsprävention](/security/)
+[Ethereum-Sicherheit und Betrugsprävention](/security/)
+
Hardware fällt gelegentlich aus, Netzwerkverbindungen schlagen fehl und Client-Software muss gelegentlich aktualisiert werden. Die Wartung von Knoten ist unvermeidlich und erfordert gelegentlich Ihre Aufmerksamkeit. Sie sollten sicherstellen, dass Sie über alle erwarteten Netzwerk-Upgrades oder andere wichtige Client-Upgrades informiert bleiben.
@@ -66,7 +69,9 @@ Ihre Belohnungen sind proportional zu der Zeit, in der Ihr Validator online ist
Im Gegensatz zu Inaktivitätsstrafen für das Offline-Sein ist Slashing eine wesentlich schwerwiegendere Strafe, die böswilligen Verstößen vorbehalten ist. Indem Sie einen Minderheits-Client betreiben und Ihre Schlüssel nur auf einem einzigen Gerät geladen haben, wird Ihr Risiko eines Slashings minimiert. Dennoch müssen sich alle Staker der Risiken des Slashings bewusst sein.
- Mehr über Slashing und den Lebenszyklus von Validatoren
+ Mehr über Slashing und den Lebenszyklus von Validatoren
+
+
Ein Validator ist eine virtuelle Entität, die auf Ethereum lebt und am Konsens des Ethereum-Protokolls teilnimmt. Validatoren werden durch ein Guthaben, einen öffentlichen Schlüssel und andere Eigenschaften dargestellt. Ein Validator-Client ist die Software, die im Namen des Validators handelt, indem sie dessen privaten Schlüssel hält und verwendet. Ein einzelner Validator-Client kann viele Schlüsselpaare enthalten und somit viele Validatoren steuern.
-
@@ -137,14 +141,16 @@ Dieser Puffer verhindert auch, dass ein effektiver Saldo sinkt, bis er 0,25 ETH
Jedes Schlüsselpaar, das einem Validator zugeordnet ist, benötigt mindestens 32 ETH, um aktiviert zu werden. Jedes darüber hinausgehende Guthaben kann jederzeit durch eine mit dieser Adresse signierte Transaktion an die zugehörige Auszahlungsadresse ausgezahlt werden. Alle Gelder, die das maximale effektive Guthaben übersteigen, werden in regelmäßigen Abständen automatisch ausgezahlt.
-Wenn Ihnen Home-Staking zu anspruchsvoll erscheint, ziehen Sie die Nutzung eines [Staking-as-a-Service](/staking/saas/)-Anbieters in Betracht, oder sehen Sie sich die [Staking-Pools](/staking/pools/) an, wenn Sie mit weniger als 32 ETH arbeiten.
+Wenn Ihnen Home-Staking zu anspruchsvoll erscheint, ziehen Sie die Nutzung eines [Staking-as-a-Service](/staking/saas/)-Anbieters in Betracht, oder sehen Sie sich die [Staking-Pools](/staking/pools/) an, wenn Sie mit weniger als 32 ETH arbeiten.
+
Offline zu gehen, während das Netzwerk ordnungsgemäß finalisiert, führt NICHT zu Slashing. Geringe Inaktivitätsstrafen fallen an, wenn Ihr Validator für eine bestimmte Epoche (jeweils 6,4 Minuten lang) nicht für Bestätigungen zur Verfügung steht, was sich jedoch stark von Slashing unterscheidet. Diese Strafen sind etwas geringer als die Belohnung, die Sie erhalten hätten, wenn der Validator für Bestätigungen zur Verfügung gestanden hätte. Die Verluste können durch eine ungefähr gleich lange Zeit, in der Sie wieder online sind, ausgeglichen werden.
Beachten Sie, dass die Strafen für Inaktivität proportional zur Anzahl der gleichzeitig offline geschalteten Validatoren sind. In Fällen, in denen ein großer Teil des Netzwerks gleichzeitig offline ist, sind die Strafen für jeden dieser Validatoren höher als bei der Nichtverfügbarkeit eines einzelnen Validators.
-In extremen Fällen, wenn das Netzwerk die Finalisierung einstellt, weil mehr als ein Drittel der Validatoren offline ist, erleiden diese Benutzer einen sogenannten quadratischen Inaktivitätsverlust, der einen exponentiellen Abfluss von ETH von Offline-Validator-Konten darstellt. Dies ermöglicht es dem Netzwerk, sich schließlich selbst zu heilen, indem die ETH inaktiver Validatoren verbrannt werden, bis ihr Guthaben 16 ETH erreicht. An diesem Punkt werden sie automatisch aus dem Validator-Pool entfernt. Die verbleibenden Online-Validatoren werden schließlich wieder mehr als 2/3 des Netzwerks ausmachen und so die erforderliche Supermajorität erreichen, um die Kette erneut zu finalisieren.
+In extremen Fällen, wenn das Netzwerk die Finalisierung einstellt, weil mehr als ein Drittel der Validatoren offline ist, erleiden diese Benutzer einen sogenannten quadratischen Inaktivitätsverlust, der einen exponentiellen Abfluss von ETH von Offline-Validator-Konten darstellt. Dies ermöglicht es dem Netzwerk, sich schließlich selbst zu heilen, indem die ETH inaktiver Validatoren verbrannt werden, bis ihr Guthaben 16 ETH erreicht. An diesem Punkt werden sie automatisch aus dem Validator-Pool entfernt. Die verbleibenden Online-Validatoren werden schließlich wieder mehr als 2/3 des Netzwerks ausmachen und so die erforderliche Supermajorität erreichen, um die Kette erneut zu finalisieren.
+
Kurz gesagt, dies kann nie vollständig garantiert werden, aber wenn Sie in gutem Glauben handeln, einen Minderheits-Client betreiben und Ihre Signaturschlüssel jeweils nur auf einem Computer aufbewahren, ist das Risiko eines Slashings nahezu null.
@@ -166,14 +172,16 @@ Einzelne Clients können sich in Bezug auf Leistung und Benutzeroberfläche geri
Da alle Produktions-Clients die gleiche Grundfunktionalität bieten, ist es sehr wichtig, dass Sie einen Minderheits-Client wählen, d. h. einen Client, der derzeit NICHT von einer Mehrheit der Validatoren im Netzwerk verwendet wird. Dies mag kontraintuitiv klingen, aber der Betrieb eines Majoritäts- oder Supermajoritäts-Clients setzt Sie einem erhöhten Slashing-Risiko aus, falls in diesem Client ein Fehler auftritt. Der Betrieb eines Minderheits-Clients begrenzt diese Risiken drastisch.
-Erfahren Sie mehr darüber, warum Client-Diversität entscheidend ist
+Erfahren Sie mehr darüber, warum Client-Diversität entscheidend ist
+
Obwohl ein virtueller privater Server (VPS) als Ersatz für die Hardware zu Hause verwendet werden kann, sind der physische Zugang und der Standort Ihres Validator-Clients sehr wohl von Bedeutung. Zentralisierte Cloud-Lösungen wie Amazon Web Services oder Digital Ocean bieten den Komfort, keine Hardware beschaffen und betreiben zu müssen, gehen aber auf Kosten der Zentralisierung des Netzwerks.
Je mehr Validator-Clients auf einer einzigen zentralisierten Cloud-Speicherlösung laufen, desto gefährlicher wird es für diese Benutzer. Jedes Ereignis, das diese Anbieter offline schaltet, sei es durch einen Angriff, regulatorische Anforderungen oder einfach nur Strom-/Internetausfälle, führt dazu, dass jeder Validator-Client, der auf diesen Server angewiesen ist, gleichzeitig offline geht.
-Offline-Strafen sind proportional zur Anzahl der anderen, die gleichzeitig offline sind. Die Verwendung eines VPS erhöht das Risiko, dass Offline-Strafen schwerwiegender ausfallen, und erhöht Ihr Risiko von quadratischem Verlust oder Slashing, falls der Ausfall groß genug ist. Um Ihr eigenes Risiko und das Risiko für das Netzwerk zu minimieren, wird den Benutzern dringend empfohlen, ihre eigene Hardware zu beschaffen und zu betreiben.
+Offline-Strafen sind proportional zur Anzahl der anderen, die gleichzeitig offline sind. Die Verwendung eines VPS erhöht das Risiko, dass Offline-Strafen schwerwiegender ausfallen, und erhöht Ihr Risiko von quadratischem Verlust oder Slashing, falls der Ausfall groß genug ist. Um Ihr eigenes Risiko und das Risiko für das Netzwerk zu minimieren, wird den Benutzern dringend empfohlen, ihre eigene Hardware zu beschaffen und zu betreiben.
+
@@ -185,7 +193,8 @@ Sobald die Auszahlungsdaten festgelegt sind, werden Prämienzahlungen (über den
Um Ihr gesamtes Guthaben zu entsperren und zu erhalten, müssen Sie auch den Prozess des Verlassens Ihres Validators abschließen.
-Mehr zu Staking-Auszahlungen \n
+Mehr zu Staking-Auszahlungen \n
+
## Weiterführende Lektüre {#further-reading}
diff --git a/public/content/translations/de/staking/withdrawals/index.md b/public/content/translations/de/staking/withdrawals/index.md
index 60812282b6b..f6c6f67b40f 100644
--- a/public/content/translations/de/staking/withdrawals/index.md
+++ b/public/content/translations/de/staking/withdrawals/index.md
@@ -1,6 +1,6 @@
---
title: Staking-Auszahlungen
-description: Seite mit einer Zusammenfassung zu Staking-Push-Auszahlungen, wie sie funktionieren und was Staker tun müssen, um ihre Belohnungen zu erhalten
+description: "Seite mit einer Zusammenfassung zu Staking-Push-Auszahlungen, wie sie funktionieren und was Staker tun müssen, um ihre Belohnungen zu erhalten"
lang: de
template: staking
image: /images/staking/leslie-withdrawal.png
@@ -42,7 +42,8 @@ Die Angabe einer Auszahlungsadresse ist ein erforderlicher Schritt für jedes Va
-Jedem Validatorkonto kann nur ein einziges Mal eine Auszahlungsadresse zugewiesen werden. Sobald eine Adresse ausgewählt und an die Konsensebene übermittelt wurde, kann dies nicht mehr rückgängig gemacht oder geändert werden. Überprüfen Sie die Besitzverhältnisse und die Richtigkeit der angegebenen Adresse, bevor Sie sie einreichen.
+
+Jedem Validatorkonto kann nur ein einziges Mal eine Auszahlungsadresse zugewiesen werden. Sobald eine Adresse ausgewählt und an die Konsensebene übermittelt wurde, kann dies nicht mehr rückgängig gemacht oder geändert werden. Überprüfen Sie die Besitzverhältnisse und die Richtigkeit der angegebenen Adresse, bevor Sie sie einreichen.
@@ -137,7 +138,8 @@ title="Kann ich eine Auszahlungsadresse, nachdem ich sie einmal angegeben habe,
eventCategory="FAQ"
eventAction="Once I have provided a withdrawal address, can I change it to an alternative withdrawal address?"
eventName="read more">
-Nein, der Prozess zur Bereitstellung von Auszahlungsberechtigungen ist ein einmaliger Prozess und kann nach der Einreichung nicht mehr geändert werden.
+Nein, der Prozess zur Bereitstellung von Auszahlungsberechtigungen ist ein einmaliger Prozess und kann nach der Einreichung nicht mehr geändert werden.
+
+Als Alternative zur Änderung der Auszahlungsadresse für einen bestimmten Validator können sich Benutzer dafür entscheiden, einen intelligenten Vertrag als ihre Auszahlungsadresse festzulegen, der Schlüsselrotationen handhaben könnte, wie zum Beispiel ein Safe. Benutzer, die ihre Mittel auf ihr eigenes extern kontrolliertes Konto (EOA) setzen, können einen vollständigen Ausstieg durchführen, um all ihre gestakten Mittel abzuheben, und dann mit neuen Anmeldeinformationen erneut staken.
+
Bist du in einem [Staking-Pool](/staking/pools/) oder hältst Staking-Token? Dann frage bei deinem Anbieter nach den Details zur Auszahlung, da die Handhabung je nach Dienst variiert.
Im Allgemeinen sollten Benutzer in der Lage sein, ihr zugrundeliegendes gestaktes ETH zurückzufordern oder zu ändern, welchen Staking-Anbieter sie nutzen. Wenn ein bestimmter Pool zu groß wird, können Mittel abgezogen, eingelöst und mit einem kleineren Anbieter neu gestaked werden. Alternativ kannst du, wenn du genügend ETH besitzt, auch [von zu Hause aus staken](/staking/solo/).
-
-Ja, solange Ihr Validator eine Auszahlungsadresse angegeben hat. Diese muss einmal bereitgestellt werden, um Auszahlungen zu ermöglichen, danach werden Belohnungszahlungen automatisch alle paar Tage mit jedem Durchlauf des Validators ausgelöst.
+Ja, solange Ihr Validator eine Auszahlungsadresse angegeben hat. Diese muss einmal bereitgestellt werden, um Auszahlungen zu ermöglichen, danach werden Belohnungszahlungen automatisch alle paar Tage mit jedem Durchlauf des Validators ausgelöst.
+
Nein, wenn Ihr Validator noch aktiv im Netzwerk ist, erfolgt keine automatische Auszahlung. Dies erfordert das manuelle Einleiten eines freiwilligen Ausstiegs.
Sobald ein Validator den Ausstiegsprozess abgeschlossen hat und vorausgesetzt, das Konto verfügt über Auszahlungsberechtigungen, wird das verbleibende Guthaben dann während des nächsten Validator-Durchlaufs abgehoben.
-
Auszahlungen sind darauf ausgelegt, automatisch angestoßen zu werden, wobei alle ETH übertragen werden, die nicht aktiv zum Stake beitragen. Dies beinhaltet vollständige Salden für Konten, die den Ausstiegsprozess abgeschlossen haben.
-Es ist nicht möglich, manuell spezifische Mengen an ETH zur Auszahlung anzufordern.
+Es ist nicht möglich, manuell spezifische Mengen an ETH zur Auszahlung anzufordern.
+
Validator-Betreibern wird empfohlen, die Seite Startplattform für Staking-Auszahlungen zu besuchen. Dort können sie mehr Details darüber erfahren, wie Sie Ihren Validator auf Auszahlungen vorbereiten, sowie Informationen zum Zeitpunkt der Ereignisse und zur Funktionsweise von Auszahlungen erhalten.
Um Ihr Setup zuerst auf einem Testnet auszuprobieren, besuchen Sie das Hoodi Testnet Staking Launchpad, um zu beginnen.
-
-Nein. Sobald ein Validator ausgetreten ist und sein gesamtes Guthaben abgehoben wurde, werden alle zusätzlichen Einzahlungen auf diesen Validator automatisch während des nächsten Validator-Durchlaufs an die Auszahlungsadresse übertragen. Um ETH erneut zu staken, muss ein neuer Validator aktiviert werden.
+Nein. Sobald ein Validator ausgetreten ist und sein gesamtes Guthaben abgehoben wurde, werden alle zusätzlichen Einzahlungen auf diesen Validator automatisch während des nächsten Validator-Durchlaufs an die Auszahlungsadresse übertragen. Um ETH erneut zu staken, muss ein neuer Validator aktiviert werden.
+
## Weiterführende Lektüre {#further-reading}
diff --git a/public/content/translations/de/web3/index.md b/public/content/translations/de/web3/index.md
index 36818219521..dbac1da16ba 100644
--- a/public/content/translations/de/web3/index.md
+++ b/public/content/translations/de/web3/index.md
@@ -1,6 +1,6 @@
---
title: Was ist Web3 und warum ist es wichtig?
-description: Eine Einführung in Web3 – die nächste Entwicklung des Internets – und warum es wichtig ist.
+description: "Eine Einführung in Web3 – die nächste Entwicklung des Internets – und warum es wichtig ist."
lang: de
---
@@ -69,7 +69,8 @@ Web3 ermöglicht direktes Eigentum durch [nicht-fungible Token (NFTs)](/glossary
- Mehr über NFTs erfahren
+ Mehr über NFTs erfahren
+
Mehr zu NFTs
@@ -97,7 +98,8 @@ Allerdings definieren Menschen viele Web3-Communities als DAOs. Diese Gemeinscha
- Erfahren Sie mehr über DAOs
+ Erfahren Sie mehr über DAOs
+
Mehr über DAOs
diff --git a/public/content/translations/de/what-are-apps/index.md b/public/content/translations/de/what-are-apps/index.md
index 4239e12954c..7799ff1e5a5 100644
--- a/public/content/translations/de/what-are-apps/index.md
+++ b/public/content/translations/de/what-are-apps/index.md
@@ -1,14 +1,14 @@
---
title: Ethereum-Anwendungen
metaTitle: Ethereum Anwendungen | Dezentrale Anwendungen auf Ethereum
-description: Ethereum-Apps sind kostenlos, global nutzbar und basieren auf öffentlichen Blockchains statt auf privaten Unternehmensservern. Das heißt, Sie können in allen Projekten das gleiche Konto nutzen, und gleichzeitig Ihre Privatsphäre wahren.
+description: "Ethereum-Apps sind kostenlos, global nutzbar und basieren auf öffentlichen Blockchains statt auf privaten Unternehmensservern. Das heißt, Sie können in allen Projekten das gleiche Konto nutzen, und gleichzeitig Ihre Privatsphäre wahren."
lang: de
template: use-cases
emoji: ":handshake:"
sidebarDepth: 2
showDropdown: false
image: /images/doge-computer.png
-summary: Ethereum-Apps sind kostenlos, global nutzbar und basieren auf öffentlichen Blockchains statt auf privaten Unternehmensservern. Das heißt, Sie können in allen Projekten das gleiche Konto nutzen, und gleichzeitig Ihre Privatsphäre wahren.
+summary: "Ethereum-Apps sind kostenlos, global nutzbar und basieren auf öffentlichen Blockchains statt auf privaten Unternehmensservern. Das heißt, Sie können in allen Projekten das gleiche Konto nutzen, und gleichzeitig Ihre Privatsphäre wahren."
---
## Apps mit Superpower {#apps-with-superpowers}
@@ -51,7 +51,6 @@ Apps laufen über Smart Contracts - Programmcodes, die auf der Ethereum-Blockcha
-
## Ethereum-Apps sind wie Legosteine {#ethereum-apps-are-like-legos}
diff --git a/public/content/translations/de/whitepaper/index.md b/public/content/translations/de/whitepaper/index.md
index 52f9524c268..55187467578 100644
--- a/public/content/translations/de/whitepaper/index.md
+++ b/public/content/translations/de/whitepaper/index.md
@@ -1,6 +1,6 @@
---
title: Ethereum Whitepaper
-description: Eine einleitende Arbeit zu Ethereum, veröffentlicht im Jahr 2013 vor seiner Einführung.
+description: "Eine einleitende Arbeit zu Ethereum, veröffentlicht im Jahr 2013 vor seiner Einführung."
lang: de
sidebarDepth: 2
hideEditButton: true
diff --git a/public/content/translations/de/wrapped-eth/index.md b/public/content/translations/de/wrapped-eth/index.md
index 1c3f5433aaa..43f942a8cf0 100644
--- a/public/content/translations/de/wrapped-eth/index.md
+++ b/public/content/translations/de/wrapped-eth/index.md
@@ -1,6 +1,6 @@
---
-title: Was ist „Wrapped Ether“ (WETH)
-description: Eine Einführung in Wrapped Ether (WETH) – ein ERC20-kompatibler Wrapper für Ether (ETH).
+title: "Was ist „Wrapped Ether“ (WETH)"
+description: "Eine Einführung in Wrapped Ether (WETH) – ein ERC20-kompatibler Wrapper für Ether (ETH)."
lang: de
---
@@ -8,7 +8,8 @@ lang: de
Ether (ETH) ist die Hauptwährung von Ethereum. Es wird für verschiedene Zwecke verwendet, wie Staking, als Währung und zur Bezahlung von Gasgebühren für Berechnungen. **WETH ist im Grunde eine erweiterte Form von ETH mit gewisser zusätzlicher Funktionalität, die von vielen Anwendungen und [ERC-20-Token](/glossary/#erc-20)** benötigt wird, welche andere Arten von digitalen Assets auf Ethereum darstellen. Um mit diesen Token arbeiten zu können, muss ETH dieselben Regeln befolgen, auch als ERC-20-Standard bekannt.
@@ -40,19 +41,16 @@ Sie können WETH in ETH umwandeln, indem Sie den WETH-Smart Contract verwenden.
Sie zahlen Gasgebühren, um ETH mit dem WETH-Vertrag zu verpacken oder zu entpacken.
-
WETH gilt allgemein als sicher, da es auf einem einfachen, bewährten Smart Contract basiert. Der WETH-Vertrag wurde zudem formal verifiziert, was den höchsten Sicherheitsstandard für Smart Contracts auf Ethereum darstellt.
-
Neben der [kanonischen Implementierung von WETH](https://etherscan.io/token/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2), die auf dieser Seite beschrieben ist, gibt es auch andere Varianten. Diese können benutzerdefinierte Token sein, die von App-Entwicklern erstellt wurden, oder Versionen, die auf anderen Blockchains herausgegeben wurden, und sich unterschiedlich verhalten oder unterschiedliche Sicherheitseigenschaften haben. **Überprüfen Sie immer die Token-Informationen, um zu erfahren, mit welcher WETH-Implementierung Sie interagieren.**
-
@@ -60,7 +58,6 @@ Neben der [kanonischen Implementierung von WETH](https://etherscan.io/token/0xc0
- [Ethereum-Mainnet](https://etherscan.io/token/0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2)
- [Arbitrum](https://arbiscan.io/token/0x82af49447d8a07e3bd95bd0d56f35241523fbab1)
- [Optimism](https://optimistic.etherscan.io/token/0x4200000000000000000000000000000000000006)
-
## Weiterführende Lektüre {#further-reading}
diff --git a/public/content/translations/de/zero-knowledge-proofs/index.md b/public/content/translations/de/zero-knowledge-proofs/index.md
index e96689a66d4..b1b799bf0f4 100644
--- a/public/content/translations/de/zero-knowledge-proofs/index.md
+++ b/public/content/translations/de/zero-knowledge-proofs/index.md
@@ -1,6 +1,6 @@
---
title: Null-Wissen-Beweise
-description: Eine nicht-technische Einführung in Zero-Knowledge-Beweise für Anfänger.
+description: "Eine nicht-technische Einführung in Zero-Knowledge-Beweise für Anfänger."
lang: de
---
@@ -59,8 +59,8 @@ Zero-Knowledge-Beweise sind besonders nützlich im Kontext der [dezentralen Iden
Erfahre mehr über Bhutan NDI in der Fallstudie zur dezentralen Identität.
-
-
+
+
### Proof of Humanity {#proof-of-humanity}
From 5801c74817ac5b3632c62b04908ddd5bd26b99be Mon Sep 17 00:00:00 2001
From: Joshua <62268199+minimalsm@users.noreply.github.com>
Date: Fri, 13 Feb 2026 12:39:21 +0000
Subject: [PATCH 4/9] fix(i18n): run sanitizer on de translations
---
.../translations/de/ai-agents/index.md | 1 +
.../translations/de/community/grants/index.md | 3 +--
.../translations/de/community/online/index.md | 27 ++++++++++++++++---
.../de/community/research/index.md | 2 +-
.../translatathon/details/index.md | 2 +-
.../translatathon/index.md | 2 +-
public/content/translations/de/dao/index.md | 4 +--
.../de/decentralized-identity/index.md | 2 ++
public/content/translations/de/defi/index.md | 3 +--
.../pos/block-proposal/index.md | 1 +
.../docs/intro-to-ethereum/index.md | 1 +
.../docs/nodes-and-clients/index.md | 1 +
.../developers/docs/scaling/plasma/index.md | 2 +-
.../developers/docs/scaling/validium/index.md | 1 +
.../developers/docs/smart-contracts/index.md | 1 +
.../docs/smart-contracts/languages/index.md | 18 +++++++++++++
.../docs/smart-contracts/upgrading/index.md | 1 +
.../de/developers/docs/wrapped-eth/index.md | 8 ++----
.../index.md | 2 +-
.../tutorials/all-you-can-cache/index.md | 4 +--
.../developers/tutorials/app-plasma/index.md | 2 +-
.../index.md | 2 +-
.../index.md | 4 +--
.../erc-721-vyper-annotated-code/index.md | 3 ++-
.../tutorials/erc20-annotated-code/index.md | 2 +-
.../erc20-with-safety-rails/index.md | 2 +-
.../tutorials/ethereum-for-web2-auth/index.md | 2 +-
.../index.md | 2 +-
.../index.md | 6 ++---
.../index.md | 2 +-
.../index.md | 4 +--
.../index.md | 8 +++---
.../index.md | 4 +--
.../tutorials/ipfs-decentralized-ui/index.md | 2 +-
.../index.md | 2 +-
.../index.md | 2 +-
.../reverse-engineering-a-contract/index.md | 2 +-
.../tutorials/scam-token-tricks/index.md | 4 +--
.../tutorials/secret-state/index.md | 2 +-
.../secure-development-workflow/index.md | 6 ++---
.../index.md | 2 +-
.../tutorials/server-components/index.md | 2 +-
.../developers/tutorials/short-abi/index.md | 2 +-
.../index.md | 6 ++---
.../tutorials/stealth-addr/index.md | 2 +-
.../index.md | 2 +-
.../token-integration-checklist/index.md | 6 ++---
.../uniswap-v2-annotated-code/index.md | 5 ++--
.../tutorials/using-websockets/index.md | 2 +-
.../index.md | 2 +-
.../index.md | 2 +-
.../translations/de/ethereum-forks/index.md | 2 +-
.../index.md | 3 +--
.../how-to-revoke-token-access/index.md | 3 +--
.../de/guides/how-to-swap-tokens/index.md | 3 +--
.../de/guides/how-to-use-a-bridge/index.md | 3 +--
.../de/guides/how-to-use-a-wallet/index.md | 3 +--
public/content/translations/de/nft/index.md | 3 +--
.../content/translations/de/payments/index.md | 8 +++---
.../de/prediction-markets/index.md | 2 ++
.../de/roadmap/beacon-chain/index.md | 1 +
.../translations/de/roadmap/dencun/index.md | 8 +++---
.../translations/de/roadmap/fusaka/index.md | 2 +-
.../de/roadmap/merge/issuance/index.md | 6 +++++
.../translations/de/roadmap/pectra/index.md | 2 +-
.../translations/de/staking/pools/index.md | 1 +
.../translations/de/staking/solo/index.md | 1 +
public/content/translations/de/web3/index.md | 6 ++---
.../translations/de/wrapped-eth/index.md | 3 +--
69 files changed, 142 insertions(+), 100 deletions(-)
diff --git a/public/content/translations/de/ai-agents/index.md b/public/content/translations/de/ai-agents/index.md
index c35726ce1ad..b61f2b94e89 100644
--- a/public/content/translations/de/ai-agents/index.md
+++ b/public/content/translations/de/ai-agents/index.md
@@ -111,6 +111,7 @@ Während Lunas Social-Media-Kampagne #LunaMuralChallenge auf X wählte Luna die
Gut zu wissen
KI-Agenten und zugehörige Tools befinden sich noch in der frühen Entwicklung und sind sehr experimentell – verwenden Sie sie mit Vorsicht.
+
## Kontrollieren Sie Ihre Wallet mit Chat-Befehlen {#control-your-wallet-using-chat-commands}
diff --git a/public/content/translations/de/community/grants/index.md b/public/content/translations/de/community/grants/index.md
index e573a0d9680..e5ad3218f65 100644
--- a/public/content/translations/de/community/grants/index.md
+++ b/public/content/translations/de/community/grants/index.md
@@ -12,8 +12,7 @@ Diese Liste wird von unserer Community verwaltet. Wenn Informationen fehlen oder
## Breites Ethereum-Ökosystem {#broad-ethereum-ecosystem}
diff --git a/public/content/translations/de/community/online/index.md b/public/content/translations/de/community/online/index.md
index 21e64d64ce5..c01cf0ca522 100644
--- a/public/content/translations/de/community/online/index.md
+++ b/public/content/translations/de/community/online/index.md
@@ -32,17 +32,36 @@ Um die Integrität und den Wert der gelisteten Communities zu wahren, verfolgt e
Wenn Sie der Meinung sind, dass eine Community auf Grundlage dieser Richtlinien hinzugefügt oder entfernt werden sollte, [eröffnen Sie bitte ein Issue in unserem GitHub-Repository](https://github.com/ethereum/ethereum-org-website/issues).
-## Foren {#foren}
+## Foren {#forums}
-r/ethereum - alles rund um Ethereum r/ethfinance - die finanzielle Seite von Ethereum, einschließlich DeFi r/ethdev - konzentriert auf die Ethereum-Entwicklung r/ethtrader - Trends & Marktanalyse r/ethstaker - willkommen für alle, die am Staking auf Ethereum interessiert sind Fellowship of Ethereum Magicians - eine Community, die sich auf technische Standards in Ethereum konzentriert Ethereum Stackexchange - Diskussion und Hilfe für Ethereum-Entwickler Ethereum Research - das einflussreichste Forum für kryptökonomische Forschung
+r/ethereum - alles rund um Ethereum
+r/ethfinance - die finanzielle Seite von Ethereum, einschließlich DeFi
+r/ethdev - konzentriert auf die Ethereum-Entwicklung
+r/ethtrader - Trends & Marktanalyse
+r/ethstaker - willkommen für alle, die am Staking auf Ethereum interessiert sind
+Fellowship of Ethereum Magicians - eine Community, die sich auf technische Standards in Ethereum konzentriert
+Ethereum Stackexchange - Diskussion und Hilfe für Ethereum-Entwickler
+Ethereum Research - das einflussreichste Forum für kryptökonomische Forschung
## Chaträume {#chat-rooms}
-Ethereum Cat Herders - eine Community, die Projektmanagement-Unterstützung für die Ethereum-Entwicklung anbietet Ethereum Hackers - von ETHGlobal betriebener Discord-Chat: eine Online-Community für Ethereum-Hacker aus der ganzen Welt CryptoDevs - auf die Ethereum-Entwicklung ausgerichtete Discord-Community EthStaker Discord - von der Community geführte Anleitung, Bildung, Unterstützung und Ressourcen für bestehende und potenzielle Staker Ethereum.org-Website-Team - schauen Sie vorbei und chatten Sie mit dem Team und Leuten aus der Community über die Webentwicklung und das Design von ethereum.org Matos Discord - Web3-Creator-Community, in der sich Builder, Branchengrößen und Ethereum-Enthusiasten treffen. Wir sind begeistert von Web3-Entwicklung, Design und Kultur. Bauen Sie mit uns. Solidity Gitter - Chat für die Solidity-Entwicklung (Gitter) Solidity Matrix - Chat für die Solidity-Entwicklung (Matrix) Ethereum Stack Exchange - Frage-und-Antwort-Forum Peera Community Forum - dezentralisiertes Frage-und-Antwort-Forum
+Ethereum Cat Herders - eine Community, die Projektmanagement-Unterstützung für die Ethereum-Entwicklung anbietet
+Ethereum Hackers - von ETHGlobal betriebener Discord-Chat: eine Online-Community für Ethereum-Hacker aus der ganzen Welt
+CryptoDevs - auf die Ethereum-Entwicklung ausgerichtete Discord-Community
+EthStaker Discord - von der Community geführte Anleitung, Bildung, Unterstützung und Ressourcen für bestehende und potenzielle Staker
+Ethereum.org-Website-Team - schauen Sie vorbei und chatten Sie mit dem Team und Leuten aus der Community über die Webentwicklung und das Design von ethereum.org
+Matos Discord - Web3-Creator-Community, in der sich Builder, Branchengrößen und Ethereum-Enthusiasten treffen. Wir sind begeistert von Web3-Entwicklung, Design und Kultur. Bauen Sie mit uns.
+Solidity Gitter - Chat für die Solidity-Entwicklung (Gitter)
+Solidity Matrix - Chat für die Solidity-Entwicklung (Matrix)
+Ethereum Stack Exchange - Frage-und-Antwort-Forum
+Peera Community Forum - dezentralisiertes Frage-und-Antwort-Forum
## YouTube und X (ehemals Twitter) {#youtube-and-twitter}
-Ethereum Foundation - Bleiben Sie auf dem Laufenden über die neuesten Entwicklungen der Ethereum Foundation @ethereum - Haupt-Ethereum-Account für die Community @ethereumfndn - Offizieller Account der Ethereum Foundation @ethdotorg - Das Portal zu Ethereum, für unsere wachsende globale Community entwickelt
+Ethereum Foundation - Bleiben Sie auf dem Laufenden über die neuesten Entwicklungen der Ethereum Foundation
+@ethereum - Haupt-Ethereum-Account für die Community
+@ethereumfndn - Offizieller Account der Ethereum Foundation
+@ethdotorg - Das Portal zu Ethereum, für unsere wachsende globale Community entwickelt
diff --git a/public/content/translations/de/dao/index.md b/public/content/translations/de/dao/index.md
index 976af4f1437..decc0d22742 100644
--- a/public/content/translations/de/dao/index.md
+++ b/public/content/translations/de/dao/index.md
@@ -70,9 +70,7 @@ Um DAOs zu verwalten, sind vorher zahlreiche Überlegungen notwendig – etwa wi
Die Delegation ist die DAO-Variante repräsentativer Demokratie. Tokenbesitzer delegieren Stimmen an Benutzer, die sich selbst nominieren und sich verpflichten, auf dem aktuellen Stand zu bleiben und das Protokoll zu verwalten.
-#### Ein berühmtes Beispiel {#governance-example}
-
-[ENS](https://claim.ens.domains/delegate-ranking) – ENS-Inhaber können ihre Stimmen an engagierte Community-Mitglieder delegieren, damit diese sie vertreten.
+#### Ein berühmtes Beispiel {#governance-example}[ENS](https://claim.ens.domains/delegate-ranking) – ENS-Inhaber können ihre Stimmen an engagierte Community-Mitglieder delegieren, damit diese sie vertreten.
### Automatische Transaktions-Governance {#governance-example}
diff --git a/public/content/translations/de/decentralized-identity/index.md b/public/content/translations/de/decentralized-identity/index.md
index c66aaa25964..c8de03d1581 100644
--- a/public/content/translations/de/decentralized-identity/index.md
+++ b/public/content/translations/de/decentralized-identity/index.md
@@ -108,6 +108,7 @@ Eine Attestierung ist ein Anspruch einer Entität gegenüber einer anderen Entit
Attestierungen unterscheiden sich von Identifikatoren. Eine Attestierung _enthält_ Identifikatoren, um auf eine bestimmte Identität zu verweisen, und macht eine Aussage über ein Attribut, das mit dieser Identität zusammenhängt. Ihr Führerschein hat also Identifikatoren (Name, Geburtsdatum, Adresse), ist aber zugleich auch die Attestierung Ihres gesetzlichen Fahrrechts.
### Was sind dezentralisierte Identifikatoren? {#what-are-decentralized-identifiers}
+
Klassische Identifikatoren, wie beispielsweise Ihr bürgerlicher Name oder Ihre E-Mail-Adresse, sind von Dritten abhängig - von Regierungen und E-Mail-Anbietern. Dezentralisierte Identifikatoren (DIDs) sind anders - sie werden nicht von einer zentralen Stelle ausgegeben, verwaltet oder kontrolliert.
Dezentralisierte Identifikatoren werden von Individuen ausgegeben, gehalten und kontrolliert. Ein [Ethereum-Konto](/glossary/#account) ist ein Beispiel für einen dezentralisierten Identifikator. Sie haben die Möglichkeit, so viele Konten zu erstellen, wie Sie möchten, ohne dass Sie eine Erlaubnis von Dritten benötigen und ohne dass diese Konten in einem zentralen Register gespeichert werden müssen.
@@ -115,6 +116,7 @@ Dezentralisierte Identifikatoren werden von Individuen ausgegeben, gehalten und
Dezentralisierte Identifikatoren werden auf Distributed Ledgers ([Blockchains](/glossary/#blockchain)) oder in [Peer-to-Peer-Netzwerken](/glossary/#peer-to-peer-network) gespeichert. Dies macht DIDs [weltweit einzigartig, mit hoher Verfügbarkeit auflösbar und kryptografisch verifizierbar](https://w3c-ccg.github.io/did-primer/). Ein dezentralisierter Identifikator kann mit verschiedenen Entitäten verknüpft werden, darunter Personen, Organisationen oder staatliche Einrichtungen.
## Was ermöglicht dezentralisierte Identifikatoren? {#what-makes-decentralized-identifiers-possible}
+
### 1. Public-Key-Kryptografie {#public-key-cryptography}
Public-Key-Kryptografie ist eine Informationssicherheitsmaßnahme, die einen [öffentlichen Schlüssel](/glossary/#public-key) und einen [privaten Schlüssel](/glossary/#private-key) für eine Entität generiert. Public-Key-[Kryptografie](/glossary/#cryptography) wird in Blockchain-Netzwerken verwendet, um Benutzeridentitäten zu authentifizieren und den Besitz von digitalen Vermögenswerten nachzuweisen.
diff --git a/public/content/translations/de/defi/index.md b/public/content/translations/de/defi/index.md
index 5756747de70..6c1586e8d37 100644
--- a/public/content/translations/de/defi/index.md
+++ b/public/content/translations/de/defi/index.md
@@ -67,8 +67,7 @@ Das klingt seltsam ... „Warum sollte ich mein Geld programmieren wollen?“ Da
- Machen Sie sich mit unseren Vorschlägen für DeFi-Anwendungen vertraut und testen sie, wenn Sie neu bei Ethereum sind.
-
+ Machen Sie sich mit unseren Vorschlägen für DeFi-Anwendungen vertraut und testen sie, wenn Sie neu bei Ethereum sind.
DeFi-Apps entdecken
diff --git a/public/content/translations/de/developers/docs/consensus-mechanisms/pos/block-proposal/index.md b/public/content/translations/de/developers/docs/consensus-mechanisms/pos/block-proposal/index.md
index dd5e61e6053..10b3ae1f287 100644
--- a/public/content/translations/de/developers/docs/consensus-mechanisms/pos/block-proposal/index.md
+++ b/public/content/translations/de/developers/docs/consensus-mechanisms/pos/block-proposal/index.md
@@ -11,6 +11,7 @@ Blöcke sind die grundlegenden Einheiten der Blockchain. Blöcke sind diskrete I
Block-Proposals sind Teil des Proof-of-Stake-Protokolls. Um diese Seite besser zu verstehen, empfehlen wir dir, die Artikel über [Proof-of-Stake](/developers/docs/consensus-mechanisms/pos/) und [Blockarchitektur](/developers/docs/blocks/) zu lesen.
## Wer produziert Blöcke? {#who-produces-blocks}
+
Konten von Validatoren schlagen Blöcke vor. Die Konten von Validatoren werden von Node-Operatoren verwaltet, die Validatorensoftware als Teil ihrer Ausführungs- und Konsens-Clients betreiben und mindestens 32 ETH in den Einzahlungsvertrag transferiert haben. Allerdings ist jeder Validator nur gelegentlich für das Vorschlagen eines Blocks zuständig. Ethereum misst die Zeit in Slots und Epochen. Jeder Slot ist zwölf Sekunden lang und 32 Slots (6,4 Minuten) ergeben eine Epoche. Jeder Slot bietet eine Möglichkeit, Ethereum einen neuen Block hinzuzufügen.
### Zufällige Auswahl {#random-selection}
diff --git a/public/content/translations/de/developers/docs/intro-to-ethereum/index.md b/public/content/translations/de/developers/docs/intro-to-ethereum/index.md
index ff4d3f77c59..082c190e097 100644
--- a/public/content/translations/de/developers/docs/intro-to-ethereum/index.md
+++ b/public/content/translations/de/developers/docs/intro-to-ethereum/index.md
@@ -43,6 +43,7 @@ Die Höhe der gezahlten ETH entspricht den für die Berechnung benötigten Resso
ETH wird auch verwendet, um dem Netzwerk auf drei Arten kryptoökonomische Sicherheit zu geben: 1) Es wird als Mittel zur Belohnung von Validierern verwendet, die Blöcke vorschlagen oder unehrliches Verhalten anderer Validierer aufdecken; 2) Es wird von Validierern als Sicherheit gegen unehrliches Verhalten eingesetzt – wenn Validierer versuchen, sich falsch zu verhalten, kann das die Zerstörung ihrer ETH zur Folge haben; 3) Es wird verwendet, um "Stimmen" für neu vorgeschlagene Blöcke abzuwägen, was in die Fork-Auswahl des Konsensmechanismus einfließt.
## Was sind Smart Contracts? {#what-are-smart-contracts}
+
In der Praxis schreiben die Teilnehmenden nicht jedes Mal einen neuen Code, wenn sie eine Berechnung auf der EVM anfordern wollen. Vielmehr laden Anwendungsentwickler Programme (wiederverwendbare Codeschnipsel) in den EVM-Speicher hoch, und die Nutzer stellen Anfragen, um diese Codeschnipsel mit unterschiedlichen Parametern auszuführen. Wir nennen die Programme, die in das Netzwerk hochgeladen und von diesem ausgeführt werden, "Smart Contracts".
Ganz grundsätzlich können Sie sich einen Smart Contract wie eine Art Verkaufsautomat vorstellen: ein Skript, das, wenn es mit bestimmten Parametern aufgerufen wird, bestimmte Aktionen oder Berechnungen durchführt, wenn bestimmte Bedingungen erfüllt sind. Zum Beispiel könnte ein einfacher Verkäufer-Smart-Contract das Eigentum an einem digitalen Vermögenswert schaffen und zuweisen, wenn der Aufrufer ("caller") ETH an einen bestimmten Empfänger sendet.
diff --git a/public/content/translations/de/developers/docs/nodes-and-clients/index.md b/public/content/translations/de/developers/docs/nodes-and-clients/index.md
index 7187ec44729..0e1b31e02bd 100644
--- a/public/content/translations/de/developers/docs/nodes-and-clients/index.md
+++ b/public/content/translations/de/developers/docs/nodes-and-clients/index.md
@@ -85,6 +85,7 @@ Es gibt auch potenzielle Wege, um Light-Client-Daten über das [Gossip-Netzwerk]
Ethereum unterstützt noch keine große Population von leichten Nodes, jedoch ist die Unterstützung von leichten Nodes ein Bereich, der sich in naher Zukunft voraussichtlich schnell entwickeln wird. Insbesondere Clients wie [Nimbus](https://nimbus.team/), [Helios](https://github.com/a16z/helios) und [LodeStar](https://lodestar.chainsafe.io/) konzentrieren sich derzeit stark auf Light Nodes.
## Warum sollte ich einen Ethereum-Node betreiben? {#why-should-i-run-an-ethereum-node}
+
Der Betrieb eines eigenen Knotens ermöglicht es Ihnen, Ethereum auf private, autarke und vertrauenswürdige Weise zu nutzen und gleichzeitig das Netz zu unterstützen, da es so robuster und dezentraler wird.
### Ihre Vorteile {#benefits-to-you}
diff --git a/public/content/translations/de/developers/docs/scaling/plasma/index.md b/public/content/translations/de/developers/docs/scaling/plasma/index.md
index 7990cb7ffb8..328c77873e6 100644
--- a/public/content/translations/de/developers/docs/scaling/plasma/index.md
+++ b/public/content/translations/de/developers/docs/scaling/plasma/index.md
@@ -120,7 +120,7 @@ Obwohl Plasma einst als nützliche Skalierungslösung für Ethereum galt, wurde
### Effizienz {#efficiency}
-[Zero-Knowledge Rollups](/developers/docs/scaling/zk-rollups/) erzeugen kryptografische Beweise für die Gültigkeit jedes Transaktionsstapels, der off-chain verarbeitet wird. Dies verhindert, dass Benutzer (und Betreiber) ungültige Zustandsübergänge vorantreiben, was die Notwendigkeit von Challengeperioden und Exit-Games beseitigt. Damit müssen Benutzer ihre Guthaben nicht mehr regelmäßig über die Chain überwachen, um sie zu schützen.
+[Zero-Knowledge Rollups](/developers/docs/scaling/zk-rollups) erzeugen kryptografische Beweise für die Gültigkeit jedes Transaktionsstapels, der off-chain verarbeitet wird. Dies verhindert, dass Benutzer (und Betreiber) ungültige Zustandsübergänge vorantreiben, was die Notwendigkeit von Challengeperioden und Exit-Games beseitigt. Damit müssen Benutzer ihre Guthaben nicht mehr regelmäßig über die Chain überwachen, um sie zu schützen.
### Unterstützung für Smart Contracts {#support-for-smart-contracts}
diff --git a/public/content/translations/de/developers/docs/scaling/validium/index.md b/public/content/translations/de/developers/docs/scaling/validium/index.md
index eaa4347f30c..4aead5d522a 100644
--- a/public/content/translations/de/developers/docs/scaling/validium/index.md
+++ b/public/content/translations/de/developers/docs/scaling/validium/index.md
@@ -24,6 +24,7 @@ Allerdings können die Gelder der Validium-Nutzer eingefroren und Auszahlungen e
Dies ist der Hauptunterschied zwischen Validiums und ZK-Rollups – ihre Positionen im Datenverfügbarkeitsspektrum. Beide Lösungen gehen unterschiedlich mit der Datenspeicherung um, was Auswirkungen auf Sicherheit und Vertrauenswürdigkeit hat.
## Wie interagieren Validiums mit Ethereum? {#how-do-validiums-interact-with-ethereum}
+
Validiums sind Skalierungsprotokolle, die auf der bestehenden Ethereum-Blockchain aufgebaut sind. Obwohl die Transaktionen Off-Chain ausgeführt werden, wird eine Validium-Chain von mehreren Smart Contracts verwaltet, die im Mainnet eingesetzt sind, darunter:
1. **Verifier-Vertrag**: Der Verifier-Vertrag überprüft die Gültigkeit der vom Validium-Operator eingereichten Nachweise bei der Durchführung von Statusaktualisierungen. Das umfasst Gültigkeitsnachweise, die die Korrektheit der Offchain-Transaktionen belegen, sowie Datenverfügbarkeitsnachweise, die bestätigen, dass die Offchain-Transaktionsdaten vorhanden sind.
diff --git a/public/content/translations/de/developers/docs/smart-contracts/index.md b/public/content/translations/de/developers/docs/smart-contracts/index.md
index 64e1af8b3e9..c88869f1b8c 100644
--- a/public/content/translations/de/developers/docs/smart-contracts/index.md
+++ b/public/content/translations/de/developers/docs/smart-contracts/index.md
@@ -5,6 +5,7 @@ lang: de
---
## Was ist ein Smart Contract? {#what-is-a-smart-contract}
+
Ein "Smart Contract" oder intelligenter Vertrag ist einfach ein Programm, das auf der Ethereum-Blockchain läuft. Es ist eine Sammlung von Anweisungen (seinen Funktionen) und Daten (seinem Zustand), die sich an einer bestimmten Adresse in der Ethereum-Blockchain befindet.
Smart Contracts sind eine Art [Ethereum-Konto](/developers/docs/accounts/). Das bedeutet, dass sie über ein Guthaben verfügen und Ziel von Transaktionen werden können. Allerdings werden sie nicht von einem Benutzer gesteuert, sondern im Netzwerk bereitgestellt und wie programmiert ausgeführt. Benutzerkonten können dann mit einem Smart Contract interagieren, indem sie Transaktionen übermitteln, die eine im Smart Contract definierte Funktion ausführt. Smart Contracts können, wie auch herkömmliche Verträge, Regeln definieren und diese mittels Programmierung automatisch durchsetzen. Standardmäßig können Smart Contracts nicht gelöscht werden und Interaktionen mit ihnen sind irreversibel.
diff --git a/public/content/translations/de/developers/docs/smart-contracts/languages/index.md b/public/content/translations/de/developers/docs/smart-contracts/languages/index.md
index ea2f2498dde..a8d929f9fee 100644
--- a/public/content/translations/de/developers/docs/smart-contracts/languages/index.md
+++ b/public/content/translations/de/developers/docs/smart-contracts/languages/index.md
@@ -123,24 +123,32 @@ Für weitere Informationen [lesen Sie die Begründung für Vyper](https://vyper.
# Offene Auktion
# Auktionsparameter
+
# Der Begünstigte erhält Geld vom Höchstbietenden
+
beneficiary: public(address)
auctionStart: public(uint256)
auctionEnd: public(uint256)
# Aktueller Stand der Auktion
+
highestBidder: public(address)
highestBid: public(uint256)
# Wird am Ende auf „true“ gesetzt, verbietet jede Änderung
+
ended: public(bool)
# Nachverfolgung der zurückgezahlten Gebote, damit wir dem Auszahlungsmuster folgen können
+
pendingReturns: public(HashMap[address, uint256])
# Erstellt eine einfache Auktion mit `_bidding_time`
+
# Sekunden Bietzeit im Namen der
+
# Begünstigten-Adresse `_beneficiary`.
+
@external
def __init__(_beneficiary: address, _bidding_time: uint256):
self.beneficiary = _beneficiary
@@ -148,9 +156,13 @@ def __init__(_beneficiary: address, _bidding_time: uint256):
self.auctionEnd = self.auctionStart + _bidding_time
# Mit dem Wert, der zusammen mit dieser Transaktion
+
# gesendet wird, auf die Auktion bieten.
+
# Der Wert wird nur dann zurückerstattet,
+
# wenn die Auktion nicht gewonnen wird.
+
@external
@payable
def bid():
@@ -165,9 +177,13 @@ def bid():
self.highestBid = msg.value
# Ein zuvor erstattetes Gebot abheben. Das Auszahlungsmuster wird
+
# hier verwendet, um ein Sicherheitsproblem zu vermeiden. Wenn Rückerstattungen direkt
+
# als Teil von bid() gesendet würden, könnte ein bösartiger Bietvertrag
+
# diese Rückerstattungen blockieren und somit das Eingehen neuer, höherer Gebote verhindern.
+
@external
def withdraw():
pending_amount: uint256 = self.pendingReturns[msg.sender]
@@ -175,7 +191,9 @@ def withdraw():
send(msg.sender, pending_amount)
# Die Auktion beenden und das höchste Gebot an
+
# den Begünstigten senden.
+
@external
def endAuction():
# Es ist eine gute Richtlinie, Funktionen, die mit anderen Verträgen interagieren
diff --git a/public/content/translations/de/developers/docs/smart-contracts/upgrading/index.md b/public/content/translations/de/developers/docs/smart-contracts/upgrading/index.md
index 95653458f11..2d43ed1a166 100644
--- a/public/content/translations/de/developers/docs/smart-contracts/upgrading/index.md
+++ b/public/content/translations/de/developers/docs/smart-contracts/upgrading/index.md
@@ -15,6 +15,7 @@ Die zunehmende Forschung zur Verbesserung von Smart Contracts hat jedoch zur Ein
Sie sollten ein gutes Verständnis von [Smart Contracts](/developers/docs/smart-contracts/), der [Anatomie von Smart Contracts](/developers/docs/smart-contracts/anatomy/) und der [Ethereum Virtual Machine (EVM)](/developers/docs/evm/) haben. In diesem Leitfaden wird außerdem davon ausgegangen, dass die Leser über Kenntnisse in der Programmierung von Smart Contracts verfügen.
## Was ist ein Smart-Contract-Upgrade? {#what-is-a-smart-contract-upgrade}
+
Bei einem Smart-Contract-Upgrade wird die Geschäftslogik eines Smart Contracts geändert, wobei der Zustand des Vertrags erhalten bleibt. Es ist wichtig, klarzustellen, dass Aktualisierbarkeit und Veränderbarkeit nicht dasselbe sind, insbesondere im Zusammenhang mit Smart Contracts.
Sie können ein Programm, das auf einer Adresse im Ethereum-Netzwerk veröffentlicht wird, trotzdem nicht ändern. Aber Sie können den Code ändern, der ausgeführt wird, wenn Benutzer mit einem Smart Contract interagieren.
diff --git a/public/content/translations/de/developers/docs/wrapped-eth/index.md b/public/content/translations/de/developers/docs/wrapped-eth/index.md
index 2b6099003a0..90a0439dc4e 100644
--- a/public/content/translations/de/developers/docs/wrapped-eth/index.md
+++ b/public/content/translations/de/developers/docs/wrapped-eth/index.md
@@ -1,6 +1,6 @@
---
-title: Was ist „Wrapped Ether“ (WETH)
-description: Eine Einführung in Wrapped Ether (WETH) – ein ERC20-kompatibler Wrapper für Ether (ETH).
+title: "Was ist „Wrapped Ether“ (WETH)"
+description: "Eine Einführung in Wrapped Ether (WETH) – ein ERC20-kompatibler Wrapper für Ether (ETH)."
lang: de
---
@@ -35,19 +35,16 @@ Sie können WETH in ETH umwandeln, indem Sie den WETH-Smart Contract verwenden.
Sie zahlen Gasgebühren, um ETH mit dem WETH-Vertrag zu verpacken oder zu entpacken.
-
WETH gilt allgemein als sicher, da es auf einem einfachen, bewährten Smart Contract basiert. Der WETH-Vertrag wurde zudem formal verifiziert, was den höchsten Sicherheitsstandard für Smart Contracts auf Ethereum darstellt.
-
Neben der [kanonischen Implementierung von WETH](https://etherscan.io/token/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2), die auf dieser Seite beschrieben ist, gibt es auch andere Varianten. Diese können benutzerdefinierte Token sein, die von App-Entwicklern erstellt wurden, oder Versionen, die auf anderen Blockchains herausgegeben wurden, und sich unterschiedlich verhalten oder unterschiedliche Sicherheitseigenschaften haben. **Überprüfen Sie immer die Token-Informationen, um zu erfahren, mit welcher WETH-Implementierung Sie interagieren.**
-
@@ -55,7 +52,6 @@ Neben der [kanonischen Implementierung von WETH](https://etherscan.io/token/0xc0
- [Ethereum-Mainnet](https://etherscan.io/token/0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2)
- [Arbitrum](https://arbiscan.io/token/0x82af49447d8a07e3bd95bd0d56f35241523fbab1)
- [Optimism](https://optimistic.etherscan.io/token/0x4200000000000000000000000000000000000006)
-
## Weiterführende Lektüre {#further-reading}
diff --git a/public/content/translations/de/developers/tutorials/a-developers-guide-to-ethereum-part-one/index.md b/public/content/translations/de/developers/tutorials/a-developers-guide-to-ethereum-part-one/index.md
index 49f625b86b3..3c6106303de 100644
--- a/public/content/translations/de/developers/tutorials/a-developers-guide-to-ethereum-part-one/index.md
+++ b/public/content/translations/de/developers/tutorials/a-developers-guide-to-ethereum-part-one/index.md
@@ -5,7 +5,7 @@ author: Marc Garreau
lang: de
tags: [ "Python", "web3.py" ]
skill: beginner
-published: 08.09.2020
+published: 2020-09-08
source: Snake charmers
sourceUrl: https://snakecharmers.ethereum.org/a-developers-guide-to-ethereum-pt-1/
---
diff --git a/public/content/translations/de/developers/tutorials/all-you-can-cache/index.md b/public/content/translations/de/developers/tutorials/all-you-can-cache/index.md
index cb8dd2ab921..d24759b06a8 100644
--- a/public/content/translations/de/developers/tutorials/all-you-can-cache/index.md
+++ b/public/content/translations/de/developers/tutorials/all-you-can-cache/index.md
@@ -1,7 +1,7 @@
---
title: "Alles, was Sie cachen können"
description: "Erfahren Sie, wie Sie einen Caching-Vertrag für günstigere Rollup-Transaktionen erstellen und verwenden."
-author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+author: Ori Pomerantz
tags: [ "Layer 2", "Caching", "Speicher" ]
skill: intermediate
published: 2022-09-15
@@ -252,7 +252,7 @@ Ein großer Vorteil von Foundry ist, dass Tests in Solidity geschrieben werden k
return bytes.concat(INTO_CACHE, bytes32(_val));
```
-In der [EVM](/entwickler/docs/evm/) wird davon ausgegangen, dass jeder nicht initialisierte Speicher Null ist. Wenn wir also nach dem Schlüssel für einen nicht vorhandenen Wert suchen, erhalten wir eine Null. In diesem Fall sind die Bytes, die ihn kodieren, `INTO_CACHE` (damit er beim nächsten Mal zwischengespeichert wird), gefolgt von dem tatsächlichen Wert.
+In der [EVM](/developers/docs/evm/) wird davon ausgegangen, dass jeder nicht initialisierte Speicher Null ist. Wenn wir also nach dem Schlüssel für einen nicht vorhandenen Wert suchen, erhalten wir eine Null. In diesem Fall sind die Bytes, die ihn kodieren, `INTO_CACHE` (damit er beim nächsten Mal zwischengespeichert wird), gefolgt von dem tatsächlichen Wert.
```solidity
// Wenn der Schlüssel <0x10 ist, geben Sie ihn als einzelnes Byte zurück
diff --git a/public/content/translations/de/developers/tutorials/app-plasma/index.md b/public/content/translations/de/developers/tutorials/app-plasma/index.md
index 21a1c8014c0..e3f86fa1768 100644
--- a/public/content/translations/de/developers/tutorials/app-plasma/index.md
+++ b/public/content/translations/de/developers/tutorials/app-plasma/index.md
@@ -1,7 +1,7 @@
---
title: "Schreiben Sie ein App-spezifisches Plasma, das die Privatsphäre wahrt"
description: "In diesem Tutorial bauen wir eine halbgeheime Bank für Einlagen. Die Bank ist eine zentralisierte Komponente; sie kennt das Guthaben jedes Benutzers. Diese Informationen werden jedoch nicht onchain gespeichert. Stattdessen veröffentlicht die Bank einen Hash des Zustands. Jedes Mal, wenn eine Transaktion stattfindet, veröffentlicht die Bank den neuen Hash, zusammen mit einem Zero-Knowledge-Proof, dass sie eine signierte Transaktion hat, die den Hash-Zustand in den neuen ändert. Nach der Lektüre dieses Tutorials werden Sie nicht nur verstehen, wie man Zero-Knowledge-Proofs verwendet, sondern auch, warum man sie verwendet und wie man dies sicher tut."
-author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+author: Ori Pomerantz
tags:
[
"Zero-Knowledge",
diff --git a/public/content/translations/de/developers/tutorials/calling-a-smart-contract-from-javascript/index.md b/public/content/translations/de/developers/tutorials/calling-a-smart-contract-from-javascript/index.md
index e676e0a61f6..3f6f5e8c336 100644
--- a/public/content/translations/de/developers/tutorials/calling-a-smart-contract-from-javascript/index.md
+++ b/public/content/translations/de/developers/tutorials/calling-a-smart-contract-from-javascript/index.md
@@ -5,7 +5,7 @@ author: jdourlens
tags: [ "Transaktionen", "Frontend", "JavaScript", "web3.js" ]
skill: beginner
lang: de
-published: 19.04.2020
+published: 2020-04-19
source: EthereumDev
sourceUrl: https://ethereumdev.io/calling-a-smart-contract-from-javascript/
address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
diff --git a/public/content/translations/de/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md b/public/content/translations/de/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md
index 40cd770e5c5..6005c7e4797 100644
--- a/public/content/translations/de/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md
+++ b/public/content/translations/de/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md
@@ -1,10 +1,10 @@
---
title: "Erstellen einer Benutzeroberfläche für Ihren Vertrag"
description: "Mithilfe moderner Komponenten wie TypeScript, React, Vite und Wagmi werden wir eine moderne, aber minimalistische Benutzeroberfläche durchgehen und lernen, wie man eine Wallet mit der Benutzeroberfläche verbindet, einen Smart Contract aufruft, um Informationen auszulesen, eine Transaktion an einen Smart Contract zu senden und Ereignisse von einem Smart Contract zu überwachen, um Änderungen zu erkennen."
-author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+author: Ori Pomerantz
tags: [ "typescript", "react", "vite", "wagmi", "Frontend" ]
skill: beginner
-published: 01.11.2023
+published: 2023-11-01
lang: de
sidebarDepth: 3
---
diff --git a/public/content/translations/de/developers/tutorials/erc-721-vyper-annotated-code/index.md b/public/content/translations/de/developers/tutorials/erc-721-vyper-annotated-code/index.md
index abffe7281ad..d627213ef79 100644
--- a/public/content/translations/de/developers/tutorials/erc-721-vyper-annotated-code/index.md
+++ b/public/content/translations/de/developers/tutorials/erc-721-vyper-annotated-code/index.md
@@ -1,7 +1,7 @@
---
title: "Vyper ERC-721 Vertrags-Komplettlösung"
description: Ryuya Nakamuras ERC-721-Vertrag und wie er funktioniert
-author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+author: Ori Pomerantz
lang: de
tags: [ "vyper", "erc-721", "Python" ]
skill: beginner
@@ -294,6 +294,7 @@ Gibt den Wert aus der `self.supportedInterfaces`-HashMap zurück, der im Konstru
```python
### VIEW-FUNKTIONEN ###
+
```
Dies sind die View-Funktionen, die Informationen über die Token für Benutzer und andere Verträge verfügbar machen.
diff --git a/public/content/translations/de/developers/tutorials/erc20-annotated-code/index.md b/public/content/translations/de/developers/tutorials/erc20-annotated-code/index.md
index ec47cfb8494..df0c88271ed 100644
--- a/public/content/translations/de/developers/tutorials/erc20-annotated-code/index.md
+++ b/public/content/translations/de/developers/tutorials/erc20-annotated-code/index.md
@@ -1,7 +1,7 @@
---
title: "ERC-20-Vertrag – exemplarische Vorgehensweise"
description: Was beinhaltet der OpenZeppelin ERC-20-Vertrag und warum ist er da?
-author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+author: Ori Pomerantz
lang: de
tags: [ "solidity", "Erc-20" ]
skill: beginner
diff --git a/public/content/translations/de/developers/tutorials/erc20-with-safety-rails/index.md b/public/content/translations/de/developers/tutorials/erc20-with-safety-rails/index.md
index 1f76a93c690..cf7d6e742e6 100644
--- a/public/content/translations/de/developers/tutorials/erc20-with-safety-rails/index.md
+++ b/public/content/translations/de/developers/tutorials/erc20-with-safety-rails/index.md
@@ -1,7 +1,7 @@
---
title: ERC-20 mit Sicherheitsvorkehrungen
description: Wie man Leuten helfen kann, dumme Fehler zu vermeiden
-author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+author: Ori Pomerantz
lang: de
tags: [ "Erc-20" ]
skill: beginner
diff --git a/public/content/translations/de/developers/tutorials/ethereum-for-web2-auth/index.md b/public/content/translations/de/developers/tutorials/ethereum-for-web2-auth/index.md
index 946b991e134..6d4b98cb917 100644
--- a/public/content/translations/de/developers/tutorials/ethereum-for-web2-auth/index.md
+++ b/public/content/translations/de/developers/tutorials/ethereum-for-web2-auth/index.md
@@ -1,7 +1,7 @@
---
title: "Verwendung von Ethereum für die Web2-Authentifizierung"
description: "Nach der Lektüre dieses Tutorials kann ein Entwickler die Ethereum-Anmeldung (Web3) in die SAML-Anmeldung integrieren, einen in Web2 verwendeten Standard zur Bereitstellung von Single Sign-On und anderen damit verbundenen Diensten. Dies ermöglicht die Authentifizierung des Zugriffs auf Web2-Ressourcen durch Ethereum-Signaturen, wobei die Benutzerattribute aus Attestierungen stammen."
-author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+author: Ori Pomerantz
tags: [ "web2", "authentifizierung", "eas" ]
skill: beginner
lang: de
diff --git a/public/content/translations/de/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md b/public/content/translations/de/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md
index 8396f5b36e0..1f097052b0a 100644
--- a/public/content/translations/de/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md
+++ b/public/content/translations/de/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md
@@ -13,7 +13,7 @@ tags:
skill: beginner
lang: de
published: 2020-10-30
-source: Mittel
+source: Medium
sourceUrl: https://medium.com/alchemy-api/getting-started-with-ethereum-development-using-alchemy-c3d6a45c567f
---
diff --git a/public/content/translations/de/developers/tutorials/guide-to-smart-contract-security-tools/index.md b/public/content/translations/de/developers/tutorials/guide-to-smart-contract-security-tools/index.md
index 0b90d99a2a5..f934e8e1cbe 100644
--- a/public/content/translations/de/developers/tutorials/guide-to-smart-contract-security-tools/index.md
+++ b/public/content/translations/de/developers/tutorials/guide-to-smart-contract-security-tools/index.md
@@ -1,12 +1,12 @@
---
title: "Ein Leitfaden für Smart-Contract-Sicherheitstools"
description: "Ein Überblick über drei verschiedene Test- und Programmanalysetechniken"
-author: "Spuren von bits"
+author: "Trailofbits"
lang: de
tags: [ "solidity", "intelligente Verträge", "Sicherheit" ]
skill: intermediate
-published: 07.09.2020
-source: "Aufbau sicherer Verträge"
+published: 2020-09-07
+source: Building secure contracts
sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis
---
diff --git a/public/content/translations/de/developers/tutorials/how-to-implement-an-erc721-market/index.md b/public/content/translations/de/developers/tutorials/how-to-implement-an-erc721-market/index.md
index 4c06bc4de5c..ef0fa6f99d5 100644
--- a/public/content/translations/de/developers/tutorials/how-to-implement-an-erc721-market/index.md
+++ b/public/content/translations/de/developers/tutorials/how-to-implement-an-erc721-market/index.md
@@ -1,7 +1,7 @@
---
title: Wie man einen ERC-721 Markt implementiert
description: Wie man tokenisierte Assets auf einer dezentralen Pinnwand zum Verkauf anbietet
-author: "Alberto Cuesta Cañada"
+author: "Alberto Cuesta Cañada"
tags: [ "Smart Contracts", "erc-721", "Solidity", "Token" ]
skill: intermediate
lang: de
diff --git a/public/content/translations/de/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/index.md b/public/content/translations/de/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/index.md
index 896d8de3017..743d24952dc 100644
--- a/public/content/translations/de/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/index.md
+++ b/public/content/translations/de/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/index.md
@@ -1,7 +1,7 @@
---
title: So verwenden Sie Echidna zum Testen von Smart Contracts
description: So verwenden Sie Echidna zum automatischen Testen von Smart Contracts
-author: "Spuren von bits"
+author: "Trailofbits"
lang: de
tags:
[
@@ -13,7 +13,7 @@ tags:
]
skill: advanced
published: 2020-04-10
-source: "Aufbau sicherer Verträge"
+source: Building secure contracts
sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/echidna
---
diff --git a/public/content/translations/de/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/index.md b/public/content/translations/de/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/index.md
index 8b0e2a7c02c..cb078e6f8d4 100644
--- a/public/content/translations/de/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/index.md
+++ b/public/content/translations/de/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/index.md
@@ -1,7 +1,7 @@
---
title: So nutzt du Manticore, um Fehler in Smart Contracts zu finden
description: So nutzt du Manticore, um automatisiert Fehler in Smart Contracts zu finden
-author: Spuren von bits
+author: Trailofbits
lang: de
tags:
[
@@ -12,8 +12,8 @@ tags:
"Formale Verifizierung"
]
skill: advanced
-published: 13.01.2020
-source: "Aufbau sicherer Verträge"
+published: 2020-01-13
+source: Building secure contracts
sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/manticore
---
@@ -399,6 +399,7 @@ symbolic_var = m.make_symbolic_value()
contract_account.f(symbolic_var)
## Prüfen, ob eine Ausführung mit REVERT oder INVALID endet
+
for state in m.terminated_states:
last_tx = state.platform.transactions[-1]
if last_tx.result in ['REVERT', 'INVALID']:
@@ -506,6 +507,7 @@ contract_account.f(symbolic_var)
no_bug_found = True
## Prüfen, ob eine Ausführung mit REVERT oder INVALID endet
+
for state in m.terminated_states:
last_tx = state.platform.transactions[-1]
if last_tx.result in ['REVERT', 'INVALID']:
diff --git a/public/content/translations/de/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/index.md b/public/content/translations/de/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/index.md
index fa79c810ead..fa6362e934b 100644
--- a/public/content/translations/de/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/index.md
+++ b/public/content/translations/de/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/index.md
@@ -1,7 +1,7 @@
---
title: So verwenden Sie Slither, um Bugs in Smart Contracts zu finden
description: So verwenden Sie Slither, um automatisch Fehler in Smart Contracts zu finden
-author: Spuren von bits
+author: Trailofbits
lang: de
tags:
[
@@ -12,7 +12,7 @@ tags:
]
skill: advanced
published: 2020-06-09
-source: "Aufbau sicherer Verträge"
+source: Building secure contracts
sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/slither
---
diff --git a/public/content/translations/de/developers/tutorials/ipfs-decentralized-ui/index.md b/public/content/translations/de/developers/tutorials/ipfs-decentralized-ui/index.md
index 5a4a3c04c34..c75b1125099 100644
--- a/public/content/translations/de/developers/tutorials/ipfs-decentralized-ui/index.md
+++ b/public/content/translations/de/developers/tutorials/ipfs-decentralized-ui/index.md
@@ -1,7 +1,7 @@
---
title: "IPFS für dezentralisierte Benutzeroberflächen"
description: "Dieses Tutorial zeigt dem Leser, wie man IPFS nutzt, um die Benutzeroberfläche für eine Dapp zu speichern. Obwohl die Daten und die Geschäftslogik der Anwendung dezentralisiert sind, könnten Benutzer ohne eine zensurresistente Benutzeroberfläche trotzdem den Zugriff darauf verlieren."
-author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+author: Ori Pomerantz
tags: [ "ipfs" ]
skill: beginner
lang: de
diff --git a/public/content/translations/de/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md b/public/content/translations/de/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md
index cfaebd49b30..f1dc71ae15d 100644
--- a/public/content/translations/de/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md
+++ b/public/content/translations/de/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md
@@ -1,7 +1,7 @@
---
title: "Merkle-Beweise für Offline Datenintegrität"
description: "Sicherstellung der Datenintegrität onchain für Daten, die größtenteils offchain gespeichert sind"
-author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+author: Ori Pomerantz
tags: [ "Speicher" ]
skill: advanced
lang: de
diff --git a/public/content/translations/de/developers/tutorials/optimism-std-bridge-annotated-code/index.md b/public/content/translations/de/developers/tutorials/optimism-std-bridge-annotated-code/index.md
index 55f5ac6afc7..32ba13de8b4 100644
--- a/public/content/translations/de/developers/tutorials/optimism-std-bridge-annotated-code/index.md
+++ b/public/content/translations/de/developers/tutorials/optimism-std-bridge-annotated-code/index.md
@@ -1,7 +1,7 @@
---
title: "Walkthrough zum Vertrag der Optimism-Standard-Brücke"
description: "Wie funktioniert die Standard-Brücke für Optimism? Warum funktioniert sie auf diese Weise?"
-author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+author: Ori Pomerantz
tags: [ "solidity", "Brücke", "Layer 2" ]
skill: intermediate
published: 2022-03-30
diff --git a/public/content/translations/de/developers/tutorials/reverse-engineering-a-contract/index.md b/public/content/translations/de/developers/tutorials/reverse-engineering-a-contract/index.md
index 1309b7bf0a5..b77583efd22 100644
--- a/public/content/translations/de/developers/tutorials/reverse-engineering-a-contract/index.md
+++ b/public/content/translations/de/developers/tutorials/reverse-engineering-a-contract/index.md
@@ -1,7 +1,7 @@
---
title: "Reverse Engineering eines Contracts"
description: Wie Sie einen Contract verstehen, wenn Sie den Quellcode nicht haben
-author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+author: Ori Pomerantz
lang: de
tags: [ "evm", "Opcodes" ]
skill: advanced
diff --git a/public/content/translations/de/developers/tutorials/scam-token-tricks/index.md b/public/content/translations/de/developers/tutorials/scam-token-tricks/index.md
index 7b7f86f44f4..0980bcb0830 100644
--- a/public/content/translations/de/developers/tutorials/scam-token-tricks/index.md
+++ b/public/content/translations/de/developers/tutorials/scam-token-tricks/index.md
@@ -1,7 +1,7 @@
---
title: "Einige Tricks, die von Betrugs-Tokens verwendet werden, und wie man sie erkennt"
description: "In diesem Tutorial analysieren wir einen Betrugs-Token, um einige der Tricks zu sehen, die Betrüger anwenden, wie sie sie implementieren und wie wir sie erkennen können."
-author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+author: Ori Pomerantz
tags:
[
"Betrug",
@@ -11,7 +11,7 @@ tags:
"typescript"
]
skill: intermediate
-published: 15.09.2023
+published: 2023-09-15
lang: de
---
diff --git a/public/content/translations/de/developers/tutorials/secret-state/index.md b/public/content/translations/de/developers/tutorials/secret-state/index.md
index 78414174214..7749c29c967 100644
--- a/public/content/translations/de/developers/tutorials/secret-state/index.md
+++ b/public/content/translations/de/developers/tutorials/secret-state/index.md
@@ -1,7 +1,7 @@
---
title: "Verwendung von Zero-Knowledge für einen geheimen Zustand"
description: "Onchain-Spiele sind begrenzt, da sie keine versteckten Informationen enthalten können. Nach der Lektüre dieses Tutorials ist der Leser in der Lage, Zero-Knowledge-Beweise und Serverkomponenten zu kombinieren, um verifizierbare Spiele mit einer geheimen Offchain-Zustandskomponente zu erstellen. Die Technik dafür wird durch die Erstellung eines Minesweeper-Spiels demonstriert."
-author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+author: Ori Pomerantz
tags:
[
"Server",
diff --git a/public/content/translations/de/developers/tutorials/secure-development-workflow/index.md b/public/content/translations/de/developers/tutorials/secure-development-workflow/index.md
index b54fa5d3820..7306aadedf0 100644
--- a/public/content/translations/de/developers/tutorials/secure-development-workflow/index.md
+++ b/public/content/translations/de/developers/tutorials/secure-development-workflow/index.md
@@ -1,12 +1,12 @@
---
title: Smart-Contract-Sicherheitscheckliste
description: Ein empfohlener Workflow zum Schreiben sicherer Smart Contracts
-author: "Spuren von bits"
+author: "Trailofbits"
tags: [ "Smart Contracts", "Sicherheit", "Solidity" ]
skill: intermediate
lang: de
-published: 07.09.2020
-source: "Aufbau sicherer Verträge"
+published: 2020-09-07
+source: Building secure contracts
sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/workflow.md
---
diff --git a/public/content/translations/de/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md b/public/content/translations/de/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md
index 79f858b6f76..006218d9701 100644
--- a/public/content/translations/de/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md
+++ b/public/content/translations/de/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md
@@ -6,7 +6,7 @@ tags: [ "Transaktionen", "web3.js", "Alchemy" ]
skill: beginner
lang: de
published: 2020-11-04
-source: Alchemie Dokumente
+source: Alchemy docs
sourceUrl: https://www.alchemy.com/docs/how-to-send-transactions-on-ethereum
---
diff --git a/public/content/translations/de/developers/tutorials/server-components/index.md b/public/content/translations/de/developers/tutorials/server-components/index.md
index b3784445bc1..b427cad4c49 100644
--- a/public/content/translations/de/developers/tutorials/server-components/index.md
+++ b/public/content/translations/de/developers/tutorials/server-components/index.md
@@ -2,7 +2,7 @@
title: "Server-Komponenten und Agenten für Web3-Apps"
description: "Nach dem Lesen dieses Tutorials können Sie TypeScript-Server schreiben, die auf Ereignisse auf einer Blockchain lauschen und entsprechend mit ihren eigenen Transaktionen reagieren. Dies ermöglicht es Ihnen, zentralisierte Anwendungen zu schreiben (da der Server ein Single Point of Failure ist), die jedoch mit Web3-Entitäten interagieren können. Die gleichen Techniken können auch verwendet werden, um einen Agenten zu schreiben, der auf On-Chain-Ereignisse ohne menschliches Eingreifen reagiert."
-author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+author: Ori Pomerantz
lang: de
tags: [ "Agent", "Server", "Off-Chain" ]
skill: beginner
diff --git a/public/content/translations/de/developers/tutorials/short-abi/index.md b/public/content/translations/de/developers/tutorials/short-abi/index.md
index b1a8bc3c69f..763f9c307d5 100644
--- a/public/content/translations/de/developers/tutorials/short-abi/index.md
+++ b/public/content/translations/de/developers/tutorials/short-abi/index.md
@@ -1,7 +1,7 @@
---
title: "Kurze ABIs zur Calldata-Optimierung"
description: "Optimierung von Smart Contracts für Optimistic Rollups"
-author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+author: Ori Pomerantz
lang: de
tags: [ "Layer 2" ]
skill: intermediate
diff --git a/public/content/translations/de/developers/tutorials/smart-contract-security-guidelines/index.md b/public/content/translations/de/developers/tutorials/smart-contract-security-guidelines/index.md
index 56c9bcb29e3..5955ef6837e 100644
--- a/public/content/translations/de/developers/tutorials/smart-contract-security-guidelines/index.md
+++ b/public/content/translations/de/developers/tutorials/smart-contract-security-guidelines/index.md
@@ -1,12 +1,12 @@
---
title: Smart-Contract-Sicherheitsrichtlinien
description: "Eine Checkliste der Sicherheitsrichtlinien, die beim Erstellen Ihrer dapp berücksichtigt werden sollen"
-author: "Spuren von bits"
+author: "Trailofbits"
tags: [ "solidity", "Smart Contracts", "Sicherheit" ]
skill: intermediate
lang: de
-published: 06.09.2020
-source: "Aufbau sicherer Verträge"
+published: 2020-09-06
+source: Building secure contracts
sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/guidelines.md
---
diff --git a/public/content/translations/de/developers/tutorials/stealth-addr/index.md b/public/content/translations/de/developers/tutorials/stealth-addr/index.md
index 6eea3375006..3e2f48d7ed8 100644
--- a/public/content/translations/de/developers/tutorials/stealth-addr/index.md
+++ b/public/content/translations/de/developers/tutorials/stealth-addr/index.md
@@ -1,7 +1,7 @@
---
title: "Verwendung von Stealth-Adressen"
description: "Stealth-Adressen ermöglichen es Benutzern, Vermögenswerte anonym zu übertragen. Nach der Lektüre dieses Artikels werden Sie in der Lage sein: zu erklären, was Stealth-Adressen sind und wie sie funktionieren, zu verstehen, wie man Stealth-Adressen so verwendet, dass die Anonymität gewahrt bleibt, und eine webbasierte Anwendung zu schreiben, die Stealth-Adressen verwendet."
-author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+author: Ori Pomerantz
tags:
[
"Stealth-Adresse",
diff --git a/public/content/translations/de/developers/tutorials/the-graph-fixing-web3-data-querying/index.md b/public/content/translations/de/developers/tutorials/the-graph-fixing-web3-data-querying/index.md
index aa78539e4f7..ad2a5d452da 100644
--- a/public/content/translations/de/developers/tutorials/the-graph-fixing-web3-data-querying/index.md
+++ b/public/content/translations/de/developers/tutorials/the-graph-fixing-web3-data-querying/index.md
@@ -12,7 +12,7 @@ tags:
"react"
]
skill: intermediate
-published: 06.09.2020
+published: 2020-09-06
source: soliditydeveloper.com
sourceUrl: https://soliditydeveloper.com/thegraph
---
diff --git a/public/content/translations/de/developers/tutorials/token-integration-checklist/index.md b/public/content/translations/de/developers/tutorials/token-integration-checklist/index.md
index c264f614f86..c45a5b68987 100644
--- a/public/content/translations/de/developers/tutorials/token-integration-checklist/index.md
+++ b/public/content/translations/de/developers/tutorials/token-integration-checklist/index.md
@@ -1,7 +1,7 @@
---
title: "Checkliste für die Token-Integration"
description: Eine Checkliste mit Punkten, die bei der Interaktion mit Token zu beachten sind
-author: "Spuren von bits"
+author: "Trailofbits"
lang: de
tags:
[
@@ -11,8 +11,8 @@ tags:
"Token"
]
skill: intermediate
-published: 13.08.2020
-source: "Aufbau sicherer Verträge"
+published: 2020-08-13
+source: Building secure contracts
sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/token_integration.md
---
diff --git a/public/content/translations/de/developers/tutorials/uniswap-v2-annotated-code/index.md b/public/content/translations/de/developers/tutorials/uniswap-v2-annotated-code/index.md
index ed39bd07196..cd023cafd38 100644
--- a/public/content/translations/de/developers/tutorials/uniswap-v2-annotated-code/index.md
+++ b/public/content/translations/de/developers/tutorials/uniswap-v2-annotated-code/index.md
@@ -1,7 +1,7 @@
---
title: "Uniswap-v2-Vertrag Walk-Through"
description: Wie funktioniert der Uniswap-v2-Vertrag? Warum ist er so geschrieben?
-author: Ori Pomerantz ist der Autor des Linux Kernel Module Programming Guide
+author: Ori Pomerantz
tags: [ "solidity" ]
skill: intermediate
published: 2021-05-01
@@ -56,9 +56,8 @@ Dies ist der häufigste Ablauf, der von Händlern verwendet wird:
4. Iteriert über den Pfad. Für jede Börse auf dem Weg sendet es den Input-Token und ruft dann die `swap`-Funktion der Börse auf.
In den meisten Fällen ist die Zieladresse für die Tokens die nächste Tauschbörse im Pfad. Bei der letzten Börse ist es die vom Händler angegebene Adresse.
-#### Im Kernvertrag (UniswapV2Pair.sol) {#in-the-core-contract-uniswapv2pairsol-2}
+#### Im Kernvertrag (UniswapV2Pair.sol) {#in-the-core-contract-uniswapv2pairsol-2}5. Überprüfen Sie, ob der Kernvertrag nicht betrogen wird und nach dem Tausch eine ausreichende Liquidität aufrechterhalten kann.
-5. Überprüfen Sie, ob der Kernvertrag nicht betrogen wird und nach dem Tausch eine ausreichende Liquidität aufrechterhalten kann.
6. Sehen Sie, wie viele zusätzliche Tokens wir zusätzlich zu den bekannten Reserven haben. Dieser Betrag ist die Anzahl der Input-Tokens, die wir zum Tausch erhalten haben.
7. Senden Sie die Output-Tokens an das Ziel.
8. Rufen Sie `_update` auf, um die Reservebeträge zu aktualisieren
diff --git a/public/content/translations/de/developers/tutorials/using-websockets/index.md b/public/content/translations/de/developers/tutorials/using-websockets/index.md
index 3e789dabc44..6266a89d9e5 100644
--- a/public/content/translations/de/developers/tutorials/using-websockets/index.md
+++ b/public/content/translations/de/developers/tutorials/using-websockets/index.md
@@ -5,7 +5,7 @@ author: "Elan Halpern"
lang: de
tags: [ "Alchemy", "WebSocket", "Abfragen", "javascript" ]
skill: beginner
-source: Alchemie Dokumente
+source: Alchemy docs
sourceUrl: https://www.alchemy.com/docs/reference/best-practices-for-using-websockets-in-web3
published: 2020-12-01
---
diff --git a/public/content/translations/de/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md b/public/content/translations/de/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md
index 441b683f043..d57ac383c7d 100644
--- a/public/content/translations/de/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md
+++ b/public/content/translations/de/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md
@@ -12,7 +12,7 @@ tags:
]
skill: intermediate
lang: de
-published: 14.11.2020
+published: 2020-11-14
---
## Worum geht es in diesem Tutorial? {#what-is-this-tutorial-about}
diff --git a/public/content/translations/de/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md b/public/content/translations/de/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md
index 2bae3c0e375..eec5396f6cd 100644
--- a/public/content/translations/de/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md
+++ b/public/content/translations/de/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md
@@ -13,7 +13,7 @@ tags:
]
skill: beginner
lang: de
-published: 16.10.2020
+published: 2020-10-16
---
In diesem [Waffle](https://ethereum-waffle.readthedocs.io)-Tutorial lernen wir, wie man ein einfaches „Hallo Welt“-Smart-Contract-Projekt mit [Hardhat](https://hardhat.org/) und [ethers.js](https://docs.ethers.io/v5/) einrichtet. Dann werden wir lernen, wie wir eine neue Funktionalität zu unserem Smart Contract hinzufügen und wie wir sie mit Waffle testen können.
diff --git a/public/content/translations/de/ethereum-forks/index.md b/public/content/translations/de/ethereum-forks/index.md
index bb9f5fa75b6..f4056ef4d20 100644
--- a/public/content/translations/de/ethereum-forks/index.md
+++ b/public/content/translations/de/ethereum-forks/index.md
@@ -11,7 +11,7 @@ Ein Zeitstrang aller wichtigsten Meilensteine, Forks und Aktualisierungen der Et
-Forks entstehen, wenn wichtige technische Neuerungen oder Änderungen am Netzwerk vorgenommen werden müssen. Sie stammen in der Regel von den [Ethereum-Verbesserungsvorschlägen (EIPs)](/eips) ab und verändern die "Richtlinien" des Protokolls.
+Forks entstehen, wenn wichtige technische Neuerungen oder Änderungen am Netzwerk vorgenommen werden müssen. Sie stammen in der Regel von den [Ethereum-Verbesserungsvorschlägen (EIPs)](/eips/) ab und verändern die "Richtlinien" des Protokolls.
Wenn für eine Standardsoftware eine Aktualisierung benötigt wird, veröffentlicht der Hersteller lediglich eine neue Version für den Endbenutzer. Blockchains arbeiten anders, da es keinen alleinigen Besitzer gibt. [Ethereum Anwendungen](/developers/docs/nodes-and-clients/) müssen die Software aktualisieren um neue Regeln zu implementieren. Plus Block Ersteller (Miner in einer Proof-of-Work Umgebung, Validatoren in einer Proof-of-Stake Umgebung) und Nodes erstellen neue Blöcke und müssen diese, entsprechend der neuen Richtlinien, validieren. [Mehr zu Konsensmechanismen](/developers/docs/consensus-mechanisms/)
diff --git a/public/content/translations/de/guides/how-to-create-an-ethereum-account/index.md b/public/content/translations/de/guides/how-to-create-an-ethereum-account/index.md
index c4d6753e1ce..8ee638f609e 100644
--- a/public/content/translations/de/guides/how-to-create-an-ethereum-account/index.md
+++ b/public/content/translations/de/guides/how-to-create-an-ethereum-account/index.md
@@ -42,8 +42,7 @@ Einige Apps werden Sie auffordern, eine geheime „Wiederherstellungsphrase“ (
- Wallet installiert?
Erfahren Sie, wie Sie sie verwenden.
-
+ Wallet installiert?
Erfahren Sie, wie Sie sie verwenden.
So verwenden Sie eine Wallet
diff --git a/public/content/translations/de/guides/how-to-revoke-token-access/index.md b/public/content/translations/de/guides/how-to-revoke-token-access/index.md
index 59bf6b53032..70587dbc321 100644
--- a/public/content/translations/de/guides/how-to-revoke-token-access/index.md
+++ b/public/content/translations/de/guides/how-to-revoke-token-access/index.md
@@ -49,8 +49,7 @@ Wir empfehlen Ihnen, das Widerrufs-Tool nach einigen Minuten zu aktualisieren un
- Möchten Sie mehr erfahren?
-
+ Möchten Sie mehr erfahren?
Sehen Sie unsere anderen Anleitungen
diff --git a/public/content/translations/de/guides/how-to-swap-tokens/index.md b/public/content/translations/de/guides/how-to-swap-tokens/index.md
index 69b481ac259..7ee9ebedcf2 100644
--- a/public/content/translations/de/guides/how-to-swap-tokens/index.md
+++ b/public/content/translations/de/guides/how-to-swap-tokens/index.md
@@ -52,8 +52,7 @@ Sie werden die getauschten Token automatisch in Ihrer Krypto-Wallet erhalten, we
- Möchten Sie mehr erfahren?
-
+ Möchten Sie mehr erfahren?
Sehen Sie unsere anderen Anleitungen
diff --git a/public/content/translations/de/guides/how-to-use-a-bridge/index.md b/public/content/translations/de/guides/how-to-use-a-bridge/index.md
index aa4fd9914cc..5bc108e71c0 100644
--- a/public/content/translations/de/guides/how-to-use-a-bridge/index.md
+++ b/public/content/translations/de/guides/how-to-use-a-bridge/index.md
@@ -54,8 +54,7 @@ Sie können [chainlist.org](http://chainlist.org) verwenden, um die RPC-Details
- Möchten Sie mehr erfahren?
-
+ Möchten Sie mehr erfahren?
Sehen Sie unsere anderen Anleitungen
diff --git a/public/content/translations/de/guides/how-to-use-a-wallet/index.md b/public/content/translations/de/guides/how-to-use-a-wallet/index.md
index 4919ad467eb..0832ba7639a 100644
--- a/public/content/translations/de/guides/how-to-use-a-wallet/index.md
+++ b/public/content/translations/de/guides/how-to-use-a-wallet/index.md
@@ -65,8 +65,7 @@ Ihre Adresse wird auf allen Ethereum Projekten dieselbe sein. Sie brauchen sich
- Möchten Sie mehr erfahren?
-
+ Möchten Sie mehr erfahren?
Sehen Sie unsere anderen Anleitungen
diff --git a/public/content/translations/de/nft/index.md b/public/content/translations/de/nft/index.md
index cdc97c65d59..a774f649ec7 100644
--- a/public/content/translations/de/nft/index.md
+++ b/public/content/translations/de/nft/index.md
@@ -58,8 +58,7 @@ Vielleicht sind Sie ein Künstler, der seine Werke mithilfe von NFTs verbreiten
- Entdecken, kaufen oder erstellen Sie Ihre eigene(n) NFT-Kunst/Sammelgegenstände ...
-
+ Entdecken, kaufen oder erstellen Sie Ihre eigene(n) NFT-Kunst/Sammelgegenstände ...
NFT-Kunst entdecken
diff --git a/public/content/translations/de/payments/index.md b/public/content/translations/de/payments/index.md
index 3bf21207194..54f6f7c8204 100644
--- a/public/content/translations/de/payments/index.md
+++ b/public/content/translations/de/payments/index.md
@@ -60,12 +60,12 @@ In Ländern, in denen ihre Zahlungsmittel vom Rest der Welt abgekoppelt wurden,
- Erstellen Sie noch heute Ihr Ethereum-Konto mit einer Wallet-App.
-
+ Erstellen Sie noch heute Ihr Ethereum-Konto mit einer Wallet-App.
Jetzt loslegen
+
## Bezahlen mit selbstverwalteten Krypto-Karten {#pay-with-self-custodial-crypto-cards}
@@ -198,10 +198,10 @@ Von der Erleichterung der schnellen Katastrophenhilfe bis zur Stärkung globaler
- Zeit, Ihr eigenes Ethereum-Konto zu erstellen.
-
+ Zeit, Ihr eigenes Ethereum-Konto zu erstellen.
Jetzt loslegen!
+
diff --git a/public/content/translations/de/prediction-markets/index.md b/public/content/translations/de/prediction-markets/index.md
index fce64fa499a..552054a2f8d 100644
--- a/public/content/translations/de/prediction-markets/index.md
+++ b/public/content/translations/de/prediction-markets/index.md
@@ -56,7 +56,9 @@ Es sind mehrere auf Ethereum basierende Prognosemärkte verfügbar. Dies sind ei
Achten Sie auf die Risiken
Wetten Sie nur, was Sie sich leisten können, und seien Sie sich des potenziellen Suchtverhaltens bewusst.
+
+
## Herausforderungen und Risiken {#challenges-and-risks}
diff --git a/public/content/translations/de/roadmap/beacon-chain/index.md b/public/content/translations/de/roadmap/beacon-chain/index.md
index 20c2f249734..c63afdc0641 100644
--- a/public/content/translations/de/roadmap/beacon-chain/index.md
+++ b/public/content/translations/de/roadmap/beacon-chain/index.md
@@ -19,6 +19,7 @@ summaryPoint3: "Mit der Beacon Chain wurde die Konsenslogik und das Block-Gossip
Die Beacon Chain ist der Name der ursprünglichen Proof-of-Stake (Anteilsnachweis) Blockchain, die im Jahr 2020 eingeführt wurde. Sie wurde geschaffen, um sicherzustellen, dass die Proof-of-Stake Konsenslogik sicher und nachhaltig ist, bevor sie auf dem Ethereum Mainnet eingeführt wurde. Sie wurde daher neben dem ursprünglichen Proof-of-Work Konsens für Ethereum betrieben. Die Beacon Chain bestand aus 'leeren' Blöcken. Die Umstellung von Proof-of-Work (Arbeitsnachweis) auf den Proof-of-Stake (Anteilsnachweis) Mechanismus auf Ethereum erforderte jedoch, dass die Beacon Chain angewiesen wurde, Transaktionsdaten von Ausführungsklienten anzunehmen, sie zu Blockbündeln zusammenzuführen und sie dann mithilfe eines auf dem Proof-of-Stake-Mechanismus basierenden Konsensverfahrens in eine Blockchain zu organisieren. Zur gleichen Zeit haben die ursprünglichen Ethereum Clients ihr Mining, die Blockausbreitung und die Konsenslogik abgeschaltet und alles an die Beacon Chain übergeben. Dieses Ereignis war als [The Merge](/roadmap/merge/) bekannt. Nachdem das Merge (Fusion)-Ereignis erfolgreich abgeschlossen war, existierten keine zwei Blockchains mehr. Stattdessen existierte nur noch ein Proof-of-Stake Ethereum, für das nun pro Knoten zwei verschiedene Klienten erforderlich waren. Die Beacon Chain ist nun die Konsensus-Ebene, ein Peer-to-Peer-Netzwerk von Konsens-Clients, das für den Block-Tratsch und die Konsensus-Logik zuständig ist, während die ursprünglichen Clients die Ausführungs-Ebene bilden, die für den Tratsch und die Ausführung von Transaktionen sowie die Verwaltung des Ethereum-Status verantwortlich ist. Die beiden Schichten können über die Engine-API miteinander kommunizieren.
## Welche Funktion hat die Beacon Chain? {#what-does-the-beacon-chain-do}
+
Die Beacon Chain ist die Bezeichnung für ein Hauptbuch von Konten, das das Netzwerk der Ethereum-[Staker](/staking/) betrieb und koordinierte, bevor diese Staker mit der Validierung echter Ethereum-Blöcke begannen. Es werden jedoch keine Transaktionen verarbeitet oder Smart-Contract-Interaktionen abgewickelt, da dies in der Ausführungs-Ebene geschieht.
Die Beacon Chain ist verantwortlich für Dinge wie die Handhabung von Blöcken und Bescheinigungen, die Ausführung des Fork-Choice-Algorithmus und die Verwaltung von Belohnungen und Strafen.
Lesen Sie mehr auf unserer [Seite zur Node-Architektur](/developers/docs/nodes-and-clients/node-architecture/#node-comparison).
diff --git a/public/content/translations/de/roadmap/dencun/index.md b/public/content/translations/de/roadmap/dencun/index.md
index 64087ab051d..200c87061cf 100644
--- a/public/content/translations/de/roadmap/dencun/index.md
+++ b/public/content/translations/de/roadmap/dencun/index.md
@@ -6,9 +6,9 @@ lang: de
# Cancun-Deneb (Dencun) {#dencun}
-Cancun-Deneb (Dencun) ist ein Upgrade des Ethereum-Netzwerks, bei dem **Proto-Danksharding (EIP-4844)** aktiviert wird. Im Zuge dessen werden temporäre Daten **Blobs** für günstigere [Layer 2 (L2)](/Glossar/#layer-2)-Rollup-Speicherung einführt.
+Cancun-Deneb (Dencun) ist ein Upgrade des Ethereum-Netzwerks, bei dem **Proto-Danksharding (EIP-4844)** aktiviert wird. Im Zuge dessen werden temporäre Daten **Blobs** für günstigere [Layer 2 (L2)](/glossary/#layer-2)-Rollup-Speicherung einführt.
-Ein neuer Transaktionstyp ermöglicht es Rollup-Anbietern, Daten kostengünstiger in sogenannten „Blobs“ zu speichern. Diese Blobs stehen dem Netzwerk etwa 18 Tage lang garantiert zur Verfügung (genauer gesagt 4096 [Epochen](/Glossar/#epoch)). Nach Ablauf dieser Zeit werden die Blobs aus dem Netzwerk entfernt, aber die Anwendungen können die Gültigkeit ihrer Daten immer noch mithilfe von Nachweisen verifizieren.
+Ein neuer Transaktionstyp ermöglicht es Rollup-Anbietern, Daten kostengünstiger in sogenannten „Blobs“ zu speichern. Diese Blobs stehen dem Netzwerk etwa 18 Tage lang garantiert zur Verfügung (genauer gesagt 4096 [Epochen](/glossary/#epoch)). Nach Ablauf dieser Zeit werden die Blobs aus dem Netzwerk entfernt, aber die Anwendungen können die Gültigkeit ihrer Daten immer noch mithilfe von Nachweisen verifizieren.
Dies senkt die Kosten für Rollups erheblich, begrenzt das Wachstum der Chain und sorgt dafür, dass mehr Nutzer unterstützt werden. Gleichzeitig bleibt die Sicherheit und eine dezentralisierte Gruppe von Knotenpunktbetreibern erhalten.
@@ -23,7 +23,7 @@ Dies senkt die Kosten für Rollups erheblich, begrenzt das Wachstum der Chain un
- **Kein Handlungsbedarf für Ihre ETH**: Nach dem Upgrade Ethereum Dencun besteht keine Notwendigkeit, Ihre ETH umzuwandeln oder zu aktualisieren. Ihre Kontoguthaben bleiben unverändert und die ETH, die Sie derzeit besitzen, bleiben auch nach der harten Abspaltung in der bestehenden Form zugänglich.
- **Vorsicht vor Betrug!**
+
## Nach dem Merge (heute) {#post-merge}
@@ -96,7 +98,9 @@ Gesamte annualisierte Emissionsrate: **~0,52 %**
Nettorückgang der jährlichen ETH-Emission: **~88,7 %** ((4,61 % - 0,52 %) / 4,61 % \* 100)
+
+
##
+
Zusätzlich zu den Gebühren, die durch das London Upgrade verbrannt werden, können Validatoren auch mit Strafen belegt werden, wenn sie offline sind, oder schlimmer noch, ihr Stake kann gekürzt werden, wenn sie gegen bestimmte Regeln verstoßen, die die Netzsicherheit gefährden. Diese Strafen führen zu einer Verringerung des ETH-Guthabens dieses Validators, das nicht auf ein anderes Konto überwiesen wird, sondern effektiv verbrannt/aus dem Verkehr gezogen wird.
diff --git a/public/content/translations/de/roadmap/pectra/index.md b/public/content/translations/de/roadmap/pectra/index.md
index f8401707961..2ce0db16fa2 100644
--- a/public/content/translations/de/roadmap/pectra/index.md
+++ b/public/content/translations/de/roadmap/pectra/index.md
@@ -105,7 +105,7 @@ Ja, das Pectra-Upgrade erfordert Updates sowohl für [Ausführungs-Clients als a
- **Keine Aktion für deine ETH erforderlich**: Nach dem Ethereum-Pectra-Upgrade ist es nicht notwendig, deine ETH umzuwandeln oder zu aktualisieren. Ihre Kontoguthaben bleiben unverändert und die ETH, die Sie derzeit besitzen, bleiben auch nach der harten Abspaltung in der bestehenden Form zugänglich.
- **Vorsicht vor Betrug!**
+
- Mehr über NFTs erfahren
-
+ Mehr über NFTs erfahren
Mehr zu NFTs
@@ -98,8 +97,7 @@ Allerdings definieren Menschen viele Web3-Communities als DAOs. Diese Gemeinscha
- Erfahren Sie mehr über DAOs
-
+ Erfahren Sie mehr über DAOs
Mehr über DAOs
diff --git a/public/content/translations/de/wrapped-eth/index.md b/public/content/translations/de/wrapped-eth/index.md
index 43f942a8cf0..2d6bcc72169 100644
--- a/public/content/translations/de/wrapped-eth/index.md
+++ b/public/content/translations/de/wrapped-eth/index.md
@@ -8,8 +8,7 @@ lang: de
Ether (ETH) ist die Hauptwährung von Ethereum. Es wird für verschiedene Zwecke verwendet, wie Staking, als Währung und zur Bezahlung von Gasgebühren für Berechnungen. **WETH ist im Grunde eine erweiterte Form von ETH mit gewisser zusätzlicher Funktionalität, die von vielen Anwendungen und [ERC-20-Token](/glossary/#erc-20)** benötigt wird, welche andere Arten von digitalen Assets auf Ethereum darstellen. Um mit diesen Token arbeiten zu können, muss ETH dieselben Regeln befolgen, auch als ERC-20-Standard bekannt.
From a793004b8e7fc34c11e37867cff01cd53c32470f Mon Sep 17 00:00:00 2001
From: Joshua <62268199+minimalsm@users.noreply.github.com>
Date: Fri, 13 Feb 2026 17:23:39 +0000
Subject: [PATCH 5/9] chore: trigger rebuild
From bd96fa22f184641173c51a31c4b8fb15bcf5cb55 Mon Sep 17 00:00:00 2001
From: Joshua <62268199+minimalsm@users.noreply.github.com>
Date: Fri, 13 Feb 2026 19:29:29 +0000
Subject: [PATCH 6/9] fix(i18n): remove escaped quotes in
de/zero-knowledge-proofs
---
.../content/translations/de/zero-knowledge-proofs/index.md | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/public/content/translations/de/zero-knowledge-proofs/index.md b/public/content/translations/de/zero-knowledge-proofs/index.md
index b1b799bf0f4..b7abcd5e676 100644
--- a/public/content/translations/de/zero-knowledge-proofs/index.md
+++ b/public/content/translations/de/zero-knowledge-proofs/index.md
@@ -54,10 +54,10 @@ Zero-Knowledge-Beweise sind besonders nützlich im Kontext der [dezentralen Iden
- Ein reales Beispiel für die Verwendung von ZKP für Identitätsmanagementsysteme ist das National Digital ID (NDI)-System des Königreichs Bhutan, das auf Ethereum aufbaut. Bhutans NDI verwendet ZKPs, um es den Bürgern zu ermöglichen, Fakten über sich selbst kryptografisch zu beweisen, wie z. B. \"Ich bin Staatsbürger\" oder \"Ich bin über 18\", ohne die sensiblen persönlichen Daten auf ihrem Ausweis preiszugeben.
+ Ein reales Beispiel für die Verwendung von ZKP für Identitätsmanagementsysteme ist das National Digital ID (NDI)-System des Königreichs Bhutan, das auf Ethereum aufbaut. Bhutans NDI verwendet ZKPs, um es den Bürgern zu ermöglichen, Fakten über sich selbst kryptografisch zu beweisen, wie z. B. "Ich bin Staatsbürger" oder "Ich bin über 18", ohne die sensiblen persönlichen Daten auf ihrem Ausweis preiszugeben.
- Erfahre mehr über Bhutan NDI in der Fallstudie zur dezentralen Identität.
+ Erfahre mehr über Bhutan NDI in der Fallstudie zur dezentralen Identität.
@@ -111,7 +111,7 @@ Zum Beispiel stützen sich [quadratische Finanzierungsmechanismen](https://www.r
Durch die Verwendung von Offchain Voting ist die quadratische Finanzierung anfällig für Absprachen: Blockchain-Transaktionen sind öffentlich, sodass bestecher die Offchain Aktivitäten eines Bestechlichen überprüfen können, um zu sehen, wie dieser „abgestimmt“ hat. Auf diese Weise ist die quadratische Finanzierung kein effektives Mittel mehr, um Gelder auf der Grundlage der aggregierten Präferenzen der Gemeinschaft zuzuweisen.
-Glücklicherweise verwenden neuere Lösungen wie MACI (Minimum Anti-Collusion Infrastructure) Zero-Knowledge-Beweise, um On-Chain-Abstimmungen (z. B. quadratische Finanzierungsmechanismen) resistent gegen Bestechung und Kollusion zu machen. MACI ist ein Satz von Smart Contracts und Skripten, die es einem zentralen Administrator (genannt \"Koordinator\") ermöglichen, Stimmen zu sammeln und Ergebnisse zusammenzuzählen, _ohne_ Details darüber preiszugeben, wie jede einzelne Person abgestimmt hat. Trotzdem ist es immer noch möglich zu überprüfen, ob die Stimmen korrekt gezählt wurden, oder zu bestätigen, dass eine bestimmte Person an der Abstimmungsrunde teilgenommen hat.
+Glücklicherweise verwenden neuere Lösungen wie MACI (Minimum Anti-Collusion Infrastructure) Zero-Knowledge-Beweise, um On-Chain-Abstimmungen (z. B. quadratische Finanzierungsmechanismen) resistent gegen Bestechung und Kollusion zu machen. MACI ist ein Satz von Smart Contracts und Skripten, die es einem zentralen Administrator (genannt "Koordinator") ermöglichen, Stimmen zu sammeln und Ergebnisse zusammenzuzählen, _ohne_ Details darüber preiszugeben, wie jede einzelne Person abgestimmt hat. Trotzdem ist es immer noch möglich zu überprüfen, ob die Stimmen korrekt gezählt wurden, oder zu bestätigen, dass eine bestimmte Person an der Abstimmungsrunde teilgenommen hat.
#### Wie arbeitet MACI mit Null-Wissen-Beweisen? {#how-maci-works-with-zk-proofs}
From 112855d8b5aa7bbd2a0fc19c961acc3a47c564e9 Mon Sep 17 00:00:00 2001
From: Joshua <62268199+minimalsm@users.noreply.github.com>
Date: Fri, 13 Feb 2026 19:43:49 +0000
Subject: [PATCH 7/9] chore: trigger rebuild
From 2cc9f07f2372cb35f31d837c53197df8e4be0ef5 Mon Sep 17 00:00:00 2001
From: Joshua <62268199+minimalsm@users.noreply.github.com>
Date: Fri, 13 Feb 2026 21:52:49 +0000
Subject: [PATCH 8/9] chore: trigger rebuild (batched)
From 5df69404dc1ac6fffd3ced2845fdac2f4d62e465 Mon Sep 17 00:00:00 2001
From: Joshua <62268199+minimalsm@users.noreply.github.com>
Date: Fri, 13 Feb 2026 22:22:19 +0000
Subject: [PATCH 9/9] chore: trigger rebuild