From 7600371df0be3bb8508efac127d6413ac78173a7 Mon Sep 17 00:00:00 2001
From: Emmanuel Awosika <102589267+emmanuel-awosika@users.noreply.github.com>
Date: Sat, 9 Apr 2022 15:35:59 +0100
Subject: [PATCH 001/298] Add new information to Plasma page
Suggest updating the pros vs cons section for Plasma chains and adding a comparison of Plasma against similar scaling solutions, like sidechains and sharding.
---
.../developers/docs/scaling/plasma/index.md | 32 +++++++++++++++++--
1 file changed, 30 insertions(+), 2 deletions(-)
diff --git a/src/content/developers/docs/scaling/plasma/index.md b/src/content/developers/docs/scaling/plasma/index.md
index cdde72d051b..f205187d5c5 100644
--- a/src/content/developers/docs/scaling/plasma/index.md
+++ b/src/content/developers/docs/scaling/plasma/index.md
@@ -19,8 +19,35 @@ You should have a good understanding of all the foundational topics and a high-l
| --------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| High throughput, low cost per transaction. | Does not support general computation. Only basic token transfers, swaps, and a few other transaction types are supported via predicate logic. |
| Good for transactions between arbitrary users (no overhead per user pair if both are established on the plasma chain) | Need to periodically watch the network (liveness requirement) or delegate this responsibility to someone else to ensure the security of your funds. |
-| | Relies on one or more operators to store data and serve it upon request. |
-| | Withdrawals are delayed by several days to allow for challenges. For fungible assets this can be mitigated by liquidity providers, but there is an associated capital cost. |
+| Plasma chains can be adapted to specific use-cases that are unrelated to the main chain. Anyone, including businesses, can customize Plasma smart contracts to provide scalable infrastructure that works in different contexts. | Relies on one or more operators to store data and serve it upon request. |
+| | Withdrawals are delayed by several days to allow for challenges. For fungible assets this can be mitigated by liquidity providers, but there is an associated capital cost. |
+| | If too many users try to exit their Plasma chain simultaneously (due to malicious activity or network failure), they could flood the root chain and congest the network. |
+
+## How does Plasma differ from sidechains and sharding?
+
+Plasma, sidechains, and sharding all follow a similar pattern where a collection of "child chains" rely on a "main chain" for consensus. At intervals, cryptographic proofs of transaction validity (hashes) are submitted to the main chain to prevent fraudulent activity on child chains.
+
+However, the three scaling solutions have slight differences. Here is a quick comparison of Plasma chains, sidechains, and shard chains:
+
+### Plasma vs sidechains
+
+A [sidechain](https://ethereum.org/en/developers/docs/scaling/sidechains/) is a blockchain operating independently but connects to the main blockchain (Ethereum Mainnet) via a two-way bridge. [Bridges](https://ethereum.org/en/bridges/) allow users to exchange tokens between both blockchains, so they can transact on the sidechain—reducing congestion on the base layer and improving scalability.
+With sidechains, there's the risk of losing your funds. Sidechains use a separate consensus mechanism and, ergo, cannot rely on the security of Ethereum Mainnet (Layer 1).
+
+Conversely, Plasma chains are somewhat safer than sidechains because they derive their security from Ethereum's base layer. Like sidechains, Plasma chains can have a different consensus protocol.
+
+The difference is that Plasma publishes Merkle roots for each block on the Ethereum main chain. Block roots are small pieces of information we can use to verify information about transactions that happen on a Plasma chain. If an attack happens on a Plasma chain, users can safely exit to the main chain and withdraw their funds using the appropriate proofs.
+
+A simple way to differentiate between Plasma and sidechains is that Plasma chains are non-custodial, while sidechains are custodial.
+
+### Plasma vs sharding
+
+Both Plasma chains and [shard chains](https://ethereum.org/en/upgrades/shard-chains/) periodically publish cryptographic proofs on the main chain. However, both have different security properties.
+Shard chains are tightly coupled to the main chain, but plasma chains are not. Even if one shard block is invalid, the entire chain will reorganize and discard the invalid block. Thus, shard chains can be as safe as the main chain.
+
+While Plasma chains can benefit from Layer 1 security, they are not as tightly linked to the main chain as shard chains. It's possible to commit an invalid Plasma block header to the main chain since the larger network has little information about the state of the Plasma chain.
+
+With sharding, the main chain knows how sharded sub-chains should operate and can reject an invalid shard transition. The upside to Plasma is the effects of a malicious activity can be restricted to the child chain, while the effect on malicious activity on shard chains would affect the entire network.
### Use Plasma {#use-plasma}
@@ -35,5 +62,6 @@ Multiple projects provide implementations of Plasma that you can integrate into
- [EthHub on Plasma](https://docs.ethhub.io/ethereum-roadmap/layer-2-scaling/plasma/)
- [Learn Plasma](https://www.learnplasma.org/en/)
+- [Sidechains vs Plasma vs Sharding](https://vitalik.ca/general/2019/06/12/plasma_vs_sharding.html)
_Know of a community resource that helped you? Edit this page and add it!_
From d16e26a24f3a584db10626607d29daaabf376a28 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 19 Apr 2022 18:17:56 +0200
Subject: [PATCH 002/298] setup translations
---
src/intl/en/page-layer-2.json | 54 +++++++-
src/pages/layer-2.js | 240 +++++++++++++---------------------
2 files changed, 144 insertions(+), 150 deletions(-)
diff --git a/src/intl/en/page-layer-2.json b/src/intl/en/page-layer-2.json
index 0ebc45e01bc..af5a48808b9 100644
--- a/src/intl/en/page-layer-2.json
+++ b/src/intl/en/page-layer-2.json
@@ -2,5 +2,57 @@
"layer-2-arbitrum-note": "Fraud proofs only for whitelisted users, whitelist not open yet",
"layer-2-boba-note": "State validation in development",
"layer-2-metis-note": "Fraud proofs in development",
- "layer-2-optimism-note": "Fault proofs in development"
+ "layer-2-optimism-note": "Fault proofs in development",
+ "layer-2-hero-title": "Layer 2",
+ "layer-2-hero-header": "Ethereum for everyone",
+ "layer-2-hero-subtitle": "Scaling Ethereum without compromising on security or decentralization.",
+ "layer-2-hero-alt-text": "Layer 2 diagram",
+ "layer-2-hero-button-1": "What is layer 2",
+ "layer-2-hero-button-2": "Use layer 2",
+ "layer-2-statsbox-1": "TVL locked in layer 2 (USD)",
+ "layer-2-statsbox-2": "Average layer 2 ETH transfer fee (USD)",
+ "layer-2-statsbox-3": "Layer 2 TVL change (30 days)",
+ "layer-2-what-is-layer-2-title": "What is layer 2?",
+ "layer-2-what-is-layer-2-1": "Layer 2 (L2) is a collective term to describe a specific set of Ethereum scaling solutions. A layer 2 is separate blockchain that extends Ethereum and inherits the security guarantees of Ethereum.",
+ "layer-2-what-is-layer-2-2": "Now let’s dig into it a bit more, and to do this we need to explain layer 1 (L1).",
+ "layer-2-what-is-layer-1-title": "What is layer 1?",
+ "layer-2-what-is-layer-1-1": "Layer 1 is the base blockchain. Ethereum and Bitcoin are both layer 1 blockchains because they are the underlying foundation that various layer 2 networks build on top of. Examples of layer 2 projects include \"rollups\" on Ethereum and the Lighting Network on top of Bitcoin. All user transaction activity on these layer 2 projects can ultimately settle back to the layer 1 blockchain.",
+ "layer-2-what-is-layer-1-2": "Ethereum also functions as a data availability layer for layer 2s. Layer 2 projects will post their transaction data onto Ethereum, relying on Ethereum for data availability. This data can be used to get the state of the layer 2, or to dispute transactions on layer 2.",
+ "layer-2-what-is-layer-1-list-title": "Ethereum as the layer 1 includes:",
+ "layer-2-what-is-layer-1-list-1": "A network of node operators to secure and validate the network",
+ "layer-2-what-is-layer-1-list-2": "A network of block producers",
+ "layer-2-what-is-layer-1-list-3": "The blockchain itself and the history of transaction data",
+ "layer-2-what-is-layer-1-list-4": "The consensus mechanism for the network",
+ "layer-2-what-is-layer-1-list-link-1": "Still confused on Ethereum?",
+ "layer-2-what-is-layer-1-list-link-2": "Learn what Ethereum is.",
+ "layer-2-why-do-we-need-layer-2-title": "Why do we need layer 2?",
+ "layer-2-why-do-we-need-layer-2-1": "Three desirable properties of a blockchain are that it is decentralized, secure, and scalable. The blockchain trilemma states that a simple blockchain architecture can only achieve two out of three. Want a secure and decentralized blockchain? You need to sacrifice scalability.",
+ "layer-2-why-do-we-need-layer-2-2": "Ethereum has reached the network's current capacity with 1+ million transactions per day and high demand for each of these transactions. The success of Ethereum and the demand to use it has caused gas prices to rise substantially. Therefore the need for scaling solutions has increased in demand as well. This is where layer 2 networks come in.",
+ "layer-2-why-do-we-need-layer-2-scalability": "Scalability",
+ "layer-2-why-do-we-need-layer-2-scalability-1": "The main goal of scalability is to increase transaction speed (faster finality) and transaction throughput (higher transactions per second) without sacrificing decentralization or security.",
+ "layer-2-why-do-we-need-layer-2-scalability-2": "The Ethereum community has taken a strong stance that it would not throw out decentralization or security in order to scale. Until sharding, Ethereum Mainnet (layer 1) is only able to process roughly 15 transactions per second. When demand to use Ethereum is high, the network becomes congested, which increases transaction fees and prices out users who cannot afford those fees. That is where layer 2 comes in to scale Ethereum today.",
+ "layer-2-why-do-we-need-layer-2-scalability-3": "More on Ethereum's vision",
+ "layer-2-benefits-of-layer-2-title": "Benefits of layer 2",
+ "layer-2-lower-fees-title": "Lower fees",
+ "layer-2-lower-fees-description": "By combining multiple off-chain transactions into a single layer 1 transaction, transaction fees are massively reduced, making Ethereum more accessible for all.",
+ "layer-2-maintain-security-title": "Maintain security",
+ "layer-2-maintain-security-description": "Layer 2 blockchains settle their transactions on Ethereum Mainnet, allowing users to benefit from the security of the Ethereum network.",
+ "layer-2-expand-use-cases-title": "Expand use cases",
+ "layer-2-expand-use-cases-description": "With higher transactions per second, lower fees, and new technology, projects will expand into new applications with improved user experience.",
+ "layer-2-how-does-layer-2-work-title": "How does layer 2 work?",
+ "layer-2-how-does-layer-2-work-1": "As we mentioned above, Layer 2 is a collective term for Ethereum scaling solutions that handle transactions off Ethereum layer 1 while still taking advantage of the robust decentralized security of Ethereum layer 1. A layer 2 is a separate blockchain that extends Ethereum. How does that work?",
+ "layer-2-how-does-layer-2-work-2": "A layer 2 blockchain regularly communicates with Ethereum (by submitting bundles of transactions) in order to ensure it has similar security and decentralization guarantees. All this requires no changes to the layer 1 protocol (Ethereum). This lets layer 1 handle security, data availability, and decentralization, while layer 2s handles scaling. Layer 2s take the transactional burden away from the layer 1 and post finalized proofs back to the layer 1. By removing this transaction load from layer 1, the base layer becomes less congested, and everything becomes more scalable.",
+ "layer-2-rollups-title": "Rollups",
+ "layer-2-rollups-1": "Rollups are currently the preferred layer 2 solution for scaling Ethereum. By using rollups, users can reduce gas fees by up to 100x compared to layer 1.",
+ "layer-2-rollups-2": "Rollups bundle (or ’roll up’) hundreds of transactions into a single transaction on layer 1. This distributes the L1 transaction fees across everyone in the rollup, making it cheaper for each user. Rollup transactions get executed outside of layer 1 but the transaction data gets posted to layer 1. By posting transaction data onto layer 1, rollups inherit the security of Ethereum. There are two different approaches to rollups: optimistic and zero-knowledge - they differ primarily on how this transaction data is posted to L1.",
+ "layer-2-optimistic-rollups-title": "Optimistic rollups",
+ "layer-2-optimistic-rollups-description": "Optimistic rollups are 'optimistic' in the sense that transactions are assumed to be valid, but can be challenged if necessary. If an invalid transaction is suspected, a fault proof is ran to see if this has taken place.",
+ "layer-2-optimistic-rollups-childSentance": "More on optimistic rollups",
+ "layer-2-zk-rollups-title": "Zero-knowledge rollups",
+ "layer-2-zk-rollups-description": "Zero-knowledge rollups use validity proofs where transactions are computed off-chain, and then compressed data is supplied to Ethereum Mainnet as a proof of their validity.",
+ "layer-2-zk-rollups-childSentance": "More on zk-rollups",
+ "layer-2-dyor-title": "Do your own research: risks of layer 2",
+ "layer-2-dyor-1": "Since layer 2 chains inherit security from Ethereum, in an ideal world, they are as safe as L1 Ethereum. However, many of the projects are still young and somewhat experimental. After years of research and development, many of the L2 technologies that will scale Ethereum launched in 2021. Many projects still have additional trust assumptions as they work to decentralize their networks. Always do your own research to decide if you're comfortable with any risks involved.",
+ "layer-2-dyor-2": "For more information on the technology, risks, and trust assumptions of layer 2s, we recommend checking out L2BEAT, which provides a comprehensive risk assessment framework of each project.",
+ "layer-2-dyor-3": "Go to L2BEAT"
}
diff --git a/src/pages/layer-2.js b/src/pages/layer-2.js
index 044eeb68729..d5a29aca720 100644
--- a/src/pages/layer-2.js
+++ b/src/pages/layer-2.js
@@ -253,19 +253,18 @@ const Layer2Page = ({ data }) => {
}, [])
const heroContent = {
- title: "Layer 2",
- header: "Ethereum for everyone",
- subtitle:
- "Scaling Ethereum without compromising on security or decentralization.",
+ title: translateMessageId("layer-2-hero-title", intl),
+ header: translateMessageId("layer-2-hero-header", intl),
+ subtitle: translateMessageId("layer-2-hero-subtitle", intl),
image: getImage(data.heroImage),
- alt: "test",
+ alt: translateMessageId("layer-2-hero-alt-text", intl),
buttons: [
{
- content: "What is layer 2",
+ content: translateMessageId("layer-2-hero-button-1", intl),
pathId: "what-is-layer-2",
},
{
- content: "Use layer 2",
+ content: translateMessageId("layer-2-hero-button-2", intl),
pathId: "use-layer-2",
isSecondary: "isSecondary",
},
@@ -275,40 +274,49 @@ const Layer2Page = ({ data }) => {
const layer2Cards = [
{
emoji: ":money_with_wings:",
- title: "Lower fees",
- description:
- "By combining multiple off-chain transactions into a single layer 1 transaction, transaction fees are massively reduced, making Ethereum more accessible for all.",
+ title: translateMessageId("layer-2-lower-fees-title", intl),
+ description: translateMessageId("layer-2-lower-fees-description", intl),
},
{
emoji: ":closed_lock_with_key:",
- className: "security-card",
- title: "Maintain security",
- description:
- "Layer 2 blockchains settle their transactions on Ethereum Mainnet, allowing users to benefit from the security of the Ethereum network.",
+ title: translateMessageId("layer-2-maintain-security-title", intl),
+ description: translateMessageId(
+ "layer-2-maintain-security-description",
+ intl
+ ),
},
{
emoji: ":hammer_and_wrench:",
- title: "Expand use cases",
- description:
- "With higher transactions per second, lower fees, and new technology, projects will expand into new applications with improved user experience.",
+ title: translateMessageId("layer-2-expand-use-cases-title", intl),
+ description: translateMessageId(
+ "layer-2-expand-use-cases-description",
+ intl
+ ),
},
]
const rollupCards = [
{
image: getImage(data.optimisticRollup),
- title: "Optimistic rollups",
- description:
- "Optimistic rollups are 'optimistic' in the sense that transactions are assumed to be valid, but can be challenged if necessary. If an invalid transaction is suspected, a fault proof is ran to see if this has taken place.",
- childSentence: "More on optimistic rollups",
+ title: translateMessageId("layer-2-optimistic-rollups-title", intl),
+ description: translateMessageId(
+ "layer-2-optimistic-rollups-description",
+ intl
+ ),
+ childSentence: translateMessageId(
+ "layer-2-optimistic-rollups-childSentance",
+ intl
+ ),
childLink: "/developers/docs/scaling/optimistic-rollups/",
},
{
image: getImage(data.zkRollup),
- title: "Zero-knowledge rollups",
- description:
- "Zero-knowledge rollups use validity proofs where transactions are computed off-chain, and then compressed data is supplied to Ethereum Mainnet as a proof of their validity.",
- childSentence: "More on zk-rollups",
+ title: translateMessageId("layer-2-zk-rollups-title", intl),
+ description: translateMessageId("layer-2-zk-rollups-description", intl),
+ childSentence: translateMessageId(
+ "layer-2-zk-rollups-childSentance",
+ intl
+ ),
childLink: "/developers/docs/scaling/zk-rollups/",
},
]
@@ -394,7 +402,9 @@ const Layer2Page = ({ data }) => {
{tvl}
- TVL locked in layer 2 (USD)
+
+
+ {
{averageFee}
- Average layer 2 ETH transfer fee (USD)
+ {
{percentChangeL2}
- Layer 2 TVL change (30 days)
+
+
+ {
-
What is layer 2?
+
+
+
- Layer 2 (L2) is a collective term to describe a specific set of
- Ethereum scaling solutions.{" "}
-
- A layer 2 is separate blockchain that extends Ethereum and
- inherits the security guarantees of Ethereum
-
- .
+
- Now let’s dig into it a bit more, and to do this we need to
- explain layer 1 (L1).
+
- Layer 1 is the base blockchain. Ethereum and Bitcoin are both
- layer 1 blockchains because they are the{" "}
-
- underlying foundation that various layer 2 networks build on top
- of
-
- . Examples of layer 2 projects include "rollups" on Ethereum and
- the Lighting Network on top of Bitcoin. All user transaction
- activity on these layer 2 projects can ultimately settle back to
- the layer 1 blockchain.
+
- Ethereum also functions as a data availability layer for layer 2s.
- Layer 2 projects will post their transaction data onto Ethereum,
- relying on Ethereum for data availability. This data can be used
- to get the state of the layer 2, or to dispute transactions on
- layer 2.
+
- {/* TODO: Convert these inline styles into styled components */}
- Ethereum as the layer 1 includes:
+
- A network of node operators to secure and validate the
- network
+
,
- A network of block producers
+
,
- The blockchain itself and the history of transaction
- data
+
,
- The consensus mechanism for the network
+
,
]}
/>
- Still confused on Ethereum?{" "}
- Learn what Ethereum is.
+ {" "}
+
+
+
- Three desirable properties of a blockchain are that it is{" "}
- decentralized, secure, and scalable. The{" "}
-
- blockchain trilemma
- {" "}
- states that a simple blockchain architecture can only achieve two
- out of three. Want a secure and decentralized blockchain? You need
- to sacrifice scalability.
+
- Ethereum has reached the network's current capacity with{" "}
-
- 1+ million transactions per day
-
- and high demand for each of these transactions. The success of
- Ethereum and the demand to use it has caused gas prices to rise
- substantially. Therefore the{" "}
-
- need for scaling solutions
- {" "}
- has increased in demand as well. This is where layer 2 networks
- come in.
+
-
Scalability
+
+
+
- The main goal of scalability is to increase transaction speed
- (faster finality) and transaction throughput (higher transactions
- per second) without sacrificing decentralization or security.
+
- The Ethereum community has taken a strong stance that it would not
- throw out decentralization or security in order to scale. Until{" "}
- sharding, Ethereum Mainnet
- (layer 1) is only able to process{" "}
-
- roughly 15 transactions per second
-
- . When demand to use Ethereum is high, the network becomes
- congested, which increases transaction fees and prices out users
- who cannot afford those fees. That is where layer 2 comes in to
- scale Ethereum today.
+
- As we mentioned above, Layer 2 is a collective term for Ethereum
- scaling solutions that handle transactions off Ethereum layer 1
- while still taking advantage of the robust decentralized security
- of Ethereum layer 1.{" "}
- A layer 2 is a separate blockchain that extends Ethereum.
- How does that work?
+
- A layer 2 blockchain regularly communicates with Ethereum (by
- submitting bundles of transactions) in order to ensure it has
- similar security and decentralization guarantees. All this
- requires no changes to the layer 1 protocol (Ethereum). This lets
- layer 1 handle security, data availability, and decentralization,
- while layer 2s handles scaling. Layer 2s take the transactional
- burden away from the layer 1 and post finalized proofs back to the
- layer 1. By removing this transaction load from layer 1, the base
- layer becomes less congested, and everything becomes more
- scalable.
+
-
Rollups
+
+
+
- Rollups are currently the preferred layer 2 solution for scaling
- Ethereum. By using rollups, users can{" "}
-
- reduce gas fees by up to 100x
- {" "}
- compared to layer 1.
+
- Rollups bundle (or ’roll up’) hundreds of transactions into a
- single transaction on layer 1. This distributes the L1 transaction
- fees across everyone in the rollup, making it cheaper for each
- user. Rollup transactions get executed outside of layer 1 but the
- transaction data gets posted to layer 1. By posting transaction
- data onto layer 1, rollups inherit the security of Ethereum. There
- are two different approaches to rollups: optimistic and
- zero-knowledge - they differ primarily on how this transaction
- data is posted to L1.
+
- {/* TODO: Convert these inline styles into styled components */}
{
-
Do your own research: risks of layer 2
+
+
+
- Since layer 2 chains inherit security from Ethereum, in an ideal
- world, they are as safe as L1 Ethereum. However, many of the{" "}
- projects are still young and somewhat experimental. After
- years of research and development, many of the L2 technologies that
- will scale Ethereum launched in 2021. Many projects still have
- additional trust assumptions as they work to decentralize their
- networks. Always do your own research to decide if you're
- comfortable with any risks involved.
+
- For more information on the technology, risks, and trust assumptions
- of layer 2s, we recommend checking out L2BEAT, which provides a
- comprehensive risk assessment framework of each project.
+
- Go to L2BEAT
+
From 0ba7678d8ac73f2e4e62a5d9f94e27f57e7e830d Mon Sep 17 00:00:00 2001
From: Sam Richards
Date: Sun, 24 Apr 2022 20:49:32 +0200
Subject: [PATCH 003/298] Add basic open research page
---
src/content/community/get-involved/index.md | 2 ++
.../get-involved/open-research/index.md | 34 +++++++++++++++++++
2 files changed, 36 insertions(+)
create mode 100644 src/content/community/get-involved/open-research/index.md
diff --git a/src/content/community/get-involved/index.md b/src/content/community/get-involved/index.md
index 462438e102a..afb8bdedc7d 100644
--- a/src/content/community/get-involved/index.md
+++ b/src/content/community/get-involved/index.md
@@ -27,6 +27,8 @@ Do you have a background in mathematics, cryptography, or economics? You might b
- [Ethresear.ch](https://ethresear.ch) - Ethereum’s primary forum for research, and the world’s most influential forum for cryptoeconomics
- [Ecosystem Support Program's wishlist](https://esp.ethereum.foundation/wishlist/) - research areas where the Ethereum Ecosystem Support Program is actively seeking grant applications
+[Explore more active areas of research](/community/get-involved/open-research/).
+
## Non-technical skillsets {#non-technical}
If you’re not a developer, it can be hard to know where to start in Ethereum. Here are a few suggestions, along with resources for specific professional backgrounds.
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
new file mode 100644
index 00000000000..c9c0a2502d1
--- /dev/null
+++ b/src/content/community/get-involved/open-research/index.md
@@ -0,0 +1,34 @@
+---
+title: Active areas of Ethereum research
+description: Explore different areas of open research and learn how to get involved.
+sidebar: true
+lang: en
+---
+
+# Ethereum open areas of research
+
+Do you have a background in mathematics, cryptography, or economics? You might be interested in some of the cutting-edge work being done within the Ethereum ecosystem.
+
+TODOs
+
+- [x] Create basic page
+- [ ] Talk to researchers - what are the open questions? What are topics & resources?
+- [ ] Decide how topics should be categorized - what's the hierarchy?
+- [ ] Create
+- [ ] Create
+
+Derp derp derp
+
+List different categories of research...
+
+Protocol?
+e.g. various upgrades https://ethereum.org/en/upgrades/
+
+Cryptography?
+e.g. topics on https://cryptography-research.netlify.app/research
+
+Copied over from "get involved" section:
+
+- [Challenges.ethereum.org](https://challenges.ethereum.org/) - a series of high-value research bounties, where you can earn >$100,000 USD
+- [Ethresear.ch](https://ethresear.ch) - Ethereum’s primary forum for research, and the world’s most influential forum for cryptoeconomics
+- [Ecosystem Support Program's wishlist](https://esp.ethereum.foundation/wishlist/) - research areas where the Ethereum Ecosystem Support Program is actively seeking grant applications
From 277190bc48559dca377b587f67ff0c85e6e51d92 Mon Sep 17 00:00:00 2001
From: Sam Richards
Date: Sun, 1 May 2022 23:59:10 +0200
Subject: [PATCH 004/298] Add more high-level topic suggestions
---
.../get-involved/open-research/index.md | 59 ++++++++++++++++---
1 file changed, 50 insertions(+), 9 deletions(-)
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
index c9c0a2502d1..5ec80ea2a5e 100644
--- a/src/content/community/get-involved/open-research/index.md
+++ b/src/content/community/get-involved/open-research/index.md
@@ -9,26 +9,67 @@ lang: en
Do you have a background in mathematics, cryptography, or economics? You might be interested in some of the cutting-edge work being done within the Ethereum ecosystem.
-TODOs
+**TODOs**
- [x] Create basic page
- [ ] Talk to researchers - what are the open questions? What are topics & resources?
- [ ] Decide how topics should be categorized - what's the hierarchy?
-- [ ] Create
-- [ ] Create
-Derp derp derp
+## Community
+
+List general communities / resources for general topics?
+
+- [Ethresear.ch](https://ethresear.ch) - Ethereum’s primary forum for research
List different categories of research...
-Protocol?
+## Protocol
+
+Is this a valid category? What best captures these topics?
e.g. various upgrades https://ethereum.org/en/upgrades/
-Cryptography?
-e.g. topics on https://cryptography-research.netlify.app/research
+### Consensus
+
+Should this just be "proof-of-stake" at this point? Or other relevant areas of consensus research?
+
+Separate consensus layer & execution layer as top-level categories?
+
+Derp derp derp
+
+### Sharding
+
+Derp derp derp
+
+## Economics
+
+## Cryptography
+
+e.g. topics on https://crypto.ethereum.org/research
+
+### Hash Functions
-Copied over from "get involved" section:
+Derp derp derp
+
+### Polynomial and vector commitments
+
+Derp derp derp
+
+### Verifiable delay functions and random beacons
+
+Derp derp derp
+
+### Zero-Knowledge Proofs
+
+Derp derp derp
+
+## Layer 2
+
+## Privacy
+
+## Data Science
+
+Include miscellaneous places to find areas of opportunity/investment?
- [Challenges.ethereum.org](https://challenges.ethereum.org/) - a series of high-value research bounties, where you can earn >$100,000 USD
-- [Ethresear.ch](https://ethresear.ch) - Ethereum’s primary forum for research, and the world’s most influential forum for cryptoeconomics
+
- [Ecosystem Support Program's wishlist](https://esp.ethereum.foundation/wishlist/) - research areas where the Ethereum Ecosystem Support Program is actively seeking grant applications
From 3b6be0385dc22d4130c1fc62a50675367ee03241 Mon Sep 17 00:00:00 2001
From: Emmanuel Awosika <102589267+emmanuel-awosika@users.noreply.github.com>
Date: Mon, 9 May 2022 08:59:18 +0100
Subject: [PATCH 005/298] Update page on smart contract composability
The smart contract composability lacked detailed information, so I included new details that may be helpful to readers. This includes a more in-depth explanation of smart contract composability and why it matters for developers. The update also contains a new section on examples of composability in Ethereum, asides from the Uniswap example mentioned at the beginning.
---
.../smart-contracts/composability/index.md | 59 ++++++++++++++++++-
1 file changed, 58 insertions(+), 1 deletion(-)
diff --git a/src/content/developers/docs/smart-contracts/composability/index.md b/src/content/developers/docs/smart-contracts/composability/index.md
index 2baf422320c..cb01505bd90 100644
--- a/src/content/developers/docs/smart-contracts/composability/index.md
+++ b/src/content/developers/docs/smart-contracts/composability/index.md
@@ -8,7 +8,61 @@ incomplete: true
## A brief introduction {#a-brief-introduction}
-Smart contracts are public on Ethereum and can be thought of as open APIs. You don't need to write your own smart contract to become a dapp developer, you just need to know how to interact with them. For example, you can use the existing smart contracts of [Uniswap](https://uniswap.exchange/swap), a decentralized exchange, to handle all the token swap logic in your app – you don't need to start from scratch. Check out some of their [v2](https://github.com/Uniswap/uniswap-v2-core/tree/master/contracts) and [v3](https://github.com/Uniswap/uniswap-v3-core/tree/main/contracts) contracts.
+Smart contracts are public on Ethereum and can be thought of as open APIs. You don't need to write your own smart contract to become a dapp developer, you just need to know how to interact with them.
+
+For example, you can use the existing smart contracts of [Uniswap](https://uniswap.exchange/swap), a decentralized exchange, to handle all the token swap logic in your app – you don't need to start from scratch. Check out some of their [v2](https://github.com/Uniswap/uniswap-v2-core/tree/master/contracts) and [v3](https://github.com/Uniswap/uniswap-v3-core/tree/main/contracts) contracts.
+
+## What is composability? {#what-is-composability}
+
+Composability is the idea that distinct components can be integrated or combined to create new systems or outputs. In the context of blockchain development, composability means existing pieces of software can be reused to build new applications.
+
+A good way to understand composability is to think of composable elements as Lego blocks. Each Lego is designed to fit into another, such that you can build complex structures by combining different Lego blocks.
+
+In Ethereum, every smart contract is a Lego of sorts—you can use smart contracts from other projects as building blocks for your project. This means you don't have to spend time reinventing the wheel or building from scratch.
+
+## How does composability work? {#how-does-composability-work}
+
+As we said in the beginning, Ethereum smart contracts are like public APIs. This means anyone can interact with them or integrate them into dapps for added functionality.
+
+Smart contract composability generally works off three principles: modularity, autonomy, and discoverability:
+
+**1. Modularity**: This is the ability of individual components to perform a specific task. In Ethereum, every smart contract has specific use-case (as shown in the Uniswap example).
+
+**2. Autonomy**: Composable components must be able to operate independently. Each smart contract in Ethereum is self-executing and can function without relying on other parts of the system.
+
+**3. Discoverability**: Developers cannot call external contracts or integrate software libraries into applications if the former are not publicly available. By design, smart contracts are open-source; anyone can call a smart contract or fork a codebase.
+
+## Benefits of composability {#benefits-of-composability}
+
+### Shorter development cycle
+
+Composability reduces the work that developers have to do when creating [decentralized applications](https://ethereum.org/en/dapps/#what-are-dapps) (dapps). As Naval Ravikant [puts it](https://twitter.com/naval/status/1444366754650656770): "Open source means every problem has to be solved once."
+
+Once a particular smart contract solves one problem, other developers can reuse it, so they don’t have to solve the same problem. In this way, developers can take existing software libraries and add extra functionality to create new dapps.
+
+### Greater innovation
+
+Composability encourages innovation and experimentation. That’s because developers are free to reuse, modify, duplicate, or integrate open-source code to create desired results.
+
+Also, development teams spend less time on basic functionality and can allocate more time to experimenting with new features. This explains why there are so many great projects in the Ethereum ecosystem today—developers can focus on improve on existing dapps and build better products.
+
+### Better user experience
+
+Interoperability between components of the Ethereum ecosystem improves the user experience. Users can access greater functionality when dapps integrate external smart contracts than in a fragmented ecosystem where applications cannot communicate.
+
+## Examples of composability in Ethereum {#composability-in-ethereum}
+
+### Token swaps
+
+Say you have a dapp that requires to pay for transactions in ETH. You can add more payment options by integrating token swap logic from Uniswap contracts. This code will automatically convert the user’s token to ETH before the contract executes the called function.
+
+### Governance
+
+Building bespoke governance systems for a [decentralized autonomous organization](https://ethereum.org/en/dao/) (DAO) can be expensive and time-consuming. However, you can use [Aragon Client](https://client.aragon.org/)—an open-source governance toolkit from Aragon—to bootstrap your DAO and quickly create a usable governance framework.
+
+### Identity management
+
+Instead of building a custom authentication system or relying on centralized providers, you can integrate decentralized identity (DID) tools to manage authentication for users. An example is [SpruceID](https://www.spruceid.com/), an open-source toolkit which offers a "Sign in with Ethereum" functionality that lets users authenticate identities with an Ethereum wallet.
## Related tutorials {#related-tutorials}
@@ -20,3 +74,6 @@ Smart contracts are public on Ethereum and can be thought of as open APIs. You d
_Know of a community resource that helped you? Edit this page and add it!_
- [Composability is Innovation](https://future.a16z.com/how-composability-unlocks-crypto-and-everything-else/)
+- [Why Composability Matters For Web3](https://hackernoon.com/why-composability-matters-for-web3)
+- [What is Composability?](https://blog.aragon.org/what-is-composability/#:~:text=Aragon,connect%20to%20every%20other%20piece.)
+
From a5892c32b0f3fb2c720e91d63aa4f69eab2eea1d Mon Sep 17 00:00:00 2001
From: Emmanuel Awosika <102589267+emmanuel-awosika@users.noreply.github.com>
Date: Tue, 10 May 2022 14:47:03 +0100
Subject: [PATCH 006/298] Apply suggestions from code review
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.../smart-contracts/composability/index.md | 25 +++++++------------
1 file changed, 9 insertions(+), 16 deletions(-)
diff --git a/src/content/developers/docs/smart-contracts/composability/index.md b/src/content/developers/docs/smart-contracts/composability/index.md
index cb01505bd90..36017173c27 100644
--- a/src/content/developers/docs/smart-contracts/composability/index.md
+++ b/src/content/developers/docs/smart-contracts/composability/index.md
@@ -8,23 +8,17 @@ incomplete: true
## A brief introduction {#a-brief-introduction}
-Smart contracts are public on Ethereum and can be thought of as open APIs. You don't need to write your own smart contract to become a dapp developer, you just need to know how to interact with them.
-
-For example, you can use the existing smart contracts of [Uniswap](https://uniswap.exchange/swap), a decentralized exchange, to handle all the token swap logic in your app – you don't need to start from scratch. Check out some of their [v2](https://github.com/Uniswap/uniswap-v2-core/tree/master/contracts) and [v3](https://github.com/Uniswap/uniswap-v3-core/tree/main/contracts) contracts.
+Smart contracts are public on Ethereum and can be thought of as open APIs. You don't need to write your own smart contract to become a dapp developer, you just need to know how to interact with them. For example, you can use the existing smart contracts of [Uniswap](https://uniswap.exchange/swap), a decentralized exchange, to handle all the token swap logic in your app – you don't need to start from scratch. Check out some of their [v2](https://github.com/Uniswap/uniswap-v2-core/tree/master/contracts) and [v3](https://github.com/Uniswap/uniswap-v3-core/tree/main/contracts) contracts.
## What is composability? {#what-is-composability}
-Composability is the idea that distinct components can be integrated or combined to create new systems or outputs. In the context of blockchain development, composability means existing pieces of software can be reused to build new applications.
-
-A good way to understand composability is to think of composable elements as Lego blocks. Each Lego is designed to fit into another, such that you can build complex structures by combining different Lego blocks.
+Composability is combing distinct components to create new systems or outputs. In software development, composability means developers can reuse existing software components to build new applications. A good way to understand composability is to think of composable elements as Lego blocks. Each Lego can be combined with another, allowing you to build complex structures by combining different Legos.
In Ethereum, every smart contract is a Lego of sorts—you can use smart contracts from other projects as building blocks for your project. This means you don't have to spend time reinventing the wheel or building from scratch.
## How does composability work? {#how-does-composability-work}
-As we said in the beginning, Ethereum smart contracts are like public APIs. This means anyone can interact with them or integrate them into dapps for added functionality.
-
-Smart contract composability generally works off three principles: modularity, autonomy, and discoverability:
+Ethereum smart contracts are like public APIs, so anyone can interact with the contract or integrate them into dapps for added functionality. Smart contract composability generally works off three principles: modularity, autonomy, and discoverability:
**1. Modularity**: This is the ability of individual components to perform a specific task. In Ethereum, every smart contract has specific use-case (as shown in the Uniswap example).
@@ -34,17 +28,16 @@ Smart contract composability generally works off three principles: modularity, a
## Benefits of composability {#benefits-of-composability}
-### Shorter development cycle
+### Shorter development cycle {#shorter-development-cycle}
-Composability reduces the work that developers have to do when creating [decentralized applications](https://ethereum.org/en/dapps/#what-are-dapps) (dapps). As Naval Ravikant [puts it](https://twitter.com/naval/status/1444366754650656770): "Open source means every problem has to be solved once."
+Composability reduces the work that developers have to do when creating [dapps](/dapps/#what-are-dapps). [As Naval Ravikant puts it:](https://twitter.com/naval/status/1444366754650656770) "Open source means every problem has to be solved once."
-Once a particular smart contract solves one problem, other developers can reuse it, so they don’t have to solve the same problem. In this way, developers can take existing software libraries and add extra functionality to create new dapps.
+If there is a smart contract that solves one problem, other developers can reuse it, so they don’t have to solve the same problem. This way, developers can take existing software libraries and add extra functionality to create new dapps.
### Greater innovation
-Composability encourages innovation and experimentation. That’s because developers are free to reuse, modify, duplicate, or integrate open-source code to create desired results.
+Composability encourages innovation and experimentation because developers are free to reuse, modify, duplicate, or integrate open-source code to create desired results. As a result, development teams spend less time on basic functionality and can allocate more time experimenting with new features.
-Also, development teams spend less time on basic functionality and can allocate more time to experimenting with new features. This explains why there are so many great projects in the Ethereum ecosystem today—developers can focus on improve on existing dapps and build better products.
### Better user experience
@@ -54,11 +47,11 @@ Interoperability between components of the Ethereum ecosystem improves the user
### Token swaps
-Say you have a dapp that requires to pay for transactions in ETH. You can add more payment options by integrating token swap logic from Uniswap contracts. This code will automatically convert the user’s token to ETH before the contract executes the called function.
+If you create a dapp that requires transactions to be paid in ETH, you can allow users to pay in other ERC-20 tokens by integrating token swap logic. The code will automatically convert the user’s token to ETH before the contract executes the called function.
### Governance
-Building bespoke governance systems for a [decentralized autonomous organization](https://ethereum.org/en/dao/) (DAO) can be expensive and time-consuming. However, you can use [Aragon Client](https://client.aragon.org/)—an open-source governance toolkit from Aragon—to bootstrap your DAO and quickly create a usable governance framework.
+Building bespoke governance systems for a [DAO](/dao/) can be expensive and time-consuming. Instead, you could use an open-source governance toolkit, such as [Aragon Client](https://client.aragon.org/), to bootstrap your DAO to quickly create a governance framework.
### Identity management
From 013d2ca3e4ee82326e9600a41acc7da574e58bd3 Mon Sep 17 00:00:00 2001
From: Emmanuel Awosika <102589267+emmanuel-awosika@users.noreply.github.com>
Date: Tue, 10 May 2022 14:51:22 +0100
Subject: [PATCH 007/298] Update index.md
Added header IDs and fixed some typos.
---
.../docs/smart-contracts/composability/index.md | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/src/content/developers/docs/smart-contracts/composability/index.md b/src/content/developers/docs/smart-contracts/composability/index.md
index 36017173c27..f1b12a38a83 100644
--- a/src/content/developers/docs/smart-contracts/composability/index.md
+++ b/src/content/developers/docs/smart-contracts/composability/index.md
@@ -12,7 +12,7 @@ Smart contracts are public on Ethereum and can be thought of as open APIs. You d
## What is composability? {#what-is-composability}
-Composability is combing distinct components to create new systems or outputs. In software development, composability means developers can reuse existing software components to build new applications. A good way to understand composability is to think of composable elements as Lego blocks. Each Lego can be combined with another, allowing you to build complex structures by combining different Legos.
+Composability is combining distinct components to create new systems or outputs. In software development, composability means developers can reuse existing software components to build new applications. A good way to understand composability is to think of composable elements as Lego blocks. Each Lego can be combined with another, allowing you to build complex structures by combining different Legos.
In Ethereum, every smart contract is a Lego of sorts—you can use smart contracts from other projects as building blocks for your project. This means you don't have to spend time reinventing the wheel or building from scratch.
@@ -34,26 +34,26 @@ Composability reduces the work that developers have to do when creating [dapps](
If there is a smart contract that solves one problem, other developers can reuse it, so they don’t have to solve the same problem. This way, developers can take existing software libraries and add extra functionality to create new dapps.
-### Greater innovation
+### Greater innovation {#greater-innovation}
Composability encourages innovation and experimentation because developers are free to reuse, modify, duplicate, or integrate open-source code to create desired results. As a result, development teams spend less time on basic functionality and can allocate more time experimenting with new features.
-### Better user experience
+### Better user experience {#better-user-experience}
Interoperability between components of the Ethereum ecosystem improves the user experience. Users can access greater functionality when dapps integrate external smart contracts than in a fragmented ecosystem where applications cannot communicate.
## Examples of composability in Ethereum {#composability-in-ethereum}
-### Token swaps
+### Token swaps {#token-swaps}
If you create a dapp that requires transactions to be paid in ETH, you can allow users to pay in other ERC-20 tokens by integrating token swap logic. The code will automatically convert the user’s token to ETH before the contract executes the called function.
-### Governance
+### Governance {#governance}
Building bespoke governance systems for a [DAO](/dao/) can be expensive and time-consuming. Instead, you could use an open-source governance toolkit, such as [Aragon Client](https://client.aragon.org/), to bootstrap your DAO to quickly create a governance framework.
-### Identity management
+### Identity management {#identity-management}
Instead of building a custom authentication system or relying on centralized providers, you can integrate decentralized identity (DID) tools to manage authentication for users. An example is [SpruceID](https://www.spruceid.com/), an open-source toolkit which offers a "Sign in with Ethereum" functionality that lets users authenticate identities with an Ethereum wallet.
From 4efc4611262f1d36a6ff7cf12d2a5897135770b3 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 10 May 2022 12:06:08 -0600
Subject: [PATCH 008/298] bridges for developers page
---
src/content/developers/docs/bridges/index.md | 114 +++++++++++++++++++
src/data/developer-docs-links.yaml | 3 +
src/intl/en/page-developers-docs.json | 2 +
3 files changed, 119 insertions(+)
create mode 100644 src/content/developers/docs/bridges/index.md
diff --git a/src/content/developers/docs/bridges/index.md b/src/content/developers/docs/bridges/index.md
new file mode 100644
index 00000000000..d058cd11e08
--- /dev/null
+++ b/src/content/developers/docs/bridges/index.md
@@ -0,0 +1,114 @@
+---
+title: Bridges
+description: An overview of the different kind of bridging
+lang: en
+sidebar: true
+---
+
+With the proliferation of L1 blockchains and L2 [scaling](/developers/docs/scaling/) solutions, alongside an ever-growing number of decentralized applications going cross-chain, the need for communication and asset movement across chains has never been more important.
+
+This is where blockchain bridges come in.
+
+## Need for bridges {#need-for-bridges}
+
+Bridges exist to connect blockchain networks. They enable connectivity and interoperability between blockchains.
+
+Blockchains exist in siloed environments, meaning there is no way for blockchains to trade and communicate with other blockchains naturally. As a result, while there could be significant activity and innovation within an ecosystem, it is limited by the lack of connectivity and interoperability with other ecosystems.
+
+Bridges offer a way for isolated blockchain environments to connect with each other. They establish a transportation route between blockchains where tokens, messages, arbitrary data, and even [smart contract](/developers/docs/smart-contracts/) calls can be transferred from one chain to another.
+
+## Benefits of bridges {#benefits-of-bridges}
+
+Put simply, bridges unlock developer potential by allowing blockchain networks to exchange data and move assets between them.
+
+Different blockchains and communities have unique strengths, weaknesses, and approaches to building applications (such as speed, throughput, costliness, etc.). Bridges help the development of the overall crypto ecosystem by enabling blockchains to leverage the innovations of each other.
+
+Moreover, bridges unlock new use cases and possibilities for both users and developers. For example, users can now move assets across different ecosystems, making them more productive. For developers and protocols, bridges open up an almost limitless amount of possibilities by expanding the design space for [dApps](/developers/docs/dapps/) across multiple crypto ecosystems.
+
+## How do bridges work? {#how-do-bridges-work}
+
+While there are many [types of bridge designs](https://blog.li.fi/what-are-blockchain-bridges-and-how-can-we-classify-them-560dc6ec05fa), three ways to facilitate the cross-chain transfer of assets stand out:
+
+- **Lock and Mint –** Lock assets on the source chain and mint assets on the destination chain.
+- **Burn and Mint –** Burn assets on the source chain and mint assets on the destination chain.
+- **Atomic Swaps –** Swap assets on the source chain for assets on the destination chain.
+
+## Bridge types {#bridge-types}
+
+Bridges come in different types and flavors. Broadly, bridges can usually be classified into one of the following buckets:
+
+- **Native Bridges –** These bridges are typically built to bootstrap liquidity on a particular blockchain, making it easier for users to move funds to the ecosystem. For example, the Avalanche Bridge is built to make it convenient for users to bridge from [Ethereum](/developers/docs/intro-to-ethereum/) to Avalanche. Other such bridges include Polygon PoS Bridge, Arbitrum Bridge, etc.
+- **Validator or Oracle Based Bridges –** These bridges rely on an external validator set or oracles to validate cross-chain transfers. Examples: Multichain and Across.
+- **Generalized Message Passing Bridges –** These bridges can transfer assets, along with messages and arbitrary data across chains. Examples: Nomad and LayerZero.
+- **Liquidity Networks –** These bridges primarily focus on transferring assets from one chain to another via atomic swaps. Generally, they don’t support cross-chain message passing. Examples: Connext and Hop.
+
+## Evolution of bridges {#evolution-of-bridges}
+
+With bridges, there are no perfect solutions. Rather, there are only trade-offs made to fulfill a purpose. Developers and users can evaluate bridges based on the following factors:
+
+- **Security –** Who verifies the system? Bridges secured by external validators are typically less secure than bridges that are locally or natively secured by the blockchain’s validators.
+- **Convenience –** How long does it take to complete a transaction, and how many transactions did a user need to sign? For a developer, how long does it take to integrate a bridge, and how complex is the process?
+- **Connectivity –** What are the different destination chains a bridge can connect (i.e., rollups, sidechains, other layer 1 blockchains, etc.), and how hard is it to integrate a new blockchain?
+- **Ability to pass more complex data –** Can a bridge enable the transfer of messages and more complex arbitrary data across chains, or does it only support cross-chain asset transfers?
+- **Cost-Effectiveness –** How much does it cost to transfer assets across chains via a bridge? Typically, bridges charge a fixed or variable fee depending on gas costs and the liquidity of specific routes. It is also critical to evaluate the cost-effectiveness of a bridge based on the capital required to ensure its security.
+
+At a high level, bridges can be categorized as trusted and trustless.
+
+- **Trusted –** Trusted bridges are externally verified. They use an external set of verifiers (Federations with multi-sig, multi-party computation systems, oracle network) to send data across chains. As a result, they can offer great connectivity and enable fully generalized message passing across chains. They also tend to perform well with speed and cost-effectiveness. This comes at the cost of security, as users have to rely on the security of the bridge.
+- **Trustless –** These bridges rely on the blockchains they are connecting and their validators to transfer messages and tokens. They are 'trustless' because they do not add new trust assumptions (in addition to the blockchains). As a result, trustless bridges are considered to be more secure than trusted bridges. To evaluate trustless bridges based on other factors, we must break them down into generalized message passing bridges and liquidity networks.
+ - **Generalized Message Passing Bridges –** These bridges excel with security and the ability to transfer more complex data across chains. Typically, they are also good with cost-effectiveness. However, these strengths generally come at the cost of connectivity for light client bridges (ex: IBC) and speed drawbacks for optimistic bridges (ex: Nomad) that use fraud proofs.
+ - **Liquidity Networks –** These bridges use atomic swaps for transferring assets and are locally verified systems (i.e., they use the underlying blockchains’ validators to verify transactions). As a result, they excel with security and speed. Moreover, they are considered comparatively cost-effective and offer good connectivity. However, the major tradeoff is their ability to pass more complex data – as they don’t support cross-chain message passing.
+
+## Risk with bridges {#risk-with-bridges}
+
+Bridges account for the top 3 [biggest hacks in DeFi](https://rekt.news/leaderboard/) and are still in the early stages of development. Using any bridge carries the following risks:
+
+- **Smart Contract Risk –** While many bridges have successfully passed audits, all it takes is one flaw in a smart contract for assets to be exposed to hacks (ex: [Solana’s Wormhole Bridge](https://rekt.news/wormhole-rekt/)).
+- **Technology Risk –** Given the complexity of bridge operations, there is a possibility of technology risks like software failure, buggy code, human error, spam, and malicious attacks.
+- **Systematic Financial Risks** – Many bridges use wrapped assets to mint canonical versions of the original asset on a new chain. This exposes the ecosystem to systematic risk, as we have seen wrapped versions of tokens exploited.
+- **Trusted Third-Party Risk –** Some bridges utilize a trusted design that requires users to rely on the assumption that validators will not collude to steal user funds. The need for users to trust these third-party actors exposes them to risks such as rugs, censorship, and other malicious activities.
+- **Open Issues –** Given that bridges are in the nascent stages of development, there are many unanswered questions related to how bridges will perform in different market conditions, like times of network congestion and during unforeseen events such as network-level attacks or state rollbacks. This uncertainty poses certain risks, the degree of which is still unknown.
+
+## How can dapps use bridges? {#how-can-dapps-use-bridges}
+
+Here are some practical applications that developers can consider about bridges and taking their dApp cross-chain:
+
+### Integrating bridges {#integrating-bridges}
+
+For developers, there are many ways to add support for bridges:
+
+1. **Building your own bridge –** Building a secure and reliable bridge is not easy, especially if you take a more trust-minimized route. Moreover, it requires years of experience and technical expertise related to scalability and interoperability studies. Additionally, it would require a hands-on team to maintain a bridge and attract sufficient liquidity to make it feasible.
+2. **Showing users multiple bridge options –** Many dApps require users to have their native token to interact with them. To enable users to access their tokens, they offer different bridge options on their website. However, this method is a quick fix to the problem as it takes the user away from the dApp interface and still requires them to interact with other dApps and bridges. This is a cumbersome onboarding experience with the increased scope of making mistakes.
+3. **Integrating a bridge –** This solution doesn’t require the dApp to send users to the external bridge and DEX interfaces. It allows dApps to improve the user onboarding experience. However, this approach has its limitations:
+ - Assessment and maintenance of bridges are hard and time-consuming.
+ - Selecting one bridge creates a single point of failure and dependency.
+ - The dApp is limited by the bridge’s capabilities.
+ - Bridges alone might not be enough. dApps might need DEXs to offer more functionality such as cross-chain swaps.
+4. **Integrating multiple bridges –** This solution solves many problems associated with integrating a single bridge. However, it also has limitations, as integrating multiple bridges is resource-consuming and creates technical and communication overheads for developers – the scarcest resource in crypto.
+5. **Integrating a bridge aggregator –** Another option for dApps is integrating a bridge aggregation solution that gives them access to multiple bridges. Bridge aggregators inherit the strengths of all the bridges and thus are not limited by any single bridge’s capabilities. Notably, the bridge aggregators typically maintain the bridge integrations, which saves the dApp from the hassle of staying on top of the technical and operational aspects of a bridge integration.
+
+ That being said, bridge aggregators also have their limitations. For instance, while they can offer more bridge options, many more bridges are typically available in the market other than those offered on the aggregator's platform. Moreover, just like bridges, bridge aggregators are also exposed to smart contracts and technology risks (more smart contracts = more risks).
+
+If a dApp goes down the route of integrating a bridge or an aggregator, there are different options based on how deep the integration is meant to be. For instance, if it’s only a front-end integration to improve the user onboarding experience, a dApp would integrate the widget. However, if the integration is to explore deeper cross-chain strategies like staking, yield farming, etc., the dApp integrates the SDK or API.
+
+### Deploying a dapp on multiple chains {#deploying-a-dapp-on-multiple-chains}
+
+To deploy a dApp on multiple chains, developers can use development platforms like Alchemy, Hardhat, Truffle, etc. Typically, these platforms come with composable plugins that can enable dApps to go cross-chain. For instance, developers can use a deterministic deployment proxy offered by the hardhat-deploy plugin.
+
+### Monitoring contract activity across chains {#monitoring-contract-activity-across-chains}
+
+To monitor contract activity across chains, developers can use subgraphs and developer platforms like Tenderly to observe smart contracts in real-time. Such platforms also have tools that offer greater data monitoring functionality for cross-chain activities, such as checking for events emitted by contracts, etc.
+
+## Further reading {#further-reading}
+
+- [Blockchain Bridges](/en/bridges/) – ethereum.org
+- [Blockchain Bridges: Building Networks of Cryptonetworks](https://medium.com/1kxnetwork/blockchain-bridges-5db6afac44f8) Sep 8, 2021 – Dmitriy Berenzon
+- [The Interoperability Trilemma](https://blog.connext.network/the-interoperability-trilemma-657c2cf69f17) Oct 1, 2021 – Arjun Bhuptani
+- [Clusters: How Trusted & Trust-Minimized Bridges Shape the Multi-Chain Landscape](https://blog.celestia.org/clusters/) Oct 4, 2021 – Mustafa Al-Bassam
+- [LI.FI: With Bridges, Trust is a Spectrum](https://blog.li.fi/li-fi-with-bridges-trust-is-a-spectrum-354cd5a1a6d8) Apr 28, 2022 – Arjun Chand
+
+Additionally, here are some insightful presentations by [James Prestwich](https://twitter.com/_prestwich) that can help develop a deeper understanding of bridges:
+
+- [Building Bridges, Not Walled Gardens](https://youtu.be/ZQJWMiX4hT0)
+- [Breaking Down Bridges](https://youtu.be/b0mC-ZqN8Oo)
+- [Why are the Bridges Burning](https://youtu.be/c7cm2kd20j8)
diff --git a/src/data/developer-docs-links.yaml b/src/data/developer-docs-links.yaml
index 830784a452e..37309a5ed2f 100644
--- a/src/data/developer-docs-links.yaml
+++ b/src/data/developer-docs-links.yaml
@@ -149,6 +149,9 @@
- id: docs-nav-advanced
path: /developers/docs/
items:
+ - id: docs-nav-bridges
+ to: /developers/docs/bridges/
+ description: docs-nav-bridges-description
- id: docs-nav-standards
to: /developers/docs/standards/
description: docs-nav-standards-description
diff --git a/src/intl/en/page-developers-docs.json b/src/intl/en/page-developers-docs.json
index a8ba560e92d..dbbe1ffab30 100644
--- a/src/intl/en/page-developers-docs.json
+++ b/src/intl/en/page-developers-docs.json
@@ -6,6 +6,8 @@
"docs-nav-block-explorers": "Block explorers",
"docs-nav-blocks": "Blocks",
"docs-nav-blocks-description": "The way transactions are batched to ensure state is synchronised across all actors",
+ "docs-nav-bridges": "Bridges",
+ "docs-nav-bridges-description": "Bridges for developers",
"docs-nav-compiling-smart-contracts": "Compiling smart contracts",
"docs-nav-composability": "Composability",
"docs-nav-consensus-mechanisms": "Consensus mechanisms",
From c1b450c64cdc65d4cecbe9125298d764c92d88db Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 10 May 2022 12:06:27 -0600
Subject: [PATCH 009/298] change description
---
src/content/developers/docs/bridges/index.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/content/developers/docs/bridges/index.md b/src/content/developers/docs/bridges/index.md
index d058cd11e08..0332fd9c3d2 100644
--- a/src/content/developers/docs/bridges/index.md
+++ b/src/content/developers/docs/bridges/index.md
@@ -1,6 +1,6 @@
---
title: Bridges
-description: An overview of the different kind of bridging
+description: An overview of bridging for developers
lang: en
sidebar: true
---
From 25effd936134cdc9620147306caba8742814775d Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 10 May 2022 12:06:51 -0600
Subject: [PATCH 010/298] change description
---
src/intl/en/page-developers-docs.json | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/intl/en/page-developers-docs.json b/src/intl/en/page-developers-docs.json
index dbbe1ffab30..647b8d0a25f 100644
--- a/src/intl/en/page-developers-docs.json
+++ b/src/intl/en/page-developers-docs.json
@@ -7,7 +7,7 @@
"docs-nav-blocks": "Blocks",
"docs-nav-blocks-description": "The way transactions are batched to ensure state is synchronised across all actors",
"docs-nav-bridges": "Bridges",
- "docs-nav-bridges-description": "Bridges for developers",
+ "docs-nav-bridges-description": "An overview of bridging for developers",
"docs-nav-compiling-smart-contracts": "Compiling smart contracts",
"docs-nav-composability": "Composability",
"docs-nav-consensus-mechanisms": "Consensus mechanisms",
From 7c5ab192465922c5c5d383bbf4cf9bd707b19fb4 Mon Sep 17 00:00:00 2001
From: Paul Wackerow <54227730+wackerow@users.noreply.github.com>
Date: Thu, 12 May 2022 17:04:45 -0700
Subject: [PATCH 011/298] de Foundational docs import latest from Crowdin
---
.../de/developers/docs/accounts/index.md | 118 +++++++
.../de/developers/docs/blocks/index.md | 70 ++++
.../docs/consensus-mechanisms/index.md | 94 +++++
.../docs/consensus-mechanisms/pos/index.md | 98 ++++++
.../docs/consensus-mechanisms/pow/index.md | 112 ++++++
.../consensus-mechanisms/pow/mining/index.md | 77 +++++
.../de/developers/docs/dapps/index.md | 83 +++++
.../de/developers/docs/evm/index.md | 80 +++++
.../de/developers/docs/gas/index.md | 171 +++++++++
.../translations/de/developers/docs/index.md | 26 ++
.../developers/docs/intro-to-ether/index.md | 78 +++++
.../docs/intro-to-ethereum/index.md | 121 +++++++
.../de/developers/docs/networks/index.md | 129 +++++++
.../docs/nodes-and-clients/index.md | 324 ++++++++++++++++++
.../nodes-as-a-service/index.md | 218 ++++++++++++
.../nodes-and-clients/run-a-node/index.md | 166 +++++++++
.../de/developers/docs/transactions/index.md | 209 +++++++++++
.../de/developers/docs/web2-vs-web3/index.md | 62 ++++
src/intl/de/page-developers-docs.json | 53 ++-
19 files changed, 2282 insertions(+), 7 deletions(-)
create mode 100644 src/content/translations/de/developers/docs/accounts/index.md
create mode 100644 src/content/translations/de/developers/docs/blocks/index.md
create mode 100644 src/content/translations/de/developers/docs/consensus-mechanisms/index.md
create mode 100644 src/content/translations/de/developers/docs/consensus-mechanisms/pos/index.md
create mode 100644 src/content/translations/de/developers/docs/consensus-mechanisms/pow/index.md
create mode 100644 src/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/index.md
create mode 100644 src/content/translations/de/developers/docs/dapps/index.md
create mode 100644 src/content/translations/de/developers/docs/evm/index.md
create mode 100644 src/content/translations/de/developers/docs/gas/index.md
create mode 100644 src/content/translations/de/developers/docs/index.md
create mode 100644 src/content/translations/de/developers/docs/intro-to-ether/index.md
create mode 100644 src/content/translations/de/developers/docs/intro-to-ethereum/index.md
create mode 100644 src/content/translations/de/developers/docs/networks/index.md
create mode 100644 src/content/translations/de/developers/docs/nodes-and-clients/index.md
create mode 100644 src/content/translations/de/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
create mode 100644 src/content/translations/de/developers/docs/nodes-and-clients/run-a-node/index.md
create mode 100644 src/content/translations/de/developers/docs/transactions/index.md
create mode 100644 src/content/translations/de/developers/docs/web2-vs-web3/index.md
diff --git a/src/content/translations/de/developers/docs/accounts/index.md b/src/content/translations/de/developers/docs/accounts/index.md
new file mode 100644
index 00000000000..c6a1f67f29b
--- /dev/null
+++ b/src/content/translations/de/developers/docs/accounts/index.md
@@ -0,0 +1,118 @@
+---
+title: Ethereum-Konten
+description: Eine Erklärung der Ethereum-Konten – ihre Datenstrukturen und ihre Beziehung zur Schlüsselpaar-Kryptografie.
+lang: de
+sidebar: true
+---
+
+Ein Ethereum-Konto ist eine Entität mit einem Ether(ETH)-Guthaben, welche Transaktionen bei Ethereum durchführen kann. Konten können benutzerkontrolliert oder als intelligenter Vertrag bereitgestellt werden.
+
+## Voraussetzungen {#prerequisites}
+
+Konten sind ein sehr anfängerfreundliches Thema. Um dir jedoch zu helfen, diese Seite besser zu verstehen, empfehlen wir dir, zuerst unsere [Einführung in Ethereum](/developers/docs/intro-to-ethereum/) zu lesen.
+
+## Kontotypen {#types-of-account}
+
+Ethereum hat zwei Kontotypen:
+
+- Externer Besitz – kontrolliert von jedem mit den privaten Schlüsseln
+- Vertrag – ein intelligenter Vertag, der im Neztwerk bereitgestellt und über einen Code gesteuert wird. Erfahre mehr über [intelligente Verträge](/developers/docs/smart-contracts/).
+
+Beide Kontotypen haben die Möglichkeit
+
+- ETH und Token zu empfangen, zu halten und zu versenden,
+- mit bereitgestellten, intelligenten Verträgen zu interagieren.
+
+### Wesentliche Unterschiede {#key-differences}
+
+**Externer Besitz**
+
+- Die Erstellung eines Kontos ist kostenlos.
+- Kann Transaktionen initiieren
+- Transaktionen zwischen fremden Konten können nur ETH/Token-Transfers sein.
+
+**Vertrag**
+
+- Die Erstellung eines Vertrags ist mit Kosten verbunden, da diese Netzwerkspeicher verwenden.
+- Transaktionen können nur als Antwort auf den Erhalt einer Transaktion gesendet werden.
+- Transaktionen von einem externen Konto auf ein Vertragskonto können einen Code auslösen, der viele verschiedene Aktionen ausführt, z. B. die Übertragung von Token oder sogar die Erstellung eines neuen Vertrags.
+
+## Analyse eines Kontos {#an-account-examined}
+
+Ethereum-Konten haben vier Bereiche:
+
+- `Nonce` – einen Zähler, der die Anzahl an Transaktionen angibt, die vom Konto gesendet wurden. Dies stellt sicher, dass Transaktionen nur einmal verarbeitet werden. Bei einem Vertragskonto steht diese Zahl für die Anzahl der Verträge, die durch das Konto erstellt wurden.
+- `Balance` – die Anzahl von wei, die diese Adresse besitzt. Wei ist eine Stückelung der ETH und es gibt 1e+18 wei pro ETH.
+- `codeHash` – Dieser Hash bezieht sich auf den _code_ eines Kontos auf der Ethereum Virtual Machine (EVM). In Vertragskonten sind Codefragmente einprogrammiert, die verschiedene Operationen ausführen können. Dieser EVM-Code wird ausgeführt, wenn das Konto einen Nachrichtenaufruf erhält. Er kann im Gegensatz zu den anderen Kontofeldern nicht geändert werden. Alle diese Codefragmente werden in der Zustandsdatenbank unter den entsprechenden Hashes gespeichert und können später abgerufen werden. Dieser Hash-Wert wird als codeHash bezeichnet. Bei externen Konten ist das Feld codeHash der Hash einer leeren Zeichenfolge.
+- `StorageRoot` – manchmal auch bekannt als Speicher-Hash. Ein 256-Bit-Hash des Wurzelknotens eines Merkle-Patricia-Tries, der den Speicherinhalt des Kontos codiert (eine Zuordnung zwischen 256-Bit-Integer-Werten), codiert in den Trie als eine Zuordnung vom Keccak-256-Bit-Hash der 256-Bit-Integer-Schlüssel zu den RLP-codierten 256-Bit-Integer-Werten. Dieser Trie kodiert den Hash des Speicherinhalts dieses Kontos und ist standardmäßig leer.
+
+![Ein Diagramm, das die Funktionsweise eines Kontos zeigt](./accounts.png) _Diagramm angepasst von [Ethereum EVM illustriert](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+
+## Externe Konten und Schlüsselpaare {#externally-owned-accounts-and-key-pairs}
+
+Ein Konto besteht aus einem kryptographischen Schlüsselpaar: öffentlich und privat. Sie tragen zum Nachweis bei, dass eine Transaktion tatsächlich vom Absender unterzeichnet wurde, und verhindern Fälschungen. Deinen privaten Schlüssel verwendest du, um Transaktionen zu unterzeichnen; so gewährt er dir die Obhut über das mit deinem Konto verbundene Guthaben. Man besitzt nie wirklich Kryptowährung, sondern private Schlüssel – das Geld ist immer auf Ethereums Hauptbuch (ledger).
+
+Dies hindert böswillige Akteure daran, gefälschte Transaktionen zu übertragen, da du immer den Absender einer Transaktion überprüfen kannst.
+
+Wenn Alice Ether von ihrem Konto an das Konto von Bob senden möchte, muss sie eine Transaktionsanfrage erstellen und zur Verifizierung an das Netzwerk senden. Ethereums Verwendung von Kryptographie mit öffentlichem Schlüssel stellt sicher, dass Alice nachweisen kann, dass sie ursprünglich die Transaktionsanfrage initiiert hat. Ohne kryptographische Mechanismen könnte Eve, ein böswilliger Akteur, einfach öffentlich eine Anfrage senden, die so aussieht wie „sende 5 ETH von Alices Konto auf Eves Konto", und niemand wäre in der Lage zu überprüfen, dass sie nicht von Alice kommt.
+
+## Kontoerstellung {#account-creation}
+
+Wenn du ein Konto erstellst, werden die meisten "libraries" dir einen zufälligen, privaten Schlüssel generieren.
+
+Ein privater Schlüssel besteht aus 64 hexadezimalen Zeichen und kann mit einem Passwort verschlüsselt werden.
+
+Beispiel:
+
+`fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036415f`
+
+Der öffentliche Schlüssel wird mithilfe des [Elliptic Curve Digital Signature Algorithm](https://wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm) aus dem privaten Schlüssel generiert. Du erhältst eine öffentliche Adresse für dein Konto, indem du die letzten 20 Bytes des Keccak-256-Hashes des öffentlichen Schlüssels nimmst und `0x` an den Anfang setzt.
+
+Hier ist ein Beispiel für die Erstellung eines Kontos in der Konsole, in der GETH's `personal_newAccount` verwendet wird
+
+```go
+> personal.newAccount()
+Passphrase:
+Repeat passphrase:
+"0x5e97870f263700f46aa00d967821199b9bc5a120"
+
+> personal.newAccount("h4ck3r")
+"0x3d80b31a78c30fc628f20b2c89d7ddbf6e53cedc
+```
+
+[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. Dies bedeutet, dass es unerlässlich ist, einen privaten Schlüssel sicher und, wie der Name schon sagt, **PRIVAT** aufzubewahren.
+
+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 deiner App kannst du eine Javascript-Bibliothek verwenden, um Transaktionen ins Netzwerk zu senden.
+
+## Vertragskonten {#contract-accounts}
+
+Vertragskonten haben eine 42-stellige, hexadezimale Adresse:
+
+Beispiel:
+
+`0x06012c8cf97bead5deae237070f9587f8e7a266d`
+
+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“).
+
+## Ein Hinweis zu Wallets {#a-note-on-wallets}
+
+Ein Konto ist kein Wallet. Ein Konto ist das Schlüsselpaar für ein Ethereum-Konto, das dem Benutzer gehört. Eine Wallet ist eine Schnittstelle oder Anwendung, über die du mit deinem Ethereum-Konto interagieren kannst.
+
+## Eine visuelle Demo {#a-visual-demo}
+
+Austin führt dich durch Hash-Funktionen und Schlüsselpaare.
+
+
+
+
+
+## Weiterführende Informationen {#further-reading}
+
+_Du kennst Community-Resourcen die dir geholfen haben? Bearbeite diese Seite und füge sie hinzu!_
+
+## Verwandte Themen {#related-topics}
+
+- [Smart Contracts](/developers/docs/smart-contracts/)
+- [Transaktionen](/developers/docs/transactions/)
diff --git a/src/content/translations/de/developers/docs/blocks/index.md b/src/content/translations/de/developers/docs/blocks/index.md
new file mode 100644
index 00000000000..94260572196
--- /dev/null
+++ b/src/content/translations/de/developers/docs/blocks/index.md
@@ -0,0 +1,70 @@
+---
+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
+sidebar: true
+---
+
+Blöcke sind Stapel von Transaktionen mit einem Hash des vorherigen Blocks in der Kette. Dies verbindet Blöcke (in einer Kette), weil Hashes kryptographisch aus den Blockdaten abgeleitet werden. Dies verhindert Betrug: Eine Änderung in irgendeiner Chronik würde alle nachfolgenden Blöcke ungültig machen, da sich alle nachfolgenden Hashes ändern und jeder, der die Blockchain ausführt, dies bemerken würde.
+
+## 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.
+
+## 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) Transaktionen auf einmal übergeben, bestätigt und synchronisiert werden.
+
+![Ein Diagramm, das Transaktionen in einem Block zeigt, die Zustandsänderungen verursachen](./tx-block.png) _Diagramm angepasst von [Ethereum EVM illustriert](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+
+Durch die Aufteilung der Übertragungen geben wir allen Netzwerkteilnehmern genügend Zeit, einen Konsens zu finden: Obwohl Transaktionsanfragen dutzende Male pro Sekunde auftreten, werden Blöcke auf Ethereum etwa alle fünfzehn Sekunden übertragen.
+
+## Wie Blöcke funktionieren {#how-blocks-work}
+
+Um die Transaktionsgeschichte zu erhalten, sind Blöcke streng sortiert (jeder neu erstellte Block enthält einen Verweis auf den übergeordneten Block), und Transaktionen innerhalb von Blöcken sind ebenfalls streng geordnet. Außer in seltenen Fällen, zu einem bestimmten Zeitpunkt, sind sich alle Teilnehmer des Netzwerks über die genaue Anzahl und Geschichte der Blöcke einig und arbeiten daran, die aktuellen Live-Transaktionsanfragen in den nächsten Block zu integrieren.
+
+Sobald ein Block von einem Miner im Netzwerk zusammengesetzt wird (geschürft, mined [engl.]), wird er an den Rest des Netzwerks weitergeleitet: Alle Nodes fügen diesen Block am Ende ihrer Blockchain hinzu und das Mining (Schürfen) geht weiter. Der genaue Prozess der Blockmontage (Schürfen/Mining [engl.]) und der Commitment/Konsensus-Prozess werden derzeit durch das „Proof-of-Work-Protokoll" von Ethereum spezifiziert.
+
+### Eine visuelle Demo {#a-visual-demo}
+
+
+
+## Proof-of-Work-Protokoll {#proof-of-work-protocol}
+
+Proof-of-Work bedeutet Folgendes:
+
+- Mining-Knoten müssen eine variable, aber beträchtliche Menge an Energie, Zeit und Rechenleistung aufwenden, um ein "Legitimationszertifikat" für einen Block zu erstellen, den sie dem Netzwerk vorschlagen. Dies trägt u. a. zum Schutz des Netzes vor Spam-/Denial-of-Service-Angriffen bei, da Zertifikate in der Herstellung teuer sind.
+- Andere Miner, die von einem neuen Block mit einem gültigen Legitimationszertifikat erfahren, müssen den neuen Block als den kanonischen nächsten Block auf der Blockchain akzeptieren.
+- Die genaue Zeit, die ein bestimmter Miner benötigt, um dieses Zertifikat zu erstellen, ist eine Zufallsvariable mit hoher Varianz. Dies stellt sicher, dass es unwahrscheinlich ist, dass zwei Miner gleichzeitig Validierungen für einen vorgeschlagenen nächsten Block erstellen. Wenn ein Miner einen zertifizierten neuen Block erstellt und verbreitet, kann er fast sicher sein, dass der Block vom Netzwerk als kanonischer nächster Block auf der Blockchain akzeptiert wird, ohne dass es zu Konflikten kommt (obwohl es auch ein Protokoll für den Umgang mit Konflikten gibt, falls zwei Ketten zertifizierter Blöcke fast gleichzeitig erstellt werden).
+
+[Mehr zum Mining](/developers/docs/consensus-mechanisms/pow/mining/)
+
+## Was enthält ein Block? {#block-anatomy}
+
+- `Zeitstempel` – die Zeit, zu der der Block gemint wurde.
+- `Blocknummer` – die Länge der Blockchain in Blöcken.
+- `Basisgebühr pro Gas` – die Mindestgebühr pro Gas, die erforderlich ist, damit eine Transaktion in den Block aufgenommen wird.
+- `Schwierigkeit` – der Aufwand, der erforderlich ist, um den Block abzubauen.
+- `mixHash` – ein eindeutiger Bezeichner für diesen Block.
+- `parentHash` – der eindeutige Bezeichner des vorhergehenden Blocks (so werden die Blöcke in einer Kette verknüpft).
+- `Transaktionen` – die im Block enthaltenen Transaktionen.
+- `stateRoot` – der gesamte Status des Systems: Kontosalden, Vertragsspeicher, Vertragscode und Konto-Nonce sind darin enthalten.
+- `nonce` – ein Hash, der in Kombination mit dem mixHash beweist, dass der Block den [Proof-of-Work](/developers/docs/consensus-mechanisms/pow/) durchlaufen hat.
+
+## Blockzeit {#block-time}
+
+Die Blockzeit bezieht sich auf die Zeit, die für das Mining eines neuen Blocks benötigt wird. In Ethereum beträgt die durchschnittliche Blockzeit zwischen 12 und 14 Sekunden und wird nach jedem Block ausgewertet. Die erwartete Blockzeit wird als Konstante auf Protokollebene festgelegt und dient dazu, die Sicherheit des Netzwerks zu schützen, wenn die Miner mehr Rechenleistung einsetzen. Die durchschnittliche Blockzeit wird mit der erwarteten Blockzeit verglichen, und wenn die durchschnittliche Blockzeit höher ist, dann wird die Schwierigkeit im Block-Header verringert. Wenn die durchschnittliche Blockzeit kleiner ist, wird die Schwierigkeit im Block-Header erhöht.
+
+## 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 15 Millionen Gas, aber die Größe der Blöcke wird entsprechend der Netznachfrage erhöht oder verringert, bis zur Blockgrenze von 30 Millionen Gas (doppelte Zielblockgröße). Die Gesamtmenge des von allen Transaktionen im Block verbrauchten Gases muss unter dem Blockgaslimit liegen. Dies 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 Nodes aufgrund von Platz- und Geschwindigkeitsanforderungen allmählich nicht mehr mit dem Netzwerk Schritt halten können.
+
+## Weiterführende Informationen {#further-reading}
+
+_Kennst du eine Community-Ressource, die dir geholfen hat? Bearbeite diese Seite und füge sie hinzu!_
+
+## Verwandte Themen {#related-topics}
+
+- [Mining](/developers/docs/consensus-mechanisms/pow/mining/)
+- [Transaktionen](/developers/docs/transactions/)
+- [Ressourcen](/developers/docs/gas/)
diff --git a/src/content/translations/de/developers/docs/consensus-mechanisms/index.md b/src/content/translations/de/developers/docs/consensus-mechanisms/index.md
new file mode 100644
index 00000000000..49dfec2f13c
--- /dev/null
+++ b/src/content/translations/de/developers/docs/consensus-mechanisms/index.md
@@ -0,0 +1,94 @@
+---
+title: Konsensmechanismus
+description: Eine Erklärung von Konsensprotokollen in verteilten Systemen und die Rolle, die sie in Ethereum spielen.
+lang: de
+sidebar: true
+incomplete: true
+---
+
+Bei Blockchains wie Ethereum, die im Grunde verteilte Datenbanken sind, müssen sich die Nodes des Netzwerks über den aktuellen Zustand des Netzwerks einigen. Diese Einigung wird durch Konsensmechanismen erreicht.
+
+Auch wenn die Konsensmechanismen nicht direkt mit der Entwicklung einer App zu tun haben, wird das Verständnis dieser Mechanismen dir und deinen Nutzern/Nutzerinnen helfen, Konzepte wie Gaspreise und Transaktionszeiten zu verstehen.
+
+## Voraussetzungen {#prerequisites}
+
+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}
+
+Unter einem Konsens verstehen wir, dass eine allgemeine Einigung erzielt wurde. Stell dir vor, eine Gruppe von Menschen geht ins Kino. Wenn es keine Meinungsverschiedenheiten über eine vorgeschlagene Filmauswahl gibt, wird ein Konsens erzielt. Im Extremfall wird sich die Gruppe ohne Konsens aufspalten.
+
+In Bezug auf die Blockchain ist der Prozess formalisiert und das Erreichen eines Konsenses bedeutet, dass sich mindestens 51 % der Nodes im Netzwerk über den nächsten globalen Zustand des Netzwerks einig sind.
+
+## Was ist ein Konsensmechanismus? {#what-is-a-consensus-mechanism}
+
+Konsensmechanismen (auch bekannt als Konsensprotokolle oder Konsensalgorithmen) ermöglichen, dass verteilte Systeme (Computernetzwerke) zusammenarbeiten und sicher bleiben.
+
+Seit Jahrzehnten werden Mechanismen genutzt, um einen Konsens zwischen Datenbank-Nodes, Anwendungsservern und anderen Unternehmensinfrastrukturen herzustellen. In den letzten Jahren wurden neue Konsensmechanismen erfunden, die es kryptoökonomischen Systemen wie Ethereum ermöglichen, sich über den Zustand des Netzwerks zu einigen.
+
+Ein Konsensmechanismus in einem kryptoökonomisches System hilft auch bestimmte Arten von wirtschaftlichen Angriffen zu verhindern. Theoretisch kann ein Angreifer den Konsens erreichen, indem er 51 % des Netzwerks kontrolliert. Konsensmechanismen sollen diesen "51-%-Angriff" unmöglich zu machen. Verschiedene Mechanismen werden entwickelt, um dieses Sicherheitsproblem auf unterschiedliche Weise zu lösen.
+
+
+
+## Arten von Konsensmechanismen {#types-of-consensus-mechanisms}
+
+### Proof-of-Work {#proof-of-work}
+
+Ethereum verwendet, wie Bitcoin, derzeit ein **Proof-of-Work(PoW)**-Konsensprotokoll.
+
+#### Blockerstellung {#pow-block-creation}
+
+Der Proof-of-Work wird durch [Miner](/developers/docs/consensus-mechanisms/pow/mining/) erledigt, die um die Erstellung eines neuen Blocks voller verarbeiteter Transaktionen konkurrieren. Der Gewinner teilt den neuen Block mit dem Rest des Netzwerks und verdient einige frisch geminte ETH. Es gewinnt derjenige, dessen Computer am schnellsten ein mathematisches Rätsel lösen kann. Dadurch wird die kryptographische Verbindung zwischen dem aktuellen Block und dem vorherigen Block hergestellt. Die Lösung dieses Rätsels ist die Arbeit ("Work") im "Proof-of-Work".
+
+#### Sicherheit {#pow-security}
+
+Die Sicherheit des Netzwerks wird dadurch gewährleistet, dass du 51 % der Rechenleistung des Netzwerks brauchst, um die Kette zu betrügen. Das würde so große Investitionen in Ausrüstung und Energie erfordern, dass du wahrscheinlich mehr ausgibst, als du gewinnst.
+
+Mehr über [Proof-of-Work](/developers/docs/consensus-mechanisms/pow/)
+
+### Proof-of-Stake {#proof-of-stake}
+
+Ethereum plant ein Upgrade zum **Proof-of-Stake(PoS)**-Konsensprotokoll.
+
+#### Blockerstellung {#pos-block-creation}
+
+Der Proof-of-Stake wird durch Validatoren vollzogen, welche ihre ETH für die Teilnahme im System eingesetzt haben. Ein Validator wird nach dem Zufallsprinzip ausgewählt, um neue Blöcke zu erstellen, sie mit dem Netzwerk zu teilen und Belohnungen zu verdienen. Anstatt intensive Rechenarbeit leisten zu müssen, musst du einfach deine ETH ins Netzwerk gesteckt haben. Das schafft Anreize für ein gesundes Netzwerkverhalten.
+
+#### Sicherheit {#pos-security}
+
+Ein Proof-of-Stake-System wird durch die Tatsache gesichert, dass man 51 % der gesamten eingesetzten ETH benötigt, um die Kette zu betrügen, und dass dein Einsatz für böswilliges Verhalten gekürzt wird.
+
+Mehr zu [Proof-of-Stake](/developers/docs/consensus-mechanisms/pos/)
+
+### Ein visueller Leitfaden {#types-of-consensus-video}
+
+Erfahre mehr über die verschiedenen Arten von Konsensmechanismen, die auf Ethereum verwendet werden:
+
+
+
+### Sybil: Widerstand & Kettenauswahl {#sybil-chain}
+
+Technisch gesehen sind Proof-of-Work und Proof-of-Stake keine Konsensprotokolle, aber der Einfachheit halber werden sie oft als solche bezeichnet. Sie sind eigentlich Sybil-Widerstandsmechanismen und Blockautor-Selektoren; sie sind ein Weg, um zu entscheiden, wer der Autor des letzten Blocks ist. Dieser Sybil-Widerstandsmechanismus in Kombination mit einer Kettenauswahlregel macht einen echten Konsensmechanismus aus.
+
+Der **Sybil-Widerstand** misst, wie ein Protokoll gegen einen [Sybil-Angriff](https://wikipedia.org/wiki/Sybil_attack) abschneidet. Bei Sybil-Angriffen gibt sich ein Nutzer oder eine Gruppe als viele Nutzer aus. Der Widerstand gegen diese Art von Angriffen ist für eine dezentrale Blockchain unerlässlich und ermöglicht es Minern und Validatoren, auf der Grundlage der eingesetzten Ressourcen gleichermaßen belohnt zu werden. Proof-of-Work und Proof-of-Stake schützen davor, indem sie die Nutzer/Nutzerinnen dazu bringen, viel Energie aufzuwenden oder eine Menge Sicherheiten zu stellen. Diese Schutzmaßnahmen sind eine wirtschaftliche Abschreckung gegen Sybil-Angriffe.
+
+Eine **Kettenauswahlregel** wird verwendet, um zu entscheiden, welche Kette die "richtige" ist. Ethereum und Bitcoin verwenden derzeit die "Longest-Chain"-Regel, was bedeutet, dass die Blockchain, die am längsten ist, von den anderen Nodes als gültig akzeptiert wird und mit ihr arbeitet. Bei Proof-of-Work-Ketten wird die längste Kette durch die gesamte kumulative Proof-of-Work-Schwierigkeit der Kette bestimmt.
+
+Die Kombination aus Proof-of-Work und Longest-Chain-Regel ist als "Nakamoto-Konsens" bekannt.
+
+Die [Beacon Chain](/upgrades/beacon-chain/) verwendet einen Konsensmechanismus namens [Casper the Friendly Finality Gadget](https://arxiv.org/abs/1710.09437), der auf einem Proof-of-Stake basiert.
+
+## Weiterführende Informationen {#further-reading}
+
+- [Was ist ein Blockchain-Konsens-Algorithmus?](https://academy.binance.com/en/articles/what-is-a-blockchain-consensus-algorithm)
+- [Was ist der Nakamoto-Konsens? Vollständiger Leitfaden für Anfänger](https://blockonomi.com/nakamoto-consensus/)
+- [Wie funktioniert Casper?](https://medium.com/unitychain/intro-to-casper-ffg-9ed944d98b2d)
+- [Über die Sicherheit und Leistungsfähigkeit von Proof-of-Work-Blockchains](https://eprint.iacr.org/2016/555.pdf)
+
+_Kennst du eine Community-Ressource, die dir geholfen hat? Bearbeite diese Seite und füge sie hinzu!_
+
+## Verwandte Themen {#related-topics}
+
+- [Proof-of-Work](/developers/docs/consensus-mechanisms/pow/)
+- [Mining](/developers/docs/consensus-mechanisms/pow/mining/)
+- [Proof-of-Stake](/developers/docs/consensus-mechanisms/pos/)
diff --git a/src/content/translations/de/developers/docs/consensus-mechanisms/pos/index.md b/src/content/translations/de/developers/docs/consensus-mechanisms/pos/index.md
new file mode 100644
index 00000000000..49de72dc5be
--- /dev/null
+++ b/src/content/translations/de/developers/docs/consensus-mechanisms/pos/index.md
@@ -0,0 +1,98 @@
+---
+title: Proof-of-Stake (PoS)
+description: Eine Erklärung des Proof-of-Stake-Konsensprotokolls und seiner Rolle in Ethereum.
+lang: de
+sidebar: true
+incomplete: true
+---
+
+Ethereum bewegt sich vom [Proof-of-Work (PoW)](/developers/docs/consensus-mechanisms/pow/) zu einem Konsensmechanismus, genannt Proof-of-Stake (PoS). Das war immer der Plan, denn es ist ein wichtiger Teil der Strategie der Community, Ethereum über [Upgrades](/upgrades/) zu skalieren. Allerdings ist es eine große technische Herausforderung, PoS richtig umzusetzen, und nicht so einfach wie PoW zu nutzen, um einen Konsens über das Netzwerk zu erzielen.
+
+## Voraussetzungen {#prerequisites}
+
+Um diese Seite besser zu verstehen, empfehlen wir dir, zuerst einen Blick auf [Konsensmechanismen](/developers/docs/consensus-mechanisms/) zu werfen.
+
+## Was ist Proof-of-Stake (PoS)? {#what-is-pos}
+
+Proof-of-Stake ist eine Art von [Konsensmechanismus](/developers/docs/consensus-mechanisms/), die von Blockchain-Netzwerken benutzt wird, um einen verteilten Konsens zu erreichen.
+
+Es verlangt von Nutzern das Einsetzen ([engl.] Staking) ihrer ETH, um ein Validator im Netzwerk zu werden. Validatoren sind verantwortlich für die gleichen Dinge wie Miner in [Proof-of-Work](/developers/docs/consensus-mechanisms/pow/): Ordnen von Transaktionen und Erstellen von neuen Blöcken, so dass alle Nodes mit dem Status des Netzwerks übereinstimmen.
+
+Proof-of-Stake kommt mit einer Anzahl an Verbesserungen zum Proof-of-Work-System hinzu:
+
+- bessere Energieeffizienz – weniger Energieaufwand für das Minen (Schürfen) von Blöcken
+- weniger Hindernisse für den Einstieg, zeduziert Hardwareanforderungen – Du brauchst keine Elite-Hardware, um neue Blöcke zu erstellen
+- stärkere Immunität gegen die Zentralisierung – Proof-of-Stake sollte zu mehr Nodes im Netzwerk führen
+- stärkere Unterstützung für [Shard Chains](/upgrades/shard-chains/) – ein wichtiges Upgrade bei der Skalierung des Ethereum-Netzwerks
+
+## Proof-of-Stake, Staking und Validatoren {#pos-staking-validators}
+
+Proof-of-Stake ist der zugrundeliegende Mechanismus, der Validatoren aktiviert, wenn genügend Stakes vorhanden sind. Für Ethereum müssen Benutzer 32 ETH staken (einsetzen), um ein Validator zu werden. Validatoren werden zufällig ausgewählt, um Blöcke zu erstellen, und sind für die Überprüfung und Bestätigung von Blöcken, die sie nicht erstellen, verantwortlich. Der Einsatz eines Benutzers wird auch als Anreiz für ein gutes Validator-Verhalten verwendet. Zum Beispiel kann ein Nutzer einen Teil seines Stakes für Dinge wie offline zu gehen (Fehlversuch der Validierung) oder seinen gesamten Stake für vorsätzliche Kollusion verlieren.
+
+## Wie funktioniert Ethereums Proof-of-Stake? {#how-does-pos-work}
+
+Im Gegensatz zum Proof-of-Work müssen Validatoren keine erheblichen Mengen an Rechenleistung verwenden, da sie zufällig ausgewählt werden und nicht miteinander konkurrieren. Sie müssen nicht unentwegt Blocks minen (schürfen), sondern nur dann, wenn sie ausgewählt werden, und vorgeschlagene Blöcke validieren, wenn sie nicht ausgewählt sind. Diese Validierung wird als Attestieren bezeichnet. Du kannst dir das Attestieren vorstellen, wie "dieser Block sieht gut für mich aus" zu sagen. Validatoren erhalten Belohnungen für neue Blöcke und das Zertifizieren von Blöcken, die sie gesehen haben.
+
+Wenn du bösartige Blöcke attestierst, verlierst du deinen Einsatz.
+
+### Die Beacon Chain {#the-beacon-chain}
+
+Wenn Ethereum den Proof-of-Work durch den Proof-of-Stake ersetzt, wird es zusätzlich die Komplexität von [Shard-Chains](/upgrades/shard-chains/) geben. Das sind separate Blockchains, die Validatoren benötigen, um Transaktionen zu verarbeiten und neue Blöcke zu erstellen. Der Plan sind 64 Scherben-Ketten, die alle ein geteiltes Verständnis vom Status des Netzwerks haben. Daher ist eine zusätzliche Koordination notwendig, die von [der Beacon Chain](/upgrades/beacon-chain/) übernommen wird.
+
+Die Beacon Chain erhält Statusinformationen von den Fragmenten und stellt sie für die anderen Fragmente zur Verfügung, so dass das Netzwerken synchronisiert bleiben kann. Die Beacon Chain verwaltet auch die Validatoren, von der Registrierung ihrer Einlagen bis hin zur Verteilung ihrer Belohnungen und Strafen.
+
+So funktioniert dieser Prozess.
+
+### Wie Validierung funktioniert {#how-does-validation-work}
+
+Wenn du eine Transaktion auf einem Shard einreichst, ist ein Validator dafür verantwortlich, deine Transaktion zu einem Shard-Block hinzuzufügen. Validatoren werden algorithmisch von der Beacon Chain ausgewählt, um neue Blöcke zu vorzuschlagen.
+
+#### Attestierung {#attestation}
+
+Wird ein Validator nicht ausgewählt, um einen neuen Shard-Block vorzuschlagen, muss er den Vorschlag eines anderen Validators attestieren und bestätigen, dass alles so aussieht wie es soll. Es ist die Attestierung, die in der Beacon-Kette aufgezeichnet wird, und nicht die Transaktion selbst.
+
+Mindestens 128 Validatoren werden benötigt, um jeden Shard-Block zu attestieren. Diese werden als "Komitee" bezeichnet.
+
+Das Komitee hat einen Zeitrahmen, in dem es einen Shard-Block vorschlagen und validieren muss. Dieser ist als "Slot" bekannt. Pro Slot wird lediglich ein gültiger Block erstellt und 32 Slots bilden eine "Epoche." Nach jeder Epoche wird das Komitee aufgelöst und mit verschiedenen, zufälligen Teilnehmern reformiert. Dies trägt dazu bei, Shards vor Ausschüssen aus schlechten Akteuren zu schützen.
+
+#### Crosslinks {#rewards-and-penalties}
+
+Wenn ein neuer Shard-Block-Vorschlag genug Attestierungen hat, wird ein "Crosslink" erzeugt, welcher die Aufnahme des Blocks und deiner Transaktion in der Beacon Chain bestätigt.
+
+Sobald es einen Crosslink gibt, erhält der Validator, der den Block vorgeschlagen hat, seine Belohnung.
+
+#### Finalisierung {#finality}
+
+In verteilten Netzwerken hat eine Transaktion eine "Finalisierung", wenn sie Teil eines Bausteins ist, der sich nicht ändern kann.
+
+Um dies in Proof-of-Stake zu tun, bringt Casper, ein Finalisierungsprotokoll, Validatoren dazu, den Zustand eines Blocks an bestimmten Kontrollpunkten zu bestätigen. Solange 2/3 der Validatoren bestätigt haben, ist der Block fertig. Validatioren verlieren ihren gesamten Stake, wenn sie versuchen, dies später durch einen 51-%-Angriff rückgängig zu machen.
+
+Vlad Zamfir drückte es so aus: Das ist wie bei einem Miner, dem aufgrund der Teilnahme an einem 51-%-Angriff seine Mining-Hardware abbrennt.
+
+## Proof-of-Stake und Sicherheit {#pos-and-security}
+
+Die Bedrohung eines [51-%-Angriffs](https://www.investopedia.com/terms/1/51-attack.asp) existiert im Proof-of-Stake weiterhin, jedoch ist das Risiko für den Angreifer noch größer. Für solch einen Angriff musst du 51 % aller eingesetzten ETH kontrollieren. Dies ist nicht nur eine große Menge an Geld, sondern würde wahrscheinlich auch dazu führen, dass der ETH-Wert sinkt. Es gibt wenig Anreiz dafür, den Wert einer Währung zu zerstören, an der du eine Mehrheit hast. Es ist wesentlich erstrebenswerter, das Netzwerk sicher und gesund zu halten.
+
+Stake-Kürzungen, Ausschlüsse und andere Strafen, die von der Beacon Chain koordiniert werden, werden existieren, um andere schlechte Handlungen zu verhindern. Validatoren werden auch dafür verantwortlich sein, diese Vorfälle zu melden.
+
+## Vor- und Nachteile {#pros-and-cons}
+
+| Vorteile | Nachteile |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
+| Staking macht dir die Ausführung eines Nodes einfacher. Es erfordert keine großen Investitionen in Hardware oder Energie und wenn du nicht genug ETH zum Staken hast, kannst du dich einem Staking-Pool anschließen. | Proof-of-Stake steckt noch in den Kinderschuhen und ist im Vergleich zum Proof-of-Work weniger erprobt. |
+| Staking ist stärker dezentralisiert. Es erlaubt eine erhöhte Beteiligung und mehr Nodes bedeuten keinen %-Anstieg der Erträge, wie etwa beim Mining. | |
+| Staking ermöglicht sicheres Sharding. Shard-Chains erlauben es Ethereum, mehrere Blöcke zur gleichen Zeit zu erstellen, wodurch der Durchsatz an Transaktionen erhöht wird. Das Sharding des Netzwerks in einem Proof-of-Work-System würde einfach die Leistung verringern, die nötig ist, um einen Teil des Netzes zu kompromittieren. | |
+
+## Weiterführende Informationen {#further-reading}
+
+- [Proof of Stake FAQ](https://vitalik.ca/general/2017/12/31/pos_faq.html) _Vitalik Buterin_
+- [Was ist Proof-of-Stake](https://consensys.net/blog/blockchain-explained/what-is-proof-of-stake/) _ConsenSys_
+- [Was Proof of Stake ist und warum sie wichtig ist](https://bitcoinmagazine.com/culture/what-proof-of-stake-is-and-why-it-matters-1377531463) _Vitalik Buterin_
+- [Die Erklärung der Ethereum 2.0 Beacon Chain, die du zuerst lesen solltest](https://ethos.dev/beacon-chain/) _Ethos.dev_
+- [Warum Proof of Stake (Nov 2020)](https://vitalik.ca/general/2020/11/06/pos2020.html) _Vitalik Buterin_
+- [Proof of Stake: How I Learned to Love Weak Subjectivity](https://blog.ethereum.org/2014/11/25/proof-stake-learned-love-weak-subjectivity/) _Vitalik Buterin_
+- [A Proof of Stake Design Philosophy](https://medium.com/@VitalikButerin/a-proof-of-stake-design-philosophy-506585978d51) _Vitalik Buterin_
+
+## Verwandte Themen {#related-topics}
+
+- [Proof of work](/developers/docs/consensus-mechanisms/pow/)
diff --git a/src/content/translations/de/developers/docs/consensus-mechanisms/pow/index.md b/src/content/translations/de/developers/docs/consensus-mechanisms/pow/index.md
new file mode 100644
index 00000000000..193b651e5e9
--- /dev/null
+++ b/src/content/translations/de/developers/docs/consensus-mechanisms/pow/index.md
@@ -0,0 +1,112 @@
+---
+title: Proof-of-Work (PoW)
+description: Eine Erklärung für das Proof-of-Work-Konsensprotokoll und seine Rolle in Ethereum.
+lang: de
+sidebar: true
+incomplete: true
+---
+
+Ethereum verwendet, wie Bitcoin, derzeit ein Konsensprotokoll namens **[Proof-of-Work (PoW)](https://wikipedia.org/wiki/Proof_of_work)**. Dies ermöglicht es den Nodes des Ethereum-Netzwerks, sich über den Stand aller auf der Ethereum-Blockchain aufgezeichneten Informationen zu einigen, und verhindert bestimmte Arten von wirtschaftlichen Angriffen.
+
+Im Laufe des nächsten Jahres wird Proof-of-Work zugunsten von **[Proof-of-Stake (PoS)](/developers/docs/consensus-mechanisms/pos)** auslaufen. Mit dem Übergang zu Proof-of-Stake wird auch das Mining von Ethereum auslaufen. [Mehr zum Merge](/upgrades/merge/)
+
+## Voraussetzungen {#prerequisites}
+
+Um diese Seite besser zu verstehen, empfehlen wir dir, zuerst etwas über [Transaktionen](/developers/docs/transactions/), [Blöcke](/developers/docs/blocks/) und [Konsensmechanismen](/developers/docs/consensus-mechanisms/) zu lesen.
+
+## Was ist Proof-of-Work (PoW)? {#what-is-pow}
+
+Proof-of-Work ist der Mechanismus, der es dem dezentralen Ethereum-Netzwerk ermöglicht, einen Konsens zu finden oder sich auf Dinge wie Kontostände und die Reihenfolge von Transaktionen zu einigen. Dies verhindert, dass die Nutzer/innen ihre Coins doppelt ausgeben, und stellt sicher, dass die Ethereum-Kette nur sehr schwer angegriffen oder manipuliert werden kann.
+
+## Proof-of-Work und Mining {#pow-and-mining}
+
+Proof-of-Work ist der grundlegende Algorithmus, der den Schwierigkeitsgrad und die Regeln für die Arbeit der Miner festlegt. Mining ist die "Arbeit" (Work) selbst. Es ist das Hinzufügen von gültigen Blöcken zur Kette (Chain). Das ist wichtig, denn die Länge der Kette hilft dem Netzwerk, der richtigen Ethereum-Kette zu folgen und den aktuellen Zustand von Ethereum zu verstehen. Je mehr "Arbeit" geleistet wird, desto länger ist die Kette, und je höher die Blocknummer ist, desto sicherer kann sich das Netzwerk über den aktuellen Stand der Dinge sein.
+
+[Mehr zum Mining](/developers/docs/consensus-mechanisms/pow/mining/)
+
+## Wie funktioniert Ethereums Proof-of-Work? {#how-it-works}
+
+Ethereums Transaktionen werden zu Blöcken verarbeitet. Jeder Block hat
+
+- einen Block-Schwierigkeitsgrad – zum Beispiel: 3.324.092.183.262.715,
+- einen mixHash – zum Beispiel, `0x44bca881b07a6a09f83b130798072441705d9a665c5ac8bdf2f39a3cdf3bee29`,
+- eine Nonce – zum Beispiel: `0xd3ee432b4fb3d26b`.
+
+Diese Blockdaten sind direkt mit dem Proof-of-Work verbunden.
+
+### Die "Arbeit" (Work) in Proof-of-Work {#the-work}
+
+Das Proof-of-Work-Protokoll Ethash verlangt von den Minern einen intensiven Wettlauf von Versuch und Irrtum, um die Nonce für einen Block zu finden. Nur Blöcke mit einer gültigen Nonce können der Chain hinzugefügt werden.
+
+Beim Wettlauf zur Erstellung eines Blocks setzt ein Miner wiederholt einen Datensatz, den du nur durch Downloaden und Ausführen der kompletten Chain (wie es ein Miner macht) erhältst, in eine mathematische Funktion ein. Der Datensatz wird verwendet, um einen mixHash unter einer Ziel-Nonce zu generieren, die von der Blockschwierigkeit abhängt. Die beste Methode hierfür ist durch Versuch und Irrtum.
+
+Die Schwierigkeit bestimmt das Ziel für den Hash. Je niedriger das Ziel, desto kleiner ist der Satz gültiger Hashes. Einmal generiert, ist dies für andere Miner und Nutzer/Nutzerinnen unglaublich einfach zu überprüfen. Selbst wenn sich eine Transaktion ändern würde, wäre der Hash völlig anders und würde auf Betrug hindeuten.
+
+"Hashing" macht es leichter, Betrug zu erkennen. Aber Proof-of-Work als Prozess ist auch eine große Abschreckung für Angriffe auf die Kette.
+
+### Sicherheit von Proof-of-Work {#security}
+
+"Minern" wird ein Anreiz geboten, diese Arbeit an der wichtigsten Ethereum-Kette zu leisten. Es gibt einen kleinen Ansporn für einen Teil der Miner, ihre eigene Kette zu starten – dies untergräbt das System. Bockchains sind auf einen einzigen Status als Quelle der Wahrheit angewiesen. Und Benutzer werden immer die längste, "schwerste" Kette auswählen.
+
+Das Ziel des Proof-of-Work ist es, die Kette zu verlängern. Die längste Kette ist am glaubwürdigsten, weil für sie die meisten Berechnungen durchgeführt wurden. Im PoW-System von Ethereum ist es fast unmöglich, neue Blöcke zu erstellen, die Transaktionen löschen, gefälschte Blöcke zu erstellen oder eine zweite Kette zu unterhalten. Das liegt daran, dass ein böswilliger Miner die Block-Nonce immer schneller lösen müsste als alle anderen.
+
+Um ständig bösartige und dennoch gültige Blöcke zu erzeugen, brauchst du über 51 % der Mining-Power im Netzwerk, um alle anderen zu schlagen. Du bräuchtest eine Menge Rechenleistung, um diese Menge an "Work" erledigen zu können. Und die aufgewendete Energie könnte sogar den Gewinn aufwiegen, den du bei einem Angriff erzielen würdest.
+
+### Wirtschaftlichkeit von Proof-of-Work {#economics}
+
+Der Proof-of-Work ist auch dafür verantwortlich, dass neue Währung in das System kommt und die Miner einen Anreiz haben, die Arbeit zu machen.
+
+Miner die erfolgreich einen Block erstellen, werden mit zwei frisch erzeugten ETH belohnt, erhalten aber nicht mehr alle Transaktionsgebühren, da die Grundgebühr verbraucht wird, während die Trinkgeld- und Blockbelohnung an den Miner geht. Ein Miner kann auch 1,75 ETH für einen Onkelblock erhalten. Onkelblöcke sind gültige Blöcke, die von einem Miner praktisch zur gleichen Zeit erstellt wurden, als ein anderer Miner den erfolgreichen Block gemint hat. Onkleblöcke entstehen normalerweise aufgrund von Netzwerklatenz.
+
+## Endgültigkeit {#finality}
+
+Eine Transaktion hat bei Ethereum "Endgültigkeit", wenn sie Teil eines Blocks ist, der sich nicht mehr ändern kann.
+
+Da die Miner dezentral arbeiten, können zwei gültige Blöcke gleichzeitig gemint werden. Dadurch entsteht eine temporäre Abzweigung. Letztendlich wird eine dieser Ketten zur akzeptierten Kette, nachdem ein weiterer Block abgebaut und hinzugefügt wurde, wodurch sie länger wird.
+
+Aber um die Sache noch komplizierter zu machen, können Transaktionen, die bei der temporären Gabelung abgelehnt wurden, in die akzeptierte Kette aufgenommen worden sein. Das bedeutet, dass die Transaktion rückgängig gemacht werden könnte. Die Endgültigkeit bezieht sich also auf die Zeit, die du warten solltest, bevor du eine Transaktion als unumkehrbar betrachtest. Für Ethereum beträgt die empfohlene Zeit sechs Blöcke oder etwas mehr als eine Minute. Nach sechs Blöcken kannst du mit relativer Sicherheit sagen, dass die Transaktion erfolgreich war. Du kannst noch länger auf noch größere Zusicherungen warten.
+
+Die Endgültigkeit ist etwas, das du beim Entwerfen von Dapps beachten solltest. Es wäre ein schlechtes Nutzererlebnis, wenn du für deine Nutzer/Nutzerinnen die Transaktionsinformationen falsch darstellst, vor allem wenn die Transaktion einen hohen Wert hat.
+
+Denke daran, dass diese Zeitspanne nicht die Wartezeiten beinhaltet, bis eine Transaktion von einem Miner abgeholt wird.
+
+## Energieverbrauch von Proof-of-Work {#energy}
+
+Ein Hauptkritikpunkt an Proof-of-Work ist die Menge an Energie, die benötigt wird, um das Netzwerk sicher zu halten. Um die Sicherheit und Dezentralisierung aufrechtzuerhalten, verbraucht Ethereum mit Proof-of-Work jährlich 73,2 TWh, was dem Energieäquivalent eines mittelgroßen Landes wie Österreich entspricht.
+
+## Vor- und Nachteile {#pros-and-cons}
+
+| Vorteile | Nachteile |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Proof-of-Work ist neutral. Du brauchst keine ETH, um loszulegen, und die Blockbelohnungen erlauben dir von 0 ETH auf einen positiven Kontostand zu kommen. Für [Proof-of-Stake](/developers/docs/consensus-mechanisms/pos/) brauchst du zu Beginn ETH. | Proof-of-Work verbraucht so viel Energie, dass es schlecht für die Umwelt ist. |
+| Proof-of-Work ist ein bewährter Konsensmechanismus, der Bitcoin und Ethereum seit vielen Jahren sicher und dezentralisiert macht. | Wenn du Mining betreiben willst, brauchst du eine so spezielle Ausrüstung, dass es eine große Investition ist, damit anzufangen. |
+| Verglichen mit dem Proof-of-Stake ist es relativ einfach zu implementieren. | Da immer mehr Rechenleistung benötigt wird, könnten Mining-Pools das Mining-Geschäft dominieren, was zu Zentralisierung und Sicherheitsrisiken führt. |
+
+## Vergleich mit Proof-of-Stake {#compared-to-pos}
+
+Im Großen und Ganzen hat der Proof-of-Stake dasselbe Ziel wie der Proof-of-Work: dem dezentralen Netzwerk zu helfen, sicher einen Konsens zu erreichen. Aber er hat einige Unterschiede im Prozess und im Personal:
+
+- Der Proof-of-Stake hebt die Bedeutung der Rechenleistung für die eingesetzte ETH auf.
+- Beim Proof-of-Stake werden die Miner durch Validatoren ersetzt. Validatoren setzen ihre ETH ein ("Staking"), um die Fähigkeit, neue Blöcke zu erstellen, zu aktivieren.
+- Validatoren konkurrieren nicht um Blöcke, sondern werden zufällig durch einen Algorithmus ausgewählt.
+- Die Endgültigkeit ist klarer: Wenn sich 2/3 der Prüfer/Prüferinnen an bestimmten Kontrollpunkten über den Zustand des Blocks einig sind, gilt er als endgültig. Die Validatoren müssen ihren gesamten Einsatz darauf setzen. Wenn sie also versuchen, sich abzusprechen, verlieren sie ihren gesamten Einsatz.
+
+[Mehr über Proof-of-Stake](/developers/docs/consensus-mechanisms/pos/)
+
+## Eher ein visueller Lerner? {#visual-learner}
+
+
+
+## Weiterführende Informationen {#further-reading}
+
+- [Mehrheitsangriff](https://en.bitcoin.it/wiki/Majority_attack)
+- [Zur Endgültigkeit der Abrechnung](https://blog.ethereum.org/2016/05/09/on-settlement-finality/)
+
+### Videos {#videos}
+
+- [Eine technische Erklärung von Proof-of-Work-Protokollen](https://youtu.be/9V1bipPkCTU)
+
+## Verwandte Themen {#related-topics}
+
+- [Mining](/developers/docs/consensus-mechanisms/pow/mining/)
+- [Proof-of-Stake](/developers/docs/consensus-mechanisms/pos/)
diff --git a/src/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/index.md b/src/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/index.md
new file mode 100644
index 00000000000..cc295f416a1
--- /dev/null
+++ b/src/content/translations/de/developers/docs/consensus-mechanisms/pow/mining/index.md
@@ -0,0 +1,77 @@
+---
+title: Mining
+description: Eine Erklärung, wie "Mining" in Ethereum funktioniert und wie es dazu beiträgt, Ethereum sicher und dezentral zu halten.
+lang: de
+sidebar: true
+incomplete: true
+---
+
+## 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.
+
+## Was ist Ethereum-Mining? {#what-is-ethereum-mining}
+
+Mining ist der Prozess zur Erstellung eines Blocks aus Transaktionen, der zur Ethereum-Blockchain hinzugefügt werden soll.
+
+Ethereum verwendet derzeit, genau wie Bitcoin, einen [Proof-of-Work (PoW)](/developers/docs/consensus-mechanisms/pow/)-Konsensmechanismus. Mining ist das Lebenselixier des Proof-of-Work. Ethereum-Miner (Computer, die eine Software ausführen) nutzen ihre Zeit und Rechenleistung zur Verarbeitung von Transaktionen und Erstellung von Blöcken.
+
+
+ Proof-of-Stake wird im Laufe des nächsten Jahres Mining und Proof-of-Work ersetzen. Du kannst schon heute mit dem Staking deiner ETH beginnen. Mehr zum Staking
+
+
+## Warum gibt es Miner? {#why-do-miners-exist}
+
+In dezentralisierten Systemen wie Ethereum müssen wir sicherstellen, dass jeder mit der Reihenfolge der Transaktionen übereinstimmt. Miner helfen dabei, indem sie rechnerisch schwierige Puzzles lösen, um Blöcke zu erzeugen, welche als Möglichkeit dienen, das Netzwerk vor Angriffen zu schützen.
+
+[Mehr zum Proof-of-Work](/developers/docs/consensus-mechanisms/pow/)
+
+## Wer kann Miner bei Ethereum werden? {#who-can-become-a-miner}
+
+Technisch gesehen kann jeder mit seinem Computer im Ethereum-Netzwerk minen. Allerdings kann nicht jeder Ether (ETH) gewinnbringend minen. In den meisten Fällen müssen Miner spezielle Computerhardware kaufen, um gewinnbringend minen zu können. Zwar kann jeder die Mining-Software auf seinem Computer laufen lassen, doch ist es unwahrscheinlich, dass ein durchschnittlicher Computer genügend Blockprämien erwirtschaftet, um die mit dem Mining verbundenen Kosten zu decken.
+
+### Mining-Kosten {#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 Sie in einem Pool minen, erheben die Pools in der Regel eine pauschale Gebühr in Höhe eines Prozentsatzes jedes vom Pool erzeugten Blocks
+- 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 weiter zu erkunden, kannst du einen Mining-Rechner verwenden, wie ihn [Etherscan](https://etherscan.io/ether-mining-calculator) anbietet.
+
+## Wie Ethereum-Transaktionen gemint werden {#how-ethereum-transactions-are-mined}
+
+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.
+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, so dass 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.
+ 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 (einschließen in einen neuen Block und zum ersten Mal propagiert), aber von jedem Teilnehmer im Prozess der Weiterentwicklung des kanonischen EVM-Zustands mehrfach abgearbeitet und verifiziert. Dies hebt eines der wichtigsten Mantras der Blockchain hervor: **Vertraue nicht, prüfe!**.
+
+## Eine visuelle Demo {#a-visual-demo}
+
+Schaue zu, wie Austin dich durch Mining und die Proof-of-Work-Blockchain führt.
+
+
+
+## Weiterführende Informationen {#further-reading}
+
+- [Was bedeutet es, Ethereum zu minen?](https://docs.ethhub.io/using-ethereum/mining/) _EthHub_
+
+## Verwandte Tools {#related-tools}
+
+- [Verwandte Themen](https://etherscan.io/stat/miner?range=7&blocktype=blocks)
+- [Etherscan-Mining-Rechner](https://etherscan.io/ether-mining-calculator)
+- [Minerstat-Mining-Rechner](https://minerstat.com/coin/ETH)
+
+## Verwandte Themen {#related-topics}
+
+- [Gas](/developers/docs/gas/)
+- [EVM](/developers/docs/evm/)
+- [Proof-of-Work](/developers/docs/consensus-mechanisms/pow/)
diff --git a/src/content/translations/de/developers/docs/dapps/index.md b/src/content/translations/de/developers/docs/dapps/index.md
new file mode 100644
index 00000000000..83a103133b1
--- /dev/null
+++ b/src/content/translations/de/developers/docs/dapps/index.md
@@ -0,0 +1,83 @@
+---
+title: Einführung in Dapps
+description:
+lang: de
+sidebar: true
+---
+
+Eine dezentralisierte Anwendung ([engl.] decentralized application, 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.
+
+## 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.
+
+## 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.
+
+- **Dezentralisiert** – Dapps arbeiten auf Ethereum, einer offenen, öffentlichen und dezentralen Plattform, auf der keine 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.
+
+### 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/).
+
+Ein Smart Contract ist ein Code, der auf der Ethereum-Blockchain existiert und genau wie programmiert abläuft. Sobald Smart Contracts im Netzwerk eingesetzt werden, kannst du sie nicht mehr ändern. Dapps können dezentralisiert sein, weil sie von der Logik kontrolliert werden, die in den Vertrag geschrieben ist, und nicht von einem Individuum oder einem Unternehmen. Das bedeutet auch, dass du deine Verträge sehr sorgfältig gestalten und gründlich testen musst.
+
+## 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 man einer zentralen Autorität 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. Darüber hinaus benötigt Proof-of-Work auch Zeit. Eine "Back-of-the-Envelope"-Rechnung setzt den Leistungsaufwand auf etwa das 1.000.000-Fache der Standardrechnung.
+- **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.
+
+## Eher ein visueller Lerner? {#visual-learner}
+
+
+
+## Werkzeuge für das Erstellen von Dapps {#dapp-tools}
+
+**Scaffold-ETH _- Experimentiere schnell mit Solidity, indem du ein Frontend verwendest, das sich an deinen Smart Contract anpasst._**
+
+- [GitHub](https://github.com/austintgriffith/scaffold-eth)
+- [Beispiel-Dapp](https://punkwallet.io/)
+
+**Eth App erstellen _– Erstelle Ethereum-gestützte Apps mit einem Befehl._**
+
+- [GitHub](https://github.com/paulrberg/create-eth-app)
+
+**One Click Dapp _– FOSS-Tool zur Erstellung von Dapp-Frontends aus einer [ABI](/glossary/#abi)._**
+
+- [oneclickdapp.com](https://oneclickdapp.com)
+- [GitHub](https://github.com/oneclickdapp/oneclickdapp-v1)
+
+**Etherflow _– FOSS-Tool für Ethereum-Entwickler, um ihre Nodes zu testen und RPC-Aufrufe vom Browser aus zu komponieren und zu debuggen._**
+
+- [etherflow.quiknode.io](https://etherflow.quiknode.io/)
+- [GitHub](https://github.com/abunsen/etherflow)
+
+## Weiterführende Informationen {#further-reading}
+
+- [Die Architektur einer Web 3.0 Anwendung](https://www.preethikasireddy.com/post/the-architecture-of-a-web-3-0-application) – _Preethi Kasireddy_
+- [Ein Leitfaden für dezentrale Anwendungen aus dem Jahr 2021](https://limechain.tech/blog/what-are-dapps-the-2021-guide/) – _LimeChain_
+- [Was sind dezentrale Apps?](https://www.gemini.com/cryptopedia/decentralized-applications-defi-dapps) – _Gemini_
+
+_Kennst du eine Community-Ressource, die dir geholfen hat? Bearbeite diese Seite und füge sie hinzu!_
+
+## Verwandte Themen {#related-topics}
+
+- [Eine Anleitung zum Ethereum-Stack](/developers/docs/ethereum-stack/)
+- [Entwicklungs-Frameworks](/developers/docs/frameworks/)
diff --git a/src/content/translations/de/developers/docs/evm/index.md b/src/content/translations/de/developers/docs/evm/index.md
new file mode 100644
index 00000000000..b8f79f98d59
--- /dev/null
+++ b/src/content/translations/de/developers/docs/evm/index.md
@@ -0,0 +1,80 @@
+---
+title: Ethereum Virtual Machine (EVM)
+description: Eine Einführung in die virtuelle Maschine von Ethereum und wie sie sich auf Zustand, Transaktionen und Smart Contracts bezieht.
+lang: de
+sidebar: true
+---
+
+Die physische Überschreibung der EVM kann nicht auf dieselbe Weise beschrieben werden, wie eine Wolke oder Ozeanwelle. Sie _existiert_ vielmehr als eine zusammenhängende Einheit, die von tausenden verbundenen Computern, die einen Ethereum-Client laufen lassen, aufrechterhalten wird.
+
+Das Ethereum-Protokoll selbst besteht ausschließlich zu dem Zweck, den kontinuierlichen, ununterbrochenen und unveränderlichen Betrieb dieser speziellen Zustandsmaschine aufrechtzuerhalten. Es ist das Umfeld, in dem alle Ethereum-Konten und Smart Contracts existieren. Bei jedem Block in der Kette hat Ethereum genau einen "kanonischen" Zustand und die EVM definiert die Regeln für die Berechnung eines neuen gültigen Zustands von Block zu Block.
+
+## 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]() notwendig. Es wäre auch hilfreich, wenn du dich mit Kryptografie-/Blockchain-Konzepten wie [Hash-Funktionen](https://wikipedia.org/wiki/Cryptographic_hash_function), [Proof-of-Work](https://wikipedia.org/wiki/Proof_of_work) und dem [Merkle-Baum](https://wikipedia.org/wiki/Merkle_tree) auskennst.
+
+## Vom Ledger 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. Eine Kryptowährung verhält sich wie eine "normale" Währung, da es Regeln gibt, die bestimmen, was man tun kann und was nicht, 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.
+
+![Ein Diagramm, das die Funktionsweise eines Kontos zeigt](./evm.png) _Diagramm angepasst von [Ethereum EVM illustriert](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+
+## 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:
+
+```
+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'`.
+
+### Zustand {#state}
+
+Im Rahmen von Ethereum ist der Zustand eine enorme Datenstruktur, die eine [ modifizierte Merkle-Patricia-Trie](https://eth.wiki/en/fundamentals/patricia-tree) genannt wird, die alle [Konten](/developers/docs/accounts/) durch Hashes verbunden hält und mit einem einzigen Root-Hash in der Blockchain abrufbar 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.
+
+## 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.
+
+Während der Ausführung behält die EVM einen transienten _-Speicher_ (als wortadressiertes Byte-Array), der zwischen Transaktionen nicht vorhanden 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.
+
+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.
+
+![Ein Diagramm, das zeigt, wo Gas im EVM-Betrieb benötigt wird](../gas/gas.png) _Diagramm angepasst von [Ethereum EVM illustriert](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 fünfjährigen Geschichte von Ethereum hat die EVM mehrere Revisionen durchlaufen und es gibt mehrere Implementierungen der EVM in verschiedenen Programmiersprachen.
+
+Alle [Ethereum-Clients](/developers/docs/nodes-and-clients/#execution-clients) enthalten eine EVM-Implementierung. Zusätzlich gibt es mehrere Standalone-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_
+- [eEVM](https://github.com/microsoft/eevm) - _C++_
+- [Hyperledger Burrow](https://github.com/hyperledger/burrow) - _Go_
+
+## Weiterführende Informationen {#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/)
+- [Eine kurze Einführung in die Dokumentation von Solidity](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html#index-6)
+
+## Verwandte Themen {#related-topics}
+
+- [Gas](/developers/docs/gas/)
diff --git a/src/content/translations/de/developers/docs/gas/index.md b/src/content/translations/de/developers/docs/gas/index.md
new file mode 100644
index 00000000000..aac820be27c
--- /dev/null
+++ b/src/content/translations/de/developers/docs/gas/index.md
@@ -0,0 +1,171 @@
+---
+title: Gas und Gebühren
+description:
+lang: de
+sidebar: true
+---
+
+Gas ist für das Ethereum-Netzwerk unerlässlich. Es ist der Treibstoff, der Ethereum den Betrieb ermöglicht, so wie ein Auto Benzin braucht, um zu fahren.
+
+## Voraussetzungen {#prerequisites}
+
+Um diese Seite besser zu verstehen, empfehlen wir dir, zuerst [Transaktionen](/developers/docs/transactions/) und [Blöcke](/developers/docs/evm/) zu lesen.
+
+## Was ist Gas? {#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 Ethereum-Transaktion Rechenressourcen benötigt, um ausgeführt zu werden, wird für jede Transaktion eine Gebühr fällig. Gas bezieht sich auf die Gebühr, die erforderlich ist, um eine Transaktion auf Ethereum erfolgreich durchzuführen.
+
+![Ein Diagramm, das zeigt, wo Gas im EVM-Betrieb benötigt wird](./gas.png) _Diagramm angepasst von [Ethereum EVM illustriert](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+
+Im Wesentlichen werden Gasgebühren in Ethereums Eigenwährung, Ether (ETH) gezahlt. Die Gaspreise sind in Gwei angegeben, was selbst eine Bezeichnung für ETH ist. Jeder Gwei ist gleich 0,00000001 ETH (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" selbst bedeutet "giga-wei" und entspricht 1.000.000.000 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.
+
+## Vor dem London-Upgrade {#pre-london}
+
+Die Art und Weise, wie die Transaktionsgebühren im Ethereum-Netzwerk berechnet wurden, änderte sich mit dem [London-Upgrade](/history/#london) vom August 2021. Hier ist eine Zusammenfassung, wie die Dinge früher funktionierten:
+
+Nehmen wir an, Alice müsste Bob 1 ETH zahlen. Bei der Transaktion liegt das Gaslimit bei 21.000 Einheiten und der Gaspreis bei 200 gwei.
+
+Die Gesamtgebühr wäre gewesen: `Gaseinheiten (Limit) * Gaspreis pro Einheit`, d. h. `21.000 * 200 = 4.200.000 gwei` oder 0,0042 ETH.
+
+Wenn Alice das Geld schickt, werden 1,0042 ETH von ihrem Konto abgezogen. Bob würden 1,0000 ETH gutgeschrieben werden. Der Miner würde 0,0042 ETH erhalten.
+
+Dieses Video bietet einen kurzen Überblick über Gas und warum es existiert:
+
+
+
+## Nach dem London-Upgrade {#post-london}
+
+[Das London-Upgrade](/history/#london) wurde am 5. August 2021 eingeführt, um Transaktionen auf Ethereum für die Nutzer berechenbarer zu machen, indem der Transaktionsgebühren-Mechanismus von Ethereum überarbeitet wurde. Zu den wichtigsten Vorteilen dieser Änderung gehören eine bessere Schätzung der Transaktionsgebühren, eine allgemein schnellere Aufnahme von Transaktionen und die Kompensation der ETH-Ausgabe durch das Verbrennen eines Prozentsatzes der Transaktionsgebühren.
+
+Seit dem Upgrade des Londoner Netzes gibt es für jeden Block eine Grundgebühr, den Mindestpreis pro Gaseinheit für die Aufnahme in diesen Block, der vom Netz auf der Grundlage der Nachfrage nach Blockraum berechnet wird. Da die Grundgebühr der Transaktionsgebühr verbrannt wird, wird von den Nutzern erwartet, dass sie bei ihren Transaktionen auch ein Trinkgeld (Prioritätsgebühr) festlegen. Das Trinkgeld entschädigt die Miner für die Ausführung und Weitergabe von Nutzertransaktionen in Blöcken und wird voraussichtlich von den meisten Wallets automatisch festgelegt.
+
+Die Berechnung der gesamten Transaktionsgebühr funktioniert wie folgt: `Gaseinheiten (Limit) * (Grundgebühr + Trinkgeld)`
+
+Sagen wir, Jordan muss Taylor 1 ETH zahlen. Bei der Transaktion liegt das Gaslimit bei 21.000 Einheiten und die Grundgebühr bei 100 gwei. Jordan enthält ein Trinkgeld von 10 gwei.
+
+Mit der obigen Formel können wir dies als `21.000 * (100 + 10) = 2.310.000 gwei` oder 0,00231 ETH berechnen.
+
+Wenn Jordan das Geld schickt, werden 1,00231 ETH von seinem Konto abgezogen. Taylor werden 1,0000 ETH gutgeschrieben. Der Miner erhält das Trinkgeld von 0,00021 ETH. Die Grundgebühr von 0,0021 ETH wird verbrannt.
+
+Zusätzlich kann Jordan auch eine maximale Gebühr (`maxFeePerGas`) für die Transaktion festlegen. Die Differenz zwischen der Höchstgebühr und der tatsächlichen Gebühr wird Jordan zurückerstattet, d. h. `Erstattung = Höchstgebühr - (Grundgebühr + Prioritätsgebühr)`. Jordan kann einen Höchstbetrag für die Ausführung der Transaktion festlegen und muss sich keine Sorgen machen, dass er "über" die Grundgebühr hinaus zahlt, wenn die Transaktion ausgeführt wird.
+
+### Blockgröße {#block-size}
+
+Vor dem London-Upgrade hatte Ethereum Blöcke mit fester Größe. In Zeiten hoher Netznachfrage waren diese voll ausgelastet. Infolgedessen mussten die Nutzer/Nutzerinnen oft warten, bis die hohe Nachfrage nachließ, um in einen Block aufgenommen zu werden, was zu einem schlechten Nutzererlebnis führte.
+
+Mit dem London-Upgrade wurden in Ethereum Blöcke mit variabler Größe eingeführt. 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 30 Millionen Gas (2x die Zielblockgröße). Das Protokoll erreicht durch den Prozess des _Tâtonnement_ eine gleichgewichtige Blockgröße von durchschnittlich 15 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/).
+
+### Grundgebühr {#base-fee}
+
+Jeder Block hat eine Grundgebühr, die als Reservepreis dient. 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. Wenn der Block abgebaut wird, wird diese Grundgebühr "verbrannt" und aus dem Verkehr gezogen.
+
+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.
+
+| 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 |
+
+Im Vergleich zum Markt vor der Londoner Gasauktion führt diese Änderung des Transaktionsgebühren-Mechanismus dazu, dass die Gebührenvorhersage zuverlässiger ist. 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 zum nächsten Block hinzugefügt werden soll, `aktuelle Grundgebühr * 112,5%` oder `202,8 gwei * 112,5% = 228,1 gwei` ist.
+
+Außerdem ist es unwahrscheinlich, dass wir längere Spitzen von vollen Blöcken sehen werden, weil die Grundgebühr bei einem vollen Block so schnell steigt.
+
+| 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 |
+
+### Prioritätsgebühr (Trinkgeld) {#priority-fee}
+
+Vor dem London-Upgrade erhielten die Miner die gesamte Gasgebühr für jede in einem Block enthaltene Transaktion.
+
+Da die neue Grundgebühr verbrannt wurde, führte das London-Upgrade eine Prioritätsgebühr (Trinkgeld) ein, um Minern einen Anreiz zu geben, eine Transaktion in den Block aufzunehmen. Ohne Trinkgelder würde es sich für Miner lohnen, leere Blöcke abzubauen, da sie die gleiche Blockbelohnung erhalten würden. Unter normalen Bedingungen bietet ein kleines Trinkgeld den Minern einen minimalen Anreiz, eine Transaktion durchzuführen. Für Transaktionen, die vor anderen Transaktionen im selben Block bevorzugt ausgeführt werden müssen, ist ein höheres Trinkgeld notwendig, um konkurrierende Transaktionen zu überbieten.
+
+### 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 zahlen. 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.
+
+### Berechnung der Gebühren {#calculating-fees}
+
+Einer der Hauptvorteile des London-Upgrades ist die Verbesserung der Benutzererfahrung bei der Festlegung der Transaktionsgebühren. Bei Wallets, die das Upgrade unterstützen, geben die Wallet-Anbieter nicht mehr explizit an, wie viel du bereit bist, für deine Transaktion zu zahlen, sondern legen automatisch eine empfohlene Transaktionsgebühr fest (Grundgebühr + empfohlene Prioritätsgebühr), um die Komplexität für ihre Nutzer zu reduzieren.
+
+## EIP-1559 {#eip-1559}
+
+Die Implementierung der [EIP-1559](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md) im London-Upgrade hat den Mechanismus der Transaktionsgebühren komplexer gemacht als die vorherige Gaspreisauktion. Dies hat aber den Vorteil, dass die Gasgebühren berechenbarer sind, was zu einem effizienteren Markt für Transaktionsgebühren führt. Nutzer können Transaktionen mit einem `maxFeePerGas` einreichen, der angibt, wie viel sie bereit sind, für die Ausführung der Transaktion zu zahlen. Dabei können sie sicher sein, dass sie nicht mehr als den Marktpreis für Gas (`baseFeePerGas`) zahlen und alles, was darüber hinausgeht, abzüglich ihres Trinkgelds zurückerstattet bekommen.
+
+Dieses Video erklärt EIP-1559 und die Vorteile, die es bringt:
+
+
+
+Wenn du interessiert bist, kannst du hier die genauen [EIP-1559 Spezifikationen](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md) nachlesen.
+
+Gehe mit diesem Link weiter in den Kaninchenbau hinein: [EIP-1559 Resources](https://hackmd.io/@timbeiko/1559-resources).
+
+## Warum gibt es Gasgebühren? {#why-do-gas-fees-exist}
+
+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 schlechte Akteure das Netzwerk spammen. Um versehentliche oder feindliche Endlosschleifen oder andere Rechenverschwendung 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).
+
+![Ein Diagramm, das zeigt, wie ungenutztes Gas zurückerstattet wird](../transactions/gas-tx.png) _Diagramm angepasst von [Ethereum EVM illustriert](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 du bei einer Transaktion verbrauchen möchtest. Kompliziertere Transaktionen mit [smarten Verträgen](/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.
+
+Wenn du zum Beispiel ein Gaslimit von 50.000 für einen einfachen ETH-Transfer festlegen würdest, würde die EVM 21.000 verbrauchen und du würdest die restlichen 29.000 zurückbekommen. Wenn du jedoch zu wenig Gas angibst, z. B. ein Gaslimit von 20.000 für einen einfachen ETH-Transfer, wird die EVM deine 20.000 Gaseinheiten verbrauchen und versuchen, die Transaktion durchzuführen, aber sie wird nicht abgeschlossen. Die EVM macht dann alle Änderungen rückgängig, aber da der Miner bereits Arbeit im Wert von 20.000 Gaseinheiten geleistet hat, ist dieses Gas verbraucht.
+
+## Warum können die Gasgebühren so hoch sein? {#why-can-gas-fees-get-so-high}
+
+Die hohen Gasgebühren sind auf die Beliebtheit von Ethereum zurückzuführen. Für jede Operation auf Ethereum muss Gas verbraucht werden, und der Gasplatz ist pro Block begrenzt. Zu den Gebühren gehören Berechnungen, das Speichern oder Verarbeiten von Daten oder die Übertragung von Token, die unterschiedliche Mengen von "Gas"-Einheiten verbrauchen. Je komplexer die Funktionalität einer App wird, desto mehr Operationen führt ein Smart Contract aus, was bedeutet, dass jede Transaktion mehr Platz in einem Block begrenzter Größe einnimmt. Wenn die Nachfrage zu groß ist, müssen die Nutzer/Nutzerinnen einen höheren Trinkgeldbetrag anbieten, um zu versuchen, die Transaktionen anderer Nutzer/Nutzerinnen zu überbieten. Ein höheres Trinkgeld kann die Wahrscheinlichkeit erhöhen, dass deine Transaktion in den nächsten Block gelangt.
+
+Wie viel wir für eine bestimmte Transaktion bezahlen müssen, wird nicht allein durch den Gaspreis bestimmt. Um die Transaktionsgebühr zu berechnen, müssen wir das verbrauchte Gas mit der Transaktionsgebühr multiplizieren, die in gwei gemessen wird.
+
+## Initiativen zur Senkung der Gaskosten {#initiatives-to-reduce-gas-costs}
+
+Die Ethereum-[Skalierbarkeits-Upgrades](/upgrades/) sollten letztendlich einige der Probleme mit den Gasgebühren lösen, was wiederum die Plattform in die Lage versetzen 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. [Mehr zur Skalierung mit Layer 2](/developers/docs/scaling/#layer-2-scaling)
+
+Das neue Proof-of-Stake-Modell, das auf der Beacon Chain eingeführt wurde, soll den hohen Stromverbrauch und die Abhängigkeit von spezieller Hardware reduzieren. Diese Kette wird es dem dezentralen Ethereum-Netzwerk ermöglichen, sich zu verständigen und das Netzwerk sicher zu halten, während der Energieverbrauch begrenzt wird, indem stattdessen ein finanzielles Commitment verlangt wird.
+
+Jeder, der mindestens 32 ETH besitzt, kann diese einsetzen, um ein Validator zu werden, welcher für die Verarbeitung von Transaktionen, die Validierung von Blöcken und das Vorschlagen neuer Blöcke für die Kette verantwortlich ist. Nutzer mit weniger als 32 ETH können an Staking-Pools teilnehmen.
+
+## Strategien zur Senkung der Gaskosten {#strategies-for-you-to-reduce-gas-costs}
+
+Wenn du die Gaskosten für deine ETH senken willst, kannst du ein Trinkgeld setzen, um die Prioritätsstufe deiner Transaktion anzugeben. Die Miner werden Transaktionen mit einem höheren Trinkgeld pro Gas "bearbeiten" und ausführen, da sie die von dir gezahlten Trinkgelder behalten können und weniger geneigt sind, Transaktionen mit niedrigeren Trinkgeldern auszuführen.
+
+Wenn du die Gaspreise überwachen willst, damit du deine ETH günstiger verschicken kannst, kannst du viele verschiedene Tools nutzen, wie z. B.:
+
+- [Etherscan](https://etherscan.io/gastracker) _Transaktionsgaspreis-Schätzer_
+- [Blocknative ETH Gas Estimator](https://chrome.google.com/webstore/detail/blocknative-eth-gas-estim/ablbagjepecncofimgjmdpnhnfjiecfm) _Gasschätzungs-Chrome-Erweiterung, die sowohl Typ 0 Legacy-Transaktionen als auch Typ 2 EIP-1559-Transaktionen unterstützt_
+
+- [ETH-Tankstelle](https://ethgasstation.info/) _Verbraucherorientierte Metriken für den Ethereum-Gasmarkt _
+- [Cryptoneur-Gasgebührenrechner](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._
+
+## Verwandte Tools {#related-tools}
+
+- [Bloxy Gas Analytics](https://stat.bloxy.info/superset/dashboard/gas/?standalone=true) _Netzwerk-Gas-Statistik_
+- [Blocknative's Gas Platform](https://www.blocknative.com/gas) _Gas Schätzung API powered by Blocknative's global mempool data platform_
+
+## Weiterführende Informationen {#further-reading}
+
+- [Ethereum Gas erklärt](https://defiprime.com/gas)
+- [Wird die Nutzung von Ethereum mit steigendem Preis teurer?](https://docs.ethhub.io/questions-about-ethereum/is-ethereum-more-expensive-to-use-as-price-rises/)
+- [Reduziere den Gasverbrauch deiner Smart Contracts](https://medium.com/coinmonks/8-ways-of-reducing-the-gas-consumption-of-your-smart-contracts-9a506b339c0a)
+- [Proof-of-Stake vs. Proof-of-Work](https://blockgeeks.com/guides/proof-of-work-vs-proof-of-stake/)
+
+## Verwandte Themen {#related-topics}
+
+- [Mining](/developers/docs/consensus-mechanisms/pow/mining/)
diff --git a/src/content/translations/de/developers/docs/index.md b/src/content/translations/de/developers/docs/index.md
new file mode 100644
index 00000000000..f15bea6d8af
--- /dev/null
+++ b/src/content/translations/de/developers/docs/index.md
@@ -0,0 +1,26 @@
+---
+title: Ethereum-Entwicklungs-Dokumentation
+description: Einführung in die ethereum.org-Entwicklerdokumentation.
+lang: de
+sidebar: true
+---
+
+Diese Dokumentation soll dir helfen, mit Ethereum zu entwickeln. Es umfasst Ethereum als Konzept, erklärt den Ethereum-Technologie-Stack, dokumentiert fortgeschrittene Themen für komplexere Anwendungen und Anwendungsfälle.
+
+Dies ist eine Open-Source-Community-Anstrengung, also zögere nicht, neue Themen vorzuschlagen oder neue Inhalte hinzuzufügen, und gib Beispiele an, wo immer du denkst, dass dies hilfreich sein könnte. Alle Entwicklerdokumentationen können auf GitHub editiert werden. Falls du dir nicht sicher bist wie, [folge einfach dieser Anleitung](https://github.com/ethereum/ethereum-org-website/blob/dev/docs/contributing/editing-markdown.md).
+
+## Entwicklungsmodule {#development-modules}
+
+Wenn dies dein erster Versuch bei der Entwicklung mit Ethereum ist, empfehlen wir dir, ganz vorne zu beginnen und dich wie bei einem Buch durchzuarbeiten.
+
+### Grundsätzliche Themen {#foundational-topics}
+
+
+
+### Ethereum-Stack {#ethereum-stack}
+
+
+
+### Fortgeschritten {#advanced}
+
+
diff --git a/src/content/translations/de/developers/docs/intro-to-ether/index.md b/src/content/translations/de/developers/docs/intro-to-ether/index.md
new file mode 100644
index 00000000000..7d3fc4171da
--- /dev/null
+++ b/src/content/translations/de/developers/docs/intro-to-ether/index.md
@@ -0,0 +1,78 @@
+---
+title: Einführung in Ether
+description: Eine Einführung für Entwickler in die Kryptowährung Ether.
+lang: de
+sidebar: true
+---
+
+## Voraussetzungen {#prerequisites}
+
+Damit du diese Seite besser verstehst, empfehlen wir dir, zuerst [Einführung in Ethereum](/developers/docs/intro-to-ethereum/) zu lesen.
+
+## Was ist eine Kryptowährung? {#what-is-a-cryptocurrency}
+
+Eine Kryptowährung ist ein Tauschmittel, das durch ein Blockchain-basiertes Ledger gesichert ist.
+
+Ein Tauschmittel ist alles, was allgemein als Zahlungsmittel für Waren und Dienstleistungen akzeptiert wird, und ein Ledger ist ein Datenspeicher, der die Transaktionen aufzeichnet. Die Blockchain-Technologie ermöglicht es den Nutzern, Transaktionen auf dem Ledger durchzuführen, ohne sich auf eine vertrauenswürdige dritte Partei zu verlassen, die dieses verwaltet.
+
+Die erste Kryptowährung war Bitcoin, die vom Pseudonym Satoshi Nakamoto erschaffen wurde. Seit der Veröffentlichung von Bitcoin im Jahr 2009 haben Menschen Tausende von Kryptowährungen auf vielen verschiedenen Blockchains geschaffen.
+
+## Was ist Ether? {#what-is-ether}
+
+**Ether (ETH)** ist die Kryptowährung, die für viele Dinge im Ethereum-Netzwerk verwendet wird. Grundsätzlich ist es die einzig akzeptable Form der Bezahlung von Transaktionsgebühren, und nach [The Merge](/upgrades/merge) wird Ether erforderlich sein, um Blöcke im Mainnet zu validieren und vorzuschlagen. Ether werden u. a. auch als primäre Form von Sicherheiten auf den [DeFi](/defi)-Kreditmärkten, als Rechnungseinheit auf NFT-Marktplätzen, als Bezahlung für die Erbringung von Dienstleistungen oder für den Verkauf von Gütern in der realen Welt und mehr verwendet.
+
+Ethereum ermöglicht es Entwicklern, [**dezentrale Anwendungen (dapps)**](/developers/docs/dapps) zu erstellen, die sich alle einen Pool von Rechenleistung teilen. Da dieser gemeinsame Pool endlich ist, braucht Ethereum einen Mechanismus, um zu bestimmen, wer ihn nutzen darf. Andernfalls könnte eine App versehentlich oder böswillig alle Netzwerkressourcen verbrauchen, was anderen den Zugriff auf die App verwehren würde.
+
+Die Kryptowährung Ether unterstützt einen Preismechanismus für die Rechenleistung von Ethereum. Wenn Nutzer/Nutzerinnen eine Transaktion durchführen wollen, müssen sie Ether bezahlen, damit ihre Transaktion auf der Blockchain anerkannt wird. Diese Nutzungskosten werden als [Gasgebühren](/developers/docs/gas/) bezeichnet, und die Gasgebühr hängt von der Menge an Rechenleistung ab, die für die Ausführung der Transaktion benötigt wird, sowie von der netzwerkweiten Nachfrage nach Rechenleistung zu diesem Zeitpunkt.
+
+Selbst wenn eine böswillige Dapp eine Endlosschleife einreichen würde, ginge der Transaktion irgendwann der Ether aus und sie würde beendet, so dass das Netzwerk wieder zur Normalität zurückkehren könnte.
+
+Es ist [üblich](https://www.reuters.com/article/us-crypto-currencies-lending-insight-idUSKBN25M0GP#:~:text=Preis%20von%20Ethereum) [](https://abcnews.go.com/Business/bitcoin-slumps-week-low-amid-renewed-worries-chinese/story?id=78399845#:~:text=Kryptowährungen%20inklusive%20Ethereum) [](https://www.cnn.com/2021/03/14/tech/nft-art-buying/index.html#:~:text=Preis%20von%20Ethereum), Ethereum und Ether zu verwechseln; wenn Leute den "Preis von Ethereum" erwähnen, beschreiben sie den Preis von Ether.
+
+## Ether-Minting {#minting-ether}
+
+Minting ist der Prozess, bei dem neuer Ether im Ethereum-Ledger erstellt wird. Das zugrundeliegende Ethereum-Protokoll erstellt den neuen Ether, und es ist nicht möglich, dass ein Nutzer Ether erstellt.
+
+Ether wird gemintet, wenn ein Miner einen Block auf der Ethereum-Blockchain erstellt. Als Anreiz für Miner gewährt das Protokoll in jedem Block eine Belohnung, die das Guthaben einer Adresse erhöht, die vom Miner des Blocks festgelegt wurde. Die Blockbelohnung hat sich im Laufe der Zeit geändert und beträgt heute 2 ETH pro Block.
+
+## Ether verbrennen {#burning-ether}
+
+Neben der Erzeugung von Ether durch Blockprämien kann Ether auch durch einen Prozess namens "Verbrennen" zerstört werden. Wenn Ether verbrannt wird, wird er dauerhaft aus dem Verkehr gezogen.
+
+Bei jeder Transaktion auf Ethereum wird Ether verbrannt. Wenn Nutzer für ihre Transaktionen bezahlen, wird eine grundlegende Gasgebühr vernichtet, die vom Netzwerk entsprechend der Transaktion festgelegt wird. Dies, zusammen mit variablen Blockgrößen und einer maximalen Gasgebühr, vereinfacht die Abschätzung der Transaktionsgebühren auf Ethereum. Wenn die Nachfrage im Netzwerk hoch ist, können [Blöcke](https://etherscan.io/block/12965263) mehr Ether verbrauchen, als sie minten, wodurch die Ausgabe von Ether effektiv ausgeglichen wird.
+
+Die Verbrennung der Grundgebühr verhindert diverse Möglichkeiten der Miner zur Manipulation. Wenn beispielsweise die Miner ihre Grundgebühr erhalten, können sie ihre eigenen Transaktionen kostenlos einbeziehen und die Grundgebühr für alle anderen erhöhen. Alternativ könnten sie die Grundgebühr an einige Nutzer außerhalb der Kette zurückerstatten, was zu einem undurchsichtigen und komplexen Markt für Transaktionsgebühren führen würde.
+
+## Stückelung von Ether {#denominations}
+
+Da viele Transaktionen auf Ethereum klein sind, hat Ether mehrere Stückelungen, die für kleinere Beträge referenziert werden können. Von diesen Stückelungen sind Wei und gwei besonders wichtig.
+
+Wei ist die kleinstmögliche Menge an Ether. Daher basieren viele technische Implementierungen, wie das [Ethereum Yellowpaper](https://ethereum.github.io/yellowpaper/paper.pdf), auf Berechnungen in Wei.
+
+Gwei, kurz für Giga-Wei, wird oft verwendet, um die Gaskosten auf Ethereum zu beschreiben.
+
+| Stückelung | Wert in Ether | Häufige Verwendung |
+| ---------- | ---------------- | ------------------------------ |
+| Wei | 10-18 | Technische Implementierungen |
+| Gwei | 10-9 | Menschlich lesbare Gasgebühren |
+
+## Überweisung von Ether {#transferring-ether}
+
+Jede Transaktion auf Ethereum enthält ein `Wert`-Feld, das den zu überweisenden Ether-Betrag in Wei angibt, der von der Adresse des Absenders an die Adresse des Empfängers gesendet wird.
+
+Wenn es sich bei der Empfängeradresse um einen [Smart Contract](/developers/docs/smart-contracts/) handelt, kann dieser übertragene Ether zum Bezahlen von Gas verwendet werden, wenn der Smart Contract seinen Code ausführt.
+
+[Weitere Informationen zu Transaktionen](/developers/docs/transactions/)
+
+## Ether-Saldo abfragen {#querying-ether}
+
+Nutzer können den Ether-Saldo jedes [Kontos](/developers/docs/accounts/) abfragen, indem sie das `Saldo`-Feld des Kontos einsehen, das den Ether-Bestand in Wei anzeigt.
+
+[Etherscan](https://etherscan.io) ist ein beliebtes Tool zur Überprüfung von Adresssalden über eine webbasierte Anwendung. Zum Beispiel zeigt [diese Etherscan-Seite](https://etherscan.io/address/0xde0b295669a9fd93d5f28d9ec85e40f4cb697bae) den Kontostand der Ethereum Foundation.
+
+## Weiterführende Informationen {#further-reading}
+
+- [Definition von Ether und Ethereum](https://www.cmegroup.com/education/courses/introduction-to-ether/defining-ether-and-ethereum.html) - _CME Group_
+- [Ethereum Whitepaper](/whitepaper/): Der ursprüngliche Vorschlag für Ethereum. Dieses Dokument enthält eine Beschreibung von Ether und der Beweggründe für seine Entstehung.
+
+_Kennst du eine Community-Ressource, die dir geholfen hat? Bearbeite diese Seite und füge sie hinzu!_
diff --git a/src/content/translations/de/developers/docs/intro-to-ethereum/index.md b/src/content/translations/de/developers/docs/intro-to-ethereum/index.md
new file mode 100644
index 00000000000..f1e151999c0
--- /dev/null
+++ b/src/content/translations/de/developers/docs/intro-to-ethereum/index.md
@@ -0,0 +1,121 @@
+---
+title: Einleitung zu Ethereum
+description: Die Einführung eines dApp Entwicklers in die Kernkonzepte von Ethereum.
+lang: de
+sidebar: true
+---
+
+## Was ist eine Blockchain? {#what-is-a-blockchain}
+
+Eine Blockchain wird am besten als öffentliche Datenbank beschrieben, die über viele Computer in einem Netzwerk aktualisiert und geteilt wird.
+
+"Block" bezieht sich auf die Tatsache, dass Daten und Zustand in sequenziellen Batches oder "Blocks" gespeichert werden. Wenn du ETH an jemand anderen sendest, müssen die Transaktionsdaten zu einem Block hinzugefügt werden, damit der Vorgang erfolgreich ist.
+
+"Chain" bezieht sich auf die Tatsache, dass jeder Block kryptographisch auf seinen vorherigen Block verweist. Mit anderen Worten: Blöcke werden aneinandergekettet. Die Daten in einem Block können sich nicht ändern, ohne alle nachfolgenden Blöcke zu ändern, was den Konsens des gesamten Netzwerks erfordern würde.
+
+Jeder Computer im Netzwerk muss jedem neuen Block und der Kette als Ganzes zustimmen. Diese Computer werden als " Nodes" bezeichnet. Die Nodes stellen sicher, dass jeder, der mit der Blockchain interagiert, die gleichen Daten hat. Um diese verteilte Vereinbarung zu erreichen, brauchen Blockchains einen Konsensmechanismus.
+
+Ethereum verwendet derzeit einen [Proof-of-Work](/developers/docs/consensus-mechanisms/pow/)-Konsensmechanismus. Das bedeutet, dass jeder, der neue Blöcke zur Kette hinzufügen möchte, ein schwieriges Rätsel lösen muss, für das viel Rechenleistung benötigt wird. Das Lösen des Puzzles "beweist", dass die Rechenressourcen verwendet wurden. Dies wird als [Mining](/developers/docs/consensus-mechanisms/pow/mining/) bezeichnet. Mining funktioniert nach einem rauen Versuch-und-Fehler-Prinzip, aber das erfolgreiche Hinzufügen eines Blocks wird in ETH belohnt.
+
+Neue Blöcke werden an die Nodes im Netzwerk gesendet, geprüft und verifiziert, wodurch der Zustand der Blockchain für alle aktualisiert wird.
+
+Zusammenfassend lässt sich also festhalten: Wenn du ETH an jemanden sendest, muss die Transaktion gemint und in einen neuen Block aufgenommen werden. Der aktualisierte Zustand wird dann mit dem gesamten Netzwerk geteilt.
+
+Schau dir an, wie Austin dich durch Blockchains führt:
+
+
+
+Wenn du sehen willst, wie die Blockchain Daten hasht und der vorherige Block auf alle vorherigen Blöcke verweist, solltest du dir [diese Demo](https://andersbrownworth.com/blockchain/blockchain) von Anders Brownworth und das dazugehörige Video unten ansehen.
+
+Schau dir an, wie Anders Hashes in Blockchains erklärt:
+
+
+
+## Was ist Ethereum? {#what-is-ethereum}
+
+Im Ethereum-Universum gibt es einen einzigen kanonischen Computer (genannt die Ethereum virtuelle Maschine oder kurz EVM), dessen Zustand jeder im Ethereum-Netzwerk zustimmt. Jeder, der am Ethereum-Netzwerk (jeder Ethereum-Node) teilnimmt, behält eine Kopie des Zustands dieses Computers. Zusätzlich kann jeder Teilnehmer eine Anfrage an diesen Computer senden, um beliebige Berechnungen durchzuführen. Wenn eine solche Anfrage gesendet wird, überprüfen andere Teilnehmer/Teilnehmerinnen im Netzwerk die Berechnung und führen sie aus ("execute"). Diese Ausführung führt zu einer Zustandsänderung in der EVM, die bestätigt und im gesamten Netzwerk verbreitet wird.
+
+Rechenanfragen werden als Transaktionsanfragen bezeichnet; die Aufzeichnung aller Transaktionen und des aktuellen Zustands der EVM wird auf der Blockchain gespeichert, die wiederum von allen Nodes gespeichert und vereinbart wird.
+
+Kryptographische Mechanismen stellen sicher, dass Transaktionen, die einmal als gültig verifiziert und in die Blockchain aufgenommen wurden, später nicht mehr manipuliert werden können. Dieselben Mechanismen stellen auch sicher, dass alle Transaktionen signiert und mit den entsprechenden "Berechtigungen" ausgeführt werden (niemand außer Alice selbst sollte in der Lage sein, digitale Vermögenswerte von ihrem Konto zu versenden).
+
+## Was ist Ether? {#what-is-ether}
+
+**Ether (ETH)** ist die einheimische Kryptowährung von Ethereum. Der Zweck von Ether ist es, einen Markt für Berechnungen zu ermöglichen. Ein solcher Markt bietet einen wirtschaftlichen Anreiz für die Teilnehmer/Teilnehmerinnen, Transaktionsanfragen zu verifizieren und auszuführen und dem Netzwerk Rechenressourcen zur Verfügung zu stellen.
+
+Jeder Teilnehmer, der eine Transaktionsanfrage sendet, muss dem Netzwerk auch einen bestimmten Betrag an Ether als Kopfgeld anbieten. Dieses Kopfgeld erhält derjenige, der die Transaktion verifiziert, ausführt, in die Blockchain einträgt und an das Netzwerk weiterleitet.
+
+Die Menge an Ether, die bezahlt wird, entspricht der Zeit, die für die Berechnung benötigt wird. Diese Kopfgelder verhindern auch, dass böswillige Teilnehmer/Teilnehmerinnen das Netzwerk absichtlich verstopfen, indem sie die Ausführung von unendlichen Berechnungen oder anderen ressourcenintensiven Skripten anfordern, da diese Teilnehmer für die Rechenzeit bezahlen müssen.
+
+## Was sind Smart Contracts? {#what-are-smart-contracts}
+
+In der Praxis schreiben die Teilnehmer/Teilnehmerinnen 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 hochgeladen und durch das Netzwerk ausgeführt werden, Smart Contracts (intelligente Verträge).
+
+Ganz grundsätzlich kannst du dir 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 Händler-Smart-Contract das Eigentum an einem digitalen Vermögenswert erstellen und zuweisen, wenn der Interessent einem bestimmten Empfänger Ether sendet.
+
+Jeder Entwickler kann einen Smart Contract erstellen und im Netzwerk öffentlich machen, während die Blockchain als Datenschicht gegen eine Gebühr an das Netzwerk genutzt wird. Jeder Benutzer kann dann, wiederum gegen eine Gebühr an das Netzwerk, den Smart Contract aufrufen, um seinen Code auszuführen.
+
+Mit Smart Contracts können Entwickler/Entwicklerinnen beliebig komplexe nutzerorientierte Apps und Dienste entwickeln und bereitstellen, wie z. B. Marktplätze, Finanzinstrumente, Spiele etc.
+
+## Terminologie {#terminology}
+
+### Blockchain {#blockchain}
+
+Die Sequenz aller Blöcke, die dem Ethereum-Netzwerk in der Geschichte des Netzwerks übertragen wurden. So benannt, weil jeder Block einen Verweis auf den vorherigen Block enthält, was uns hilft, eine Zuordnung über alle Blöcke (und damit über die genaue Historie) aufrechtzuerhalten.
+
+### ETH {#eth}
+
+Die native Kryptowährung von Ethereum. Nutzer zahlen Ether an andere Nutzer, damit ihre Code-Ausführungsanfragen erfüllt werden.
+
+[Mehr zu ETH](/developers/docs/intro-to-ether/)
+
+### EVM {#evm}
+
+Die Ethereum Virtual Machine ist der globale virtuelle Computer, dessen Zustand jeder Teilnehmer im Ethereum-Netzwerk speichert und dem er zustimmt. Jeder Teilnehmer kann die Ausführung von beliebigem Code auf der EVM beantragen. Jede Codeausführung ändert den Zustand der EVM.
+
+[Mehr zur EVM](/developers/docs/evm/)
+
+### Nodes {#nodes}
+
+Die realen Maschinen, die den EVM-Zustand speichern. Nodes kommunizieren miteinander, um Informationen über den EVM-Zustand und neue Zustandsänderungen zu verbreiten. Jede/r Nutzer/in kann auch die Ausführung von Code anfordern, indem er/sie eine Anfrage zur Codeausführung von einem Node aus sendet. Das Ethereum-Netzwerk selbst ist das Aggregat aller Ethereum-Nodes und deren Kommunikation.
+
+[Mehr zu Nodes](/developers/docs/nodes-and-clients/)
+
+### Konten {#accounts}
+
+Wo Ether gespeichert wird. Nutzer können Konten initialisieren, Ether in die Konten einzahlen und Ether von ihren Konten auf andere Benutzer übertragen. Konten und Kontostände werden in einer großen Tabelle in der EVM gespeichert; sie sind Teil des EVM-Zustands.
+
+[Mehr über Konten](/developers/docs/accounts/)
+
+### Transaktionen {#transactions}
+
+Eine "Transaktionsanfrage" ist der formale Begriff für eine Anfrage zur Codeausführung auf der EVM, und eine "Transaktion" ist eine erfüllte Transaktionsanfrage und die damit verbundene Änderung des EVM-Zustands. Jeder Benutzer kann eine Transaktionsanfrage an das Netzwerk von einem Node senden. Damit sich die Transaktionsanfrage auf den vereinbarten EVM-Zustand auswirkt, muss sie von einem anderen Node validiert, ausgeführt und an das Netzwerk übertragen werden. Die Ausführung eines Codes führt zu einer Zustandsänderung in der EVM. Nach der Integration wird diese Zustandsänderung an alle Nodes im Netzwerk übertragen. Einige Beispiele für Transaktionen:
+
+- Schicke X Ether von meinem Konto an das Konto von Alice.
+- Veröffentliche Smart-Contract-Code in den EVM-Zustand.
+- Führe den Code des Smart Contracts unter Adresse X in der EVM mit Argumenten Y aus.
+
+[Mehr zu Transaktionen](/developers/docs/transactions/)
+
+### Blöcke {#blocks}
+
+Da das Transaktionsvolumen sehr hoch ist, werden die Transaktionen in Stapeln oder Blöcken "übertragen". Blöcke enthalten in der Regel Dutzende bis Hunderte von Transaktionen.
+
+[Mehr zu Blöcken](/developers/docs/blocks/)
+
+### Smart Contracts {#smart-contracts}
+
+Ein wiederverwendbares Code-Snippet (ein Programm), das ein Entwickler in den EVM-Zustand veröffentlicht. Jeder kann anfragen, dass der Smart-Contract-Code ausgeführt wird, indem er eine Transaktionsanfrage stellt. Da Entwickler beliebige ausführbare Anwendungen in die EVM (Spiele, Marktplätze, Finanzinstrumente etc.) schreiben können, werden diese oft in übergeordneter Form auch [dApps oder dezentralisierte Apps](/developers/docs/dapps/) genannt.
+
+[Mehr zu Smart Contracts](/developers/docs/smart-contracts/)
+
+## Weiterführende Informationen {#further-reading}
+
+- [Ethereum-Whitepaper](/whitepaper/)
+- [Wie funktioniert Ethereum überhaupt?](https://www.preethikasireddy.com/post/how-does-ethereum-work-anyway) – _Preethi Kasireddy_
+
+_Kennst du eine Community-Ressource, die dir geholfen hat? Bearbeite diese Seite und füge sie hinzu!_
+
+## Verwandte Tutorials {#related-tutorials}
+
+- [Ein Entwickler-Guide zu Ethereum, Teil 1 ](/developers/tutorials/a-developers-guide-to-ethereum-part-one/) _– Eine sehr anfängerfreundliche Erkundung von Ethereum mit Python und web3.py_
diff --git a/src/content/translations/de/developers/docs/networks/index.md b/src/content/translations/de/developers/docs/networks/index.md
new file mode 100644
index 00000000000..face3cc806e
--- /dev/null
+++ b/src/content/translations/de/developers/docs/networks/index.md
@@ -0,0 +1,129 @@
+---
+title: Netzwerke
+description: Eine Übersicht über Ethereums Netzwerke und wo man Testnet Ether (ETH) zum Testen neuer Anwendungen bekommt.
+lang: de
+sidebar: true
+---
+
+Da Ethereum ein Protokoll ist, kann es mehrere unabhängige "Netzwerke" geben, die diesem Protokoll entsprechen, jedoch nicht miteinander interagieren.
+
+Netzwerke sind verschiedene Ethereum-Umgebungen, auf die du für Entwicklung, Tests oder Produktionsanwendungsfälle zugreifen kannst. Dein Ethereum-Konto wird in den verschiedenen Netzwerken funktionieren, aber dein Kontostand und die zugehörige Transaktionsgeschichte werden nicht von Ethereums Hauptnetzwerk auf andere Netzwerke übertragen. Zu Testzwecken ist es nützlich zu wissen, welche Netzwerke verfügbar sind und wie man Testnet ETH erhält, um damit zu experimentieren.
+
+## Voraussetzungen {#prerequisites}
+
+Du solltest die Grundlagen von Ethereum verstehen, bevor du über die verschiedenen Netzwerke liest, da die Testnetze dir eine günstige und sichere Version von Ethereum bieten, um damit herumzuspielen. Starte mit unserer [Einführung in Ethereum](/developers/docs/intro-to-ethereum/).
+
+## Öffentliche Netzwerke {#public-networks}
+
+Öffentliche Netzwerke sind für jedermann auf der Welt mit einer Internetverbindung zugänglich. Jeder kann Transaktionen in einer öffentlichen Blockchain lesen oder erstellen und die ausgeführten Transaktionen validieren. Die Vereinbarung über Transaktionen und den Zustand des Netzwerks wird durch einen Konsens von Netzwerkteilnehmern getroffen.
+
+### Mainnet {#mainnet}
+
+Mainnet ist die primäre öffentliche Ethereum-Produktions-Blockchain, bei der Transaktionen mit tatsächlichem Wert im dezentralisierten Ledger stattfinden.
+
+Wenn Menschen und Börsen ETH-Preise diskutieren, sprechen sie über Mainnet ETH.
+
+### Testnetze {#testnets}
+
+Zusätzlich zum Mainnet gibt es öffentliche Testnetze. Dabei handelt es sich um Netzwerke, die von Protokollentwicklern oder Smart-Contract-Entwicklern eingesetzt werden, um sowohl Protokoll-Upgrades als auch potenzielle Smart Contracts in einer produktionsähnlichen Umgebung zu testen, bevor sie ins Mainnet gelangen. Stelle dir dies als Analog zur Produktion im Vergleich zu Staging-Servern vor.
+
+Es ist generell wichtig, jeden Vertragscode, den du auf einem Testnetz schreibst, zu testen, bevor du ihn in das Mainnet einbringst. Wenn du eine dApp erstellst, die an bestehende Smart Contracts angeknüpft ist, haben die meisten Projekte Kopien in Testnetze, mit denen du interagieren kannst, bereitgestellt.
+
+Die meisten Testnetze verwenden den Konsensmechanismus Proof-of-Authority. Dies bedeutet, dass eine kleine Anzahl von Nodes ausgewählt wird, um Transaktionen zu validieren und neue Blöcke zu erstellen – und ihre Identität im Prozess zu hinterlegen. Es ist schwer, das Mining auf einem Testnetz zu fördern, was es aufgrund geringer Validierungsressourcen verwundbar machen kann.
+
+ETH auf Testnetzen hat keinen echten Wert. Daher gibt es keine Märkte für Testnet ETH. Da du ETH benötigst, um tatsächlich mit Ethereum zu interagieren, bekommen die meisten Leute Testnet ETH von Faucets. Die meisten Faucets sind Webapplikationen, bei denen du eine Adresse eingeben kannst, an die die ETH gesendet werden sollen.
+
+#### Arbitrum Rinkeby {#arbitrum-rinkeby}
+
+Ein Testnetz für [Arbitrum](https://arbitrum.io/).
+
+##### Arbitrum Rinkeby faucets
+
+- [FaucETH](https://fauceth.computing.org) (Multi-Chain-faucet ohne die Notwendigkeit eines sozialen Kontos)
+- [Chainlink faucet](https://faucets.chain.link/)
+- [Paradigmatischer Faucet](https://faucet.paradigm.xyz/)
+
+#### Görli {#goerli}
+
+Ein Proof-of-Authority-Testnetz, das über verschiedene Clients hinweg funktioniert.
+
+##### Görli faucets
+
+- [Görli faucet](https://faucet.goerli.mudit.blog/)
+- [Chainlink faucet](https://faucets.chain.link/)
+- [Alchemy Goerli Faucet](https://goerlifaucet.com/)
+
+#### Kintsugi {#kintsugi}
+
+Ein Fusionstestnetz für Ethereum.
+
+##### Kintsugi faucets
+
+- [FaucETH](https://fauceth.computing.org) (Multi-Chain-Faucet ohne die Notwendigkeit eines Social-Kontos)
+- [Kintsugi faucet](https://faucet.kintsugi.themerge.dev/)
+
+#### Kovan {#kovan}
+
+Ein Proof-of-Authority-Testnetz für diejenigen, die OpenEthereum-Clients verwenden.
+
+##### Kovan faucets
+
+- [FaucETH](https://fauceth.computing.org) (Multi-Chain-Faucet ohne die Notwendigkeit eines Social-Kontos)
+- [Kovan faucet](https://faucet.kovan.network/)
+- [Chainlink faucet](https://faucets.chain.link/)
+- [Paradigm faucet](https://faucet.paradigm.xyz/)
+
+#### Optimistischer Kovan {#optimistic-kovan}
+
+Ein Testnetz für [Optimismus](https://www.optimism.io/).
+
+##### Optimistische Kovan-Faucets
+
+- [FaucETH](https://fauceth.computing.org) (Multi-Chain-Faucet ohne die Notwendigkeit eines Social-Kontos)
+- [Paradigmatischer Faucet](https://faucet.paradigm.xyz/)
+
+#### Rinkeby {#rinkeby}
+
+Ein Proof-of-Authority-Testnetz für diejenigen, die den Geth-Client verwenden.
+
+##### Rinkeby faucets
+
+- [FaucETH](https://fauceth.computing.org) (Multi-Chain-Faucet ohne die Notwendigkeit eines Social-Kontos)
+- [Alchemy faucet](https://RinkebyFaucet.com)
+- [Chainlink faucet](https://faucets.chain.link/)
+- [Paradigm faucet](https://faucet.paradigm.xyz/)
+- [Rinkeby faucet](https://faucet.rinkeby.io/)
+
+#### Ropsten {#ropsten}
+
+Ein Proof-of-Work-Testnetz. Das bedeutet, es ist die beste gleichartige Testnetzumgebung von Ethereum.
+
+##### Ropsten faucets
+
+- [FaucETH](https://fauceth.computing.org) (Multi-Chain-Faucet ohne die Notwendigkeit eines Social-Kontos)
+- [Paradigmatischer Faucet](https://faucet.paradigm.xyz/)
+
+## Private Netzwerke {#private-networks}
+
+Ein Ethereum-Netzwerk ist ein privates Netzwerk, wenn seine Nodes nicht mit einem öffentlichen Netzwerk verbunden sind (d. h. Hauptnetz [engl. Mainnet] oder ein Testnetz [engl. Testnet). In diesem Zusammenhang bedeutet privat nur reserviert oder isoliert statt geschützt oder sicher.
+
+### Entwicklungsnetzwerke {#development-networks}
+
+Um eine Ethereum-Anwendung zu entwickeln, ist es ratsam, sie in einem privaten Netzwerk auszuführen, um zu sehen, wie sie funktioniert, bevor du sie in der Blockchain verteilst. Ähnlich wie du auf deinem Computer einen lokalen Server für Webentwicklung erstellst, kannst du eine lokale Blockchain-Instanz erstellen, um deine dApp zu testen. Dies ermöglicht eine wesentlich schnellere Iteration als ein öffentliches Testnetz.
+
+Es gibt Projekte und Tools, die dabei hilfreich sind. Erfahre mehr über [Entwicklungsnetzwerke](/developers/docs/development-networks/).
+
+### Konsortium-Netzwerke {#consortium-networks}
+
+Der Konsensprozess wird von einer vordefinierten Gruppe von Nodes gesteuert, die vertrauenswürdig sind, z. B. ein privates Netzwerk bekannter akademischer Institutionen, die jeweils einen einzelnen Node stellen, wodurch Blöcke mit einer Schwelle von Unterzeichnern innerhalb des Netzwerks validiert werden.
+
+Wenn ein öffentliches Ethereum-Netzwerk wie das öffentliche Internet ist, kannst du dir ein Konsortium-Netzwerk als privates Intranet vorstellen.
+
+## Verwandte Tools {#related-tools}
+
+- [Kettenliste](https://chainlist.org/) _Liste der EVM-Netzwerke, um Wallets und Anbieter mit der entsprechenden Ketten-ID und Netzwerk-ID zu verbinden_
+- [EVM-basierte Ketten](https://github.com/ethereum-lists/chains) _GitHub Repo der Ketten-Metadaten, die Chainlist_ unterstützen
+
+## Weiterführende Informationen {#further-reading}
+
+_Kennst du eine Community-Ressource, die dir geholfen hat? Bearbeite diese Seite und füge sie hinzu!_
diff --git a/src/content/translations/de/developers/docs/nodes-and-clients/index.md b/src/content/translations/de/developers/docs/nodes-and-clients/index.md
new file mode 100644
index 00000000000..5e8a1cd0107
--- /dev/null
+++ b/src/content/translations/de/developers/docs/nodes-and-clients/index.md
@@ -0,0 +1,324 @@
+---
+title: Nodes und Clients
+description: Eine Übersicht über Ethereum-Nodes und Client-Software, wie eine Node eingerichtet wird und warum du dies tun solltest.
+lang: de
+sidebar: true
+sidebarDepth: 2
+---
+
+Ethereum ist ein verteiltes Netzwerk von Computern, auf denen Software (sogenannte Nodes) läuft, die Blöcke und Transaktionsdaten verifizieren kann. Du benötigst eine Anwendung, bekannt als Client, auf deinem Gerät, um einen Node zu "betreiben".
+
+## Voraussetzungen {#prerequisites}
+
+Du solltest das Konzept eines Peer-to-Peer-Netzwerks und die [Grundlagen der EVM](/developers/docs/evm/) verstehen, bevor du tiefer eintauchst und deine eigene Instanz eines Ethereum-Clients startest. Lies unsere [Einführung in Ethereum](/developers/docs/intro-to-ethereum/).
+
+Wenn dir das Thema Nodes neu ist, empfehlen wir dir, zunächst unsere benutzerfreundliche Einführung zum [Betreiben eines Ethereum-Nodes](/run-a-node) zu lesen.
+
+## Was sind Nodes und Clients? {#what-are-nodes-and-clients}
+
+"Node" bezieht sich auf eine laufende Client-Software. Ein Client ist eine Implementierung von Ethereum, die alle Transaktionen in jedem Block prüft und das Netzwerk somit sicher und die Daten genau hält.
+
+Du kannst eine Echtzeitansicht des Ethereum-Netzwerks sehen, indem du dir diese [Karte der Nodes](https://etherscan.io/nodetracker) ansiehst.
+
+Es gibt viele [Ethereum-Clients](/developers/docs/nodes-and-clients/#execution-clients) in einer Vielzahl von Programmiersprachen wie Go, Rust, JavaScript, Typescript, Python, C# .NET, Nim und Java. Was diese Implementierungen gemeinsam haben, ist dass sie alle einer formalen Spezifikation folgen (ursprünglich das [Ethereum Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf)). Diese Spezifikation bestimmt, wie das Ethereum-Netzwerk und die Blockchain funktionieren.
+
+![Ausführungs-Client](./client-diagram.png) Vereinfachtes Diagramm dessen, was einen Ethereum-Client ausmacht.
+
+## Node-Typen {#node-types}
+
+Wenn du [einen eigenen Node](/developers/docs/nodes-and-clients/run-a-node/) betreiben willst, solltest du verstehen, dass es verschiedene Arten von Nodes gibt, die Daten unterschiedlich konsumieren. In der Tat können Clients 3 verschiedene Arten von Nodes betreiben: Light, Full und Archive. Es gibt auch Optionen für verschiedene Synchronisierungsstrategien, die eine schnellere Synchronisationszeit ermöglichen. Die Synchronisierung bezieht sich darauf, wie schnell sie die aktuellsten Informationen über Ethereums Zustand erhalten kann.
+
+### Full-Node {#full-node}
+
+- Speichert die kompletten Blockchain-Daten.
+- Beteiligt sich an der Blockprüfung, überprüft alle Blöcke und Zustände.
+- Alle Zustände können von einem Full-Node abgeleitet werden.
+- Bedient das Netzwerk und liefert Daten auf Anfrage.
+
+### Light-Node {#light-node}
+
+- Speichert nur die Header-Kette und fordert alles andere an.
+- Kann die Gültigkeit der Daten gegen die Zustandswurzeln in den Block-Headern überprüfen.
+- Nützlich für Geräte mit geringer Kapazität, wie Embedded-Geräte oder Mobiltelefone, die es sich nicht leisten können, Gigabyte an Blockchain-Daten zu speichern.
+
+### Archive-Node {#archive-node}
+
+- Speichert alles wie im Full-Node und baut zusätzlich ein Archiv von historischen Zuständen auf. Wird benötigt, wenn du z. B. einen Kontostand bei Block #4.000.000 abfragen oder einfach und zuverlässig [deine eigenen Transaktionen testen willst, ohne sie mit OpenEthereum](https://openethereum.github.io/JSONRPC-trace-module#trace_callmany) zu minen.
+- Diese Daten stellen Einheiten von Terabytes dar, was Archive-Nodes für durchschnittliche Benutzer weniger attraktiv macht, aber für Dienste wie Blockexplorer, Wallet-Hersteller und die Blockchainanalyse nützlich sein kann.
+
+Das Synchronisieren von Clients in jedem anderen Modus als dem Archiv führt zu reduzierten (pruned) Blockchain-Daten. Das bedeutet, es gibt kein Archiv mit allen historischen Zuständen, aber der vollständige Node ist in der Lage, diese bei Bedarf zu erstellen.
+
+## Warum sollte ich einen Ethereum-Node betreiben? {#why-should-i-run-an-ethereum-node}
+
+Durch das Ausführen eines Nodes kannst du Ethereum vertraulich und privat nutzen, während das Ökosystem unterstützt wird.
+
+### Vorteile für dich {#benefits-to-you}
+
+Wenn du deinen eigenen Node betreibst, kannst du Ethereum auf eine wirklich private, autarke und vertrauenslose Weise verwenden. Du musst dem Netzwerk nicht vertrauen, weil du die Daten mit deinem Client selbst überprüfen kannst. "Nicht vertrauen, überprüfen" ist ein beliebtes Mantra der Blockchain.
+
+- Dein Node überprüft alle Transaktionen und Blöcke selbstständig gegen Konsensregeln. Das bedeutet, du musst dich nicht auf andere Nodes im Netzwerk verlassen oder ihnen vollständig vertrauen.
+- Du musst deine Adressen und Salden nicht an zufälligen Nodes veröffentlichen. Alles kann mit deinem eigenen Client überprüft werden.
+- Deine dApp kann sicherer und privater sein, wenn du einen eigenen Node verwendest. [MetaMask](https://metamask.io), [MyEtherWallet](https://myetherwallet.com) und einige andere Wallets können einfach mit deinem eigenen lokalen Node verknüpft werden.
+- Du kannst deine eigenen RPC-Endpunkte programmieren.
+- Du kannst dich mit deinem Node über **Interprozesskommunikation (IPC)** verbinden oder den Node umschreiben, um dein Programm als Plugin zu laden. Das garantiert eine niedrige Latenzzeit, die erforderlich ist, um deine Transaktionen so schnell wie möglich zu ersetzen (d. h. Frontrunning).
+
+![Wie du auf Ethereum über deine Anwendung und Nodes zugreifst](./nodes.png)
+
+### Netzwerkvorteile {#network-benefits}
+
+Eine Vielzahl von Nodes ist wichtig für Ethereums Gesundheit, Sicherheit und operative Belastbarkeit.
+
+- Sie bieten Light-Clients Zugriff auf Blockchain-Daten, die davon abhängen. Bei hohen Nutzungspitzen muss es genug vollständige Knoten geben, um die Synchronisation von Light-Nodes zu unterstützen. Light-Nodes speichern nicht die gesamte Blockchain, sondern verifizieren die Daten über die [Zustandswurzel in Block-Headern](/developers/docs/blocks/#block-anatomy). Sie können bei Bedarf weitere Informationen von Blöcken anfragen.
+- Full-Nodes erzwingen die Konsensregeln für den Proof-of-Work, so dass sie nicht dazu gebracht werden können, Blöcke zu akzeptieren, die den Regeln nicht folgen. Dies bietet zusätzliche Sicherheit im Netzwerk, denn wenn alle Nodes Light-Nodes wären, die keine vollständige Verifizierung durchführen, könnten Miner das Netzwerk angreifen und zum Beispiel Blöcke mit höheren Belohnungen erstellen.
+
+Wenn du einen Full-Node betreibst, profitiert das gesamte Ethereum Netzwerk.
+
+## Betreiben eines eigenen Nodes {#running-your-own-node}
+
+Hast du Interesse, deinen eigenen Ethereum-Client zu betreiben?
+
+Eine anfängerfreundliche Einführung findest du auf unserer [Node-Seite](/run-a-node).
+
+Wenn du eher ein technischer Benutzer bist, kannst du [einen eigenen Node](/developers/docs/nodes-and-clients/run-a-node/) mit der Kommandozeile aufbauen.
+
+### Projekte {#projects}
+
+[**Wähle einen Client aus und folge den Anweisungen.**](#clients)
+
+**Ethnode -** **_Betreibe einen Ethereum-Node (Geth oder OpenEthereum) für lokale Entwicklung._**
+
+- [GitHub](https://github.com/vrde/ethnode)
+
+**dAppNode -** **_Eine Betriebssystem-GUI für den Betrieb von Web3-Nodes, einschließlich Ethereum und der Beacon Chain, auf einer eigenen Maschine._**
+
+- [dappnode.io](https://dappnode.io)
+
+### Ressourcen {#resources}
+
+- [Running Ethereum Full Nodes: A Complete Guide](https://medium.com/coinmonks/running-ethereum-full-nodes-a-guide-for-the-barely-motivated-a8a13e7a0d31) _Nov 7, 2019 - Justin Leroux_
+- [Node Configuration Cheat Sheet](https://dev. to/5chdn/ethereum-node-configuration-modes-cheat-sheet-25l8) _Jan 5, 2019 - Afri Schoedon_
+- [How To Install & Run a Geth Node](https://www.quiknode.io/guides/infrastructure/how-to-install-and-run-a-geth-node) _Oct 4, 2020 - Sahil Sen_
+- [How To Install & Run a OpenEthereum (fka. Parity) Node](https://www.quiknode.io/guides/infrastructure/how-to-run-a-openethereum-ex-parity-client-node) _Sept 22, 2020 - Sahil Sen_
+
+## Alternativen {#alternatives}
+
+Der Betrieb eines eigenen Nodes kann schwierig sein und du musst nicht immer eine eigene Instanz betreiben. In diesem Fall kannst du einen Drittanbieter wie [Infura](https://infura.io), [Alchemy ](https://alchemyapi.io)oder [QuikNode](https://www.quiknode.io) verwenden. Alternativ dazu ist [ArchiveNode](https://archivenode.io/) ein von der Community finanzierter Archivknoten, der unabhängigen Entwicklern, die sich dies sonst nicht leisten könnten, Archivdaten auf der Ethereum-Blockchain zur Verfügung stellen soll. Einen Überblick über die Verwendung dieser Dienste findest du unter [Nodes als Dienst](/developers/docs/nodes-and-clients/nodes-as-a-service/).
+
+Wenn jemand in deiner Community einen Ethereum-Node mit einer öffentlichen API betreibt, kannst du deine Light Wallets (wie MetaMask) auf einen Community-Node [via Custom RPC](https://metamask.zendesk.com/hc/en-us/articles/360015290012-Using-a-Local-Node) verweisen lassen und so mehr Privatsphäre erreichen als mit einer zufälligen vertrauenswürdigen Drittpartei.
+
+Wenn du andererseits einen Client betreibst, kannst du ihn mit deinen Freunden teilen, die ihn vielleicht brauchen.
+
+## Ausführungs-Clients (früher "Eth1-Clients") {#execution-clients}
+
+Die Ethereum-Community unterhält mehrere quelloffene Ausführungs-Clients (früher als "Eth1-Clients" oder einfach "Ethereum-Clients" bezeichnet), die von verschiedenen Teams in unterschiedlichen Programmiersprachen entwickelt wurden. Dies macht das Netzwerk stärker und vielfältiger. Das ideale Ziel ist es, Vielfalt zu erreichen, ohne dass ein Client dominiert, um jede Art von Single Point of Failure zu reduzieren.
+
+Diese Tabelle gibt einen Überblick über die verschiedenen Clients. Sie alle bestehen [Client-Tests](https://github.com/ethereum/tests) und werden aktiv gewartet, um mit Netzwerk-Upgrades auf dem neuesten Stand zu bleiben.
+
+| Client | Sprache | Betriebssystem | Netzwerke | Sync-Strategien | Zustandsreduzierung |
+| ----------------------------------------------------------------------- | -------- | --------------------- | -------------------------------------------- | ------------------- | ------------------- |
+| [Geth](https://geth.ethereum.org/) | Go | Linux, Windows, MacOS | Mainnet, Görli, Rinkeby, Ropsten | Snap, Full | Archive, Pruned |
+| [Nethermind](http://nethermind.io/) | C#, .NET | Linux, Windows, MacOS | Mainnet, Görli, Ropsten, Rinkeby und weitere | Fast, Beam, Archive | Archive, Pruned |
+| [Besu](https://pegasys.tech/solutions/hyperledger-besu/) | Java | Linux, Windows, MacOS | Mainnet, Rinkeby, Ropsten, Görli und weitere | Fast, Full | Archive, Pruned |
+| [Erigon](https://github.com/ledgerwatch/erigon) | Los | Linux, Windows, MacOS | Mainnet, Görli, Rinkeby, Ropsten | Full | Archive, Pruned |
+| [OpenEthereum (veraltet)](https://github.com/openethereum/openethereum) | Rust | Linux, Windows, MacOS | Mainnet, Kovan, Ropsten und weitere | Warp, Full | Archive, Pruned |
+
+**Beachte, dass OpenEthereum [veraltet](https://medium.com/openethereum/gnosis-joins-erigon-formerly-turbo-geth-to-release-next-gen-ethereum-client-c6708dd06dd) ist und nicht mehr gewartet wird.** Verwende es mit Vorsicht und wechsle lieber zu einer anderen Client-Implementierung.
+
+Weitere Informationen zu unterstützten Netzwerken findest du unter [Ethereum-Netzwerke](/developers/docs/networks/).
+
+### Vorteile verschiedener Implementierungen {#advantages-of-different-implementations}
+
+Jeder Client hat einzigartige Anwendungsfälle und Vorteile, daher solltest du einen auf deinen eigenen Präferenzen basierenden wählen. Die Client-Vielfalt ermöglicht die Fokussierung der Implementierungen auf verschiedene Funktionen und Benutzergruppen. Du kannst einen Client basierend auf Features, Support, Programmiersprache oder Lizenzen auswählen.
+
+#### Go Ethereum {#geth}
+
+Go Ethereum (kurz Geth) ist eine der ursprünglichen Implementierungen des Ethereum-Protokolls. Derzeit ist es der am weitesten verbreitete Client mit der größten Benutzerbasis und der größten Vielfalt an Tools für Benutzer und Entwickler. Es ist in Go geschrieben, vollständig Open Source und unter der GNU LGPL v3 lizenziert.
+
+#### OpenEthereum {#openethereum}
+
+OpenEthereum ist ein schneller, funktionsreicher und fortgeschrittener CLI-basierter Ethereum-Client. Es wurde entwickelt, um die notwendige Infrastruktur für schnelle und zuverlässige Dienste bereitzustellen, die eine schnelle Synchronisierung und maximale Laufzeit erfordern. Das Ziel von OpenEthereum ist es, der schnellste, leichteste und sicherste Ethereum-Client zu sein. Es bietet eine saubere, modulare Codebase für
+
+- eine einfache Anpassung,
+- eine leichte Integration in Dienstleistungen oder Produkte,
+- einen minimalen Arbeitsspeicher und Speicherfußabdruck.
+
+OpenEthereum wird unter Verwendung der neuesten Rust-Programmiersprache entwickelt und unter GPLv3 lizenziert.
+
+**Beachte, dass OpenEthereum [veraltet](https://medium.com/openethereum/gnosis-joins-erigon-formerly-turbo-geth-to-release-next-gen-ethereum-client-c6708dd06dd) ist und nicht mehr gewartet wird.** Verwende es mit Vorsicht und wechsle lieber zu einer anderen Client-Implementierung.
+
+#### Nethermind {#nethermind}
+
+Nethermind ist eine Ethereum-Implementierung, die mit dem C# .NET Technologie-Stack erstellt wurde, der auf allen wichtigen Plattformen, einschließlich ARM, läuft. Es bietet eine großartige Leistung mit
+
+- einer optimierten virtuellen Maschine,
+- Zustandszugriff,
+- Netzwerken und reichhaltigen Funktionen wie Prometheus/Grafana-Dashboards, Seq Enterprise Logging Support, JSON RPC Tracing und Analytics-Plugins.
+
+Nethermind bietet auch eine [detaillierte Dokumentation](https://docs.nethermind.io), starke Entwicklerunterstützung, eine Online-Community und 24/7-Support für Premiumnutzer.
+
+#### Besu {#besu}
+
+Hyperledger Besu ist ein unternehmensorientierter Ethereum-Client für öffentliche und private Netzwerke. Er bietet alle Funktionen des Ethereum-Mainnets, von Tracing bis GraphQL, hat ein umfangreiches Monitoring und wird von ConsenSys unterstützt, sowohl in offenen Community-Kanälen als auch durch kommerzielle SLAs für Unternehmen. Er ist in Java geschrieben und ist durch Apache 2.0 lizenziert.
+
+#### Erigon {#erigon}
+
+Erigon, früher bekannt als Turbo-Geth, ist eine Abspaltung von Go Ethereum, die auf Geschwindigkeit und Speicherplatzeffizienz ausgerichtet ist. Erigon ist eine komplett neu entwickelte Implementierung von Ethereum, die derzeit in Go geschrieben ist, aber auch in anderen Sprachen implementiert werden soll. Das Ziel von Erigon ist es, eine schnellere, modularere und optimierte Implementierung von Ethereum anzubieten. Es kann eine vollständige Synchronisierung des Archiv-Nodes mit weniger als 2 Tb Speicherplatz in weniger als 3 Tagen durchführen
+
+### Synchronisationsmodi {#sync-modes}
+
+Um die aktuellen Daten im Netzwerk zu verfolgen und zu überprüfen, muss sich der Ethereum-Client mit dem neuesten Netzwerkstatus synchronisieren. Dazu werden Daten von Peers heruntergeladen, ihre Integrität kryptographisch verifiziert und eine lokale Blockchain-Datenbank aufgebaut.
+
+Die Synchronisationsmodi stellen verschiedene Ansätze für diesen Prozess mit unterschiedlichen Kompromissen dar. Die Clients unterscheiden sich auch in der Implementierung von Synchronisationsalgorithmen. Beziehe dich immer auf die offizielle Dokumentation des von dir gewählten Clients, um Einzelheiten zur Implementierung zu erfahren.
+
+#### Überblick über die Strategien {#overview-of-strategies}
+
+Allgemeiner Überblick über die Synchronisierungsansätze, die in Mainnet-Ready-Clients verwendet werden:
+
+##### Full sync {#full-sync}
+
+Bei full sync werden alle Blöcke (einschließlich Headern, Transaktionen und Quittungen) heruntergeladen und der Zustand der Blockchain inkrementell generiert, indem jeder Block ab Genesis ausgeführt wird.
+
+- Minimiert das Vertrauen und bietet höchste Sicherheit, indem jede Transaktion verifiziert wird.
+- Bei einer steigenden Anzahl von Transaktionen kann es Tage bis Wochen dauern, alle Transaktionen zu bearbeiten.
+
+##### Fast sync
+
+Die schnelle Synchronisierung lädt alle Blöcke herunter (einschließlich Headern, Transaktionen und Quittungen), überprüft alle Header, lädt den Zustand herunter und vergleicht ihn mit den Headern.
+
+- Verlässt sich auf die Sicherheit des Konsensmechanismus.
+- Die Synchronisierung dauert nur ein paar Stunden.
+
+##### Light sync
+
+Der Light-Client-Modus lädt alle Block-Header und Blockdaten herunter und prüft einige zufällig. Synchronisiert nur die Spitze der Kette vom vertrauenswürdigen Kontrollpunkt.
+
+- Ruft nur den neuesten Zustand ab und verlässt sich dabei auf das Vertrauen in die Entwickler und den Konsensmechanismus.
+- Der Client ist in wenigen Minuten mit dem aktuellen Netzwerkstatus einsatzbereit.
+
+[Mehr über Light-Clients](https://www.parity.io/blog/what-is-a-light-client/)
+
+##### Snap sync
+
+Eingeführt von Geth. Durch die Verwendung von dynamischen Snapshots, die von Peers bereitgestellt werden, werden alle Konto- und Speicherdaten abgerufen, ohne dass zwischengeschaltete Trie-Nodes heruntergeladen werden müssen, und der Merkle-Trie wird dann lokal rekonstruiert.
+
+- Schnellste von Geth entwickelte Synchronisierungsstrategie, derzeit die Standardstrategie
+- Spart eine Menge Festplattenkapazität und Netzwerkbandbreite, ohne die Sicherheit zu beeinträchtigen.
+
+[Mehr über Snap](https://github.com/ethereum/devp2p/blob/master/caps/snap.md)
+
+##### Warp-Sync
+
+Implementiert durch OpenEthereum. Nodes generieren in regelmäßigen Abständen einen konsenskritischen Zustands-Snapshot, den jeder Peer über das Netzwerk abrufen kann, was eine schnelle Synchronisation von diesem Punkt aus ermöglicht.
+
+- Der schnellste und auch standardmäßige Synchronisationsmodus von OpenEthereum basiert auf den statischen Snapshots, die von Peers generiert werden.
+- Das ist eine ähnliche Strategie wie bei Snap-Sync, aber ohne bestimmte Sicherheitsvorteile.
+
+[Mehr über Warp](https://openethereum.github.io/Beginner-Introduction#warping---no-warp)
+
+##### Beam-Sync
+
+Implementiert von Nethermind und Trinity. Beam-Sync funktioniert wie Fast-Sync, lädt aber auch die Daten herunter, die zum Ausführen der neusten Blocks benötigt wird. Dies ermöglicht dir, die Chain schon innerhalb der ersten paar Minuten nach dem Start abzufragen.
+
+- Synchronisiert den Zustand zuerst und ermöglicht die Abfrage von RPC in wenigen Minuten.
+- Noch in der Entwicklung und nicht vollständig zuverlässig. Die Hintergrundsynchronisierung ist verlangsamt und RPC-Antworten könnten fehlschlagen.
+
+[Mehr zu Beam](https://medium.com/@jason.carver/intro-to-beam-sync-a0fd168be14a)
+
+#### Setup im Client {#client-setup}
+
+Clients bieten umfangreiche Konfigurationsmöglichkeiten für deine Bedürfnisse an. Wähle einfach einen aus, der am besten zu dir passt, basierend auf dem Niveau der Sicherheit, verfügbaren Daten und Kosten. Neben dem Synchronisations-Algorithmus kannst du auch verschiedene Arten von alten Daten automatisch reduzieren lassen (Pruning). Pruning ermöglicht das Löschen veralteter Daten (z. B. das Entfernen von Zustands-Trie-Nodes), die von den letzten Blocks unerreichbar sind.
+
+Beachte die Dokumentation oder die Hilfeseite des Clients, um herauszufinden, welcher Synchronisationsmodus als Standard festgelegt ist. Du kannst beim Einrichten die standardmäßige Synchronisationsart bestimmen, in etwa so:
+
+**Light-Sync in [GETH](https://geth.ethereum.org/) oder [ERIGON](https://github.com/ledgerwatch/erigon) einrichten**
+
+`geth --syncmode "light"`
+
+Für mehr Informationen, lies die Anleitung dazu, [wie man einen Geth-Light-Node ausführt](/developers/tutorials/run-light-node-geth/).
+
+**Einrichtung von Full-Sync mit Archive in [Besu](https://besu.hyperledger.org/)**
+
+`besu --sync-mode=FULL`
+
+Genau wie jede andere Konfiguration kann es mit der Startup-Flag oder in der Konfigurationsdatei definiert werden. Ein weiteres Beispiel ist [Nethermind](https://docs.nethermind.io/nethermind/), welches dich dazu auffordert, während der ersten Initialisierung eine Konfiguration auszuwählen, und danach eine Konfigurationsdatei erstellt.
+
+## Konsens-Clients (früher als Eth2-Clients bekannt) {#consensus-clients}
+
+Es gibt mehrere Konsens-Clients (früher als Eth2-Clients bekannt), die dazu da sind, die [Konsens-Upgrades](/upgrades/beacon-chain/) zu unterstützen. Sie betreiben die Beacon Chain und werden den Ausführungen nach [The Merge](/upgrades/merge/) einen Proof-of-Stake-Konsensmechanismus zur Verfügung stellen.
+
+[Konsens-Clients anschauen](/upgrades/get-involved/#clients)
+
+| Client | Sprache | Betriebssysteme | Netzwerke |
+| ----------------------------------------------------------- | ---------- | --------------------- | ------------------------------------- |
+| [Teku](https://pegasys.tech/teku) | Java | Linux, Windows, MacOS | Beacon Chain, Prater |
+| [Nimbus](https://nimbus.team/) | Nim | Linux, Windows, MacOS | Beacon Chain, Prater |
+| [Lighthouse](https://lighthouse-book.sigmaprime.io/) | Rust | Linux, Windows, MacOS | Beacon Chain, Prater, Pyrmont |
+| [Lodestar](https://lodestar.chainsafe.io/) | TypeScript | Linux, Windows, MacOS | Beacon Chain, Prater |
+| [Prysm](https://docs.prylabs.network/docs/getting-started/) | Los | Linux, Windows, MacOS | Beacon Chain, Gnosis, Prater, Pyrmont |
+
+## Hardware {#hardware}
+
+Die Hardwareanforderungen sind je nach Client unterschiedlich, aber im Allgemeinen nicht besonders hoch, da der Node nur synchronisiert bleiben muss. Verwechsle es nicht mit dem Mining, das viel mehr Rechenleistung erfordert. Die Synchronisation von Zeit und Leistung verbessert sich jedoch mit leistungsstärkerer Hardware. Je nach Bedarf und Wunsch kann Ethereum auf deinem Computer, Home-Server, Single-Board-Computer oder virtuellen privaten Servern in der Cloud ausgeführt werden.
+
+Eine einfache Möglichkeit, deinen eigenen Node zu betreiben, ist die Verwendung von Plug-and-play-Boxen wie [dAppNode](https://dappnode.io/). Es stellt Hardware für laufende Clients und Anwendungen mit einer einfachen Benutzeroberfläche zur Verfügung.
+
+### Voraussetzungen {#requirements}
+
+Bevor du einen Client installierst, stelle bitte sicher, dass dein Computer über genügend Ressourcen verfügt, um ihn auszuführen. Die Mindestanforderungen und die empfohlenen Anforderungen findest du weiter unten. Der wichtigste Teil ist jedoch der Festplattenplatz. Die Synchronisation der Ethereum-Blockchain ist Datentechnisch sehr ein-/ausgangsintensiv. Es ist am besten, ein SSD einzusetzen. Um einen Ethereum-Client auf HDD laufen zu lassen, benötigst du mindestens 8 GB RAM für den Cache.
+
+#### Mindestanforderungen {#recommended-specifications}
+
+- CPU mit 2+ Kernen
+- Mindestens 4 GB RAM mit SSD, 8 GB+, wenn du eine HDD-Festplatte verwendest
+- 8 MBit/s Bandbreite
+
+#### Empfohlene Spezifikationen {#recommended-specifications}
+
+- Schnelle CPU mit 4+ Kernen
+- 16 GB+ RAM
+- Schnelle SSD mit mindestens 500 GB freiem Speicherplatz
+- 25+ MBit/s Bandbreite
+
+Der Sync-Modus, den du auswählst, wird einen Einfluss auf den benötigten Speicherplatz haben, deswegen haben wir schon einmal den notwendigen Speicherplatz für jeden Client abgeschätzt.
+
+| Client | Festplattengröße (Fast Sync) | Festplattengröße (Full Archive) |
+| ------------ | ---------------------------- | ------------------------------- |
+| Geth | 400 GB+ | 6 TB+ |
+| OpenEthereum | 280 GB+ | 6 TB+ |
+| Nethermind | 200 GB+ | 5 TB+ |
+| Besu | 750 GB+ | 5 TB+ |
+| Erigon | N/A | 1 TB+ |
+
+- Hinweis: Erigon kann keinen Fast-Sync durchführen, aber Full-Pruning ist möglich (~500 GB)
+
+![Ein Diagramm, das aufzeigt, dass die Gigabytes für eine Full-Synchronisation ansteigen](./full-sync.png)
+
+![Ein Diagramm, das aufzeigt, dass die Gigabytes für eine Archive-Synchronisation ansteigen](./archive-sync.png)
+
+Diese Diagramme zeigen, wie sich die Speicheranforderungen fortwährend ändern. Die aktuellsten Daten für Geth und OpenEthereum findest du auf [Full-Sync-Daten](https://etherscan.io/chartsync/chaindefault) und [Archive-Sync-Daten](https://etherscan.io/chartsync/chainarchive).
+
+### Ethereum auf einem Einzelplatinen-Computer {#ethereum-on-a-single-board-computer}
+
+Die bequemste und günstigste Art, Ethereum-Nodes zu betreiben, ist die Benutzung eines Einzelboard-Computers mit ARM-Architektur wie den Raspberry Pi. [Ethereum auf ARM](https://twitter.com/EthereumOnARM) bietet Bilder von Geth-, OpenEthereum-, Nethermind- und Besu-Clients. Hier ist ein einfaches Tutorial dazu, [wie man einen ARM-Client aufsetzt und einrichtet](/developers/tutorials/run-node-raspberry-pi/).
+
+Kleine, erschwingliche und effiziente Geräte wie diese sind ideal für den Betrieb eines Nodes zu Hause.
+
+## Weiterführende Informationen {#further-reading}
+
+Es gibt eine große Menge an Informationen über Ethereum-Clients im Internet. Hier sind ein paar Anhaltspunkte, die bei der Suche hilfreich sein könnten.
+
+- [Ethereum 101 - Part 2 - Understanding Nodes](https://kauri.io/ethereum-101-part-2-understanding-nodes/48d5098292fd4f11b251d1b1814f0bba/a) _– Wil Barnes, 13 February 2019_
+- [Running Ethereum Full Nodes: A Guide for the Barely Motivated](https://medium.com/@JustinMLeroux/running-ethereum-full-nodes-a-guide-for-the-barely-motivated-a8a13e7a0d31) _– Justin Leroux, 7 November 2019_
+- [Running an Ethereum Node](https://docs.ethhub.io/using-ethereum/running-an-ethereum-node/) _– ETHHub, updated often_
+- [Analyzing the hardware requirements to be an Ethereum full validated node](https://medium.com/coinmonks/analyzing-the-hardware-requirements-to-be-an-ethereum-full-validated-node-dc064f167902) _– Albert Palau, 24 September 2018_
+- [Running a Hyperledger Besu Node on the Ethereum Mainnet: Benefits, Requirements, and Setup](https://pegasys.tech/running-a-hyperledger-besu-node-on-the-ethereum-mainnet-benefits-requirements-and-setup/) _– Felipe Faraggi, 7 May 2020_
+
+## Verwandte Themen {#related-topics}
+
+- [Blöcke](/developers/docs/blocks/)
+- [Netzwerke](/developers/docs/networks/)
+
+## Verwandte Tutorials {#related-tutorials}
+
+- [Running a Node with Geth](/developers/tutorials/run-light-node-geth/) _– How to download, install and run Geth. Covering syncmodes, the JavaScript console, and more._
+- [Turn your Raspberry Pi 4 into a validator node just by flashing the MicroSD card – Installation guide](/developers/tutorials/run-node-raspberry-pi/) _– Flash your Raspberry Pi 4, plug in an ethernet cable, connect the SSD disk and power up the device to turn the Raspberry Pi 4 into a full Ethereum node running the execution layer (Mainnet) and / or the consensus layer (Beacon Chain / validator)._
diff --git a/src/content/translations/de/developers/docs/nodes-and-clients/nodes-as-a-service/index.md b/src/content/translations/de/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
new file mode 100644
index 00000000000..cdb16fe86a1
--- /dev/null
+++ b/src/content/translations/de/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
@@ -0,0 +1,218 @@
+---
+title: Nodes als Dienstleistung
+description: Eine Einstiegsübersicht über Node-Dienste, die Vor- und Nachteile und beliebte Anbieter.
+lang: de
+sidebar: true
+sidebarDepth: 2
+---
+
+## Einführung {#Introduction}
+
+Deinen eigenen [Ethereum-Node](/developers/docs/nodes-and-clients/#what-are-nodes-and-clients) zu betreiben kann eine Herausforderung sein, vor allem wenn du gerade beginnst oder während du schnell skalierst. Es gibt eine [Anzahl von Diensten](#popular-node-services), die optimierte Nodeinfrastrukturen für dich ausführen, damit du dich stattdessen auf die Entwicklung deiner Applikation oder deines Produkts konzentrieren kannst. Wir erklären dir, wie Node-Dienste funktionieren, welche Vor- und Nachteile sie haben und listen Anbieter auf, falls du anfangen willst, sie zu verwenden.
+
+## Voraussetzungen {#prerequisites}
+
+Wenn du noch nicht weißt, was Nodes und Clients sind, schaue dir [Nodes und Clients](/developers/docs/nodes-and-clients/) an.
+
+## Wie funktionieren Node-Dienste? {#how-do-node-services-work}
+
+Node-Dienste betreiben im Hintergrund dezentralisierte Node-Clients für dich, so dass du dich um den Aufbau der Infrastruktur nicht zu kümmern brauchst.
+
+Diese Dienste bieten in der Regel einen API-Schlüssel an, den du verwenden kannst, um in der Blockchain zu schreiben und zu lesen. Sie beinhalten oft den Zugriff auf [Ethereum-Testnetze](/developers/docs/networks/#testnets) zusätzlich zum Mainnet.
+
+Einige Dienste bieten dir Ihren eigenen dedizierten Node, den sie für dich verwalten, während andere Load Balancer nutzen, um die Aktivität auf mehrere Nodes zu verteilen.
+
+Fast alle Node-Dienste sind extrem einfach mit einer Zeilenänderung in deinen Code zu integrieren, um deinen selbst gehosteten Node auszutauschen oder sogar zwischen den Diensten selbst zu wechseln.
+
+Oft laufen Node-Dienste mit einer Vielzahl von [Node-Clients](/developers/docs/nodes-and-clients/#execution-clients) und [Typen](/developers/docs/nodes-and-clients/#node-types), so dass du in einer API zusätzlich zu Client-spezifischen Methoden auf Voll- und Archivierungsnodes zugreifen kannst.
+
+Es ist wichtig zu beachten, dass Node-Dienste keinesfalls deine privaten Schlüssel oder Informationen speichern können und sollten.
+
+## Was sind die Vorteile bei der Verwendung eines Node-Dienstes? {#benefits-of-using-a-node-service}
+
+Der Hauptvorteil bei der Nutzung eines Node-Dienstes besteht darin, die technische Zeit nicht zu benötigen, um die Nodes selbst aufzusetzen und zu verwalten. So kannst du dich auf den Aufbau deines Produkts konzentrieren, anstatt dich um die Wartung der Infrastruktur kümmern zu müssen.
+
+Der Betrieb eigener Nodes kann sehr kostspielig sein, vom Speicherplatz über die Bandbreite bis hin zu wertvoller Entwicklungszeit. Dinge wie das Starten weiterer Nodes bei der Skalierung, das Aufrüsten von Nodes auf die neueste Version und die Sicherstellung der Zustandskonsistenz können von der Entwicklung und dem Einsatz von Ressourcen für dein gewünschtes Web3-Produkt ablenken.
+
+## Was sind die Nachteile eines Node-Dienstes? {#cons-of-using-a-node-service}
+
+Durch den Einsatz eines Node-Dienstes zentralisierst du den Infrastrukturaspekt deines Produkts. Aus diesem Grund bevorzugen Projekte, für die Dezentralisierung die oberste Priorität hat, eher selbst bereitgestellte Nodes gegenüber Outsourcing an Dritte.
+
+Erfahre mehr über die [Vorteile des Betriebs deines eigenen Nodes](/developers/docs/nodes-and-clients/#benefits-to-you).
+
+## Beliebte Node-Dienste {#popular-node-services}
+
+Hier ist eine Liste der beliebtesten Ethereum-Nodeanbieter. Du bist eingeladen, fehlende hinzuzufügen! Jeder Node-Dienst bietet zusätzlich zu kostenlosen oder bezahlten Stufen verschiedene Vorteile und Funktionen. Bevor du dich entscheidest, solltest du untersuchen, welcher am besten zu deinen Bedürfnissen passt.
+
+- [**Alchemy**](https://www.alchemy.com/)
+ - [Dokumentation](https://docs.alchemyapi.io/)
+ - Eigenschaften
+ - Kostenlose Tier-Option
+ - Skalierung nach Belieben
+ - Kostenlose Archivdaten
+ - Analysetools
+ - Dashboard
+ - Einzigartige API-Endpunkte
+ - Webhooks
+ - Direkter Support
+- [**Ankr**](https://www.ankr.com/)
+ - [Dokumentation](https://docs.ankr.com/)
+ - Eigenschaften
+ - Ankr-Protokoll – offener Zugang zu öffentlichen RPC-API-Endpunkten für 8+ Ketten
+ - Lastausgleich und Überwachung der Node-Gesundheit für ein schnelles und zuverlässiges Gateway zum nächstgelegenen verfügbaren Node
+ - Premium-Tier mit WSS-Endpunkt und unbegrenzter Tarifgrenze
+ - Bereitstellung von vollständigen Nodes und Validierungs-Nodes für 40+ Ketten mit einem Klick
+ - Skalierung nach Belieben
+ - Analysetools
+ - Dashboard
+ - RPC-, HTTPS- und WSS-Endpunkte
+ - Direkter Support
+- [**BlockDaemon**](https://blockdaemon.com/)
+ - [Dokumentation](https://ubiquity.docs.blockdaemon.com/)
+ - Vorteile
+ - Dashboard
+ - Pro-Node-Basis
+ - Analyse
+- [**Chainstack**](https://chainstack.com/)
+ - [Dokumentation](https://docs.chainstack.com/)
+ - Eigenschaften
+ - Kostenloses Teilen von Nodes
+ - Gemeinsam genutzte Archiv-Nodes
+ - GraphQL-Support
+ - RPC- und WSS-Endpunkte
+ - Dedizierte Voll- und Archiv-Nodes
+ - Schnelle Synchronisierungszeit für gezielte Einsätze
+ - Bring deine Cloud mit
+ - Bezahlung pro Stunde
+ - Direkter 24/7-Support
+- [**GetBlock**](https://getblock.io/)
+ - [Dokumentation](https://getblock.io/docs/get-started/authentication-with-api-key/)
+ - Eigenschaften
+ - Zugang zu 40+ Blockchain-Nodes
+ - 40.000 kostenlose und tägliche Anfragen
+ - Unbegrenzte Anzahl von API-Schlüsseln
+ - Hohe Verbindungsgeschwindigkeit mit 1GB/sec
+ - Verfolgen+Archivieren
+ - Erweiterte Analyse
+ - Automatisierte Updates
+ - Technischer Support
+- [**InfStones**](https://infstones.com/)
+ - Eigenschaften
+ - Kostenlose Tier-Option
+ - Skalierung nach Belieben
+ - Analyse
+ - Dashboard
+ - Einzigartige API-Endpunkte
+ - Dedizierte vollständige Nodes
+ - Schnelle Synchronisierungszeit für gezielte Einsätze
+ - Direkter 24/7-Support
+ - Zugang zu mehr als 50 Blockchain-Nodes
+- [**Infura**](https://infura.io/)
+ - [Dokumentation](https://infura.io/docs)
+ - Eigenschaften
+ - Kostenlose Tier-Option
+ - Skalierung nach Belieben
+ - Kostenlose Archivierungsdaten
+ - Direkter Support
+ - Dashboard
+- [**Kaleido**](https://kaleido.io/)
+ - [Dokumentation](https://docs.kaleido.io/)
+ - Eigenschaften
+ - Kostenloser Starter
+ - Bereitstellung von Ethereum-Nodes mit einem Klick
+ - Anpassbare Clients und Algorithmen (Geth, Quorum & Besu || PoA, IBFT & Raft)
+ - 500+ Verwaltungs- und Service-APIs
+ - RESTful-Schnittstelle für die Übermittlung von Ethereum-Transaktionen (unterstützt von Apache Kafka)
+ - Ausgehende Streams für die Zustellung von Ereignissen (unterstützt von Apache Kafka)
+ - Umfassende Sammlung von "Off-Chain"- und Zusatzdiensten (z. B. bilateraler verschlüsselter Nachrichtenverkehr)
+ - Unkompliziertes Netzwerk-Onboarding mit Governance und rollenbasierter Zugriffskontrolle
+ - Ausgefeilte Benutzerverwaltung für Administratoren und Endbenutzer
+ - Hochgradig skalierbare, belastbare, unternehmensgerechte Infrastruktur
+ - Verwaltung privater HSM-Schlüssel in der Cloud
+ - Ethereum Mainnet-Anbindung
+ - ISO 27000 und SOC 2, Typ-2-Zertifizierungen
+ - Dynamische Laufzeitkonfiguration (z. B. Hinzufügen von Cloud-Integrationen, Änderung von Knoteneingängen usw.)
+ - Unterstützung für Multi-Cloud-, Multi-Region- und Hybrid-Einsatz-Orchestrierungen
+ - Einfache SaaS-Preise auf Stundenbasis
+ - SLAs- und 24/7-Support
+- [**Moralis**](https://moralis.io/)
+ - [Dokumentation](https://docs.moralis.io/)
+ - Eigenschaften
+ - Kostenloses Teilen von Nodes
+ - Kostenlose gemeinsam genutzte Archiv-Nodes
+ - Datenschutzfokussiert (keine Logs-Politik)
+ - Kettenübergreifender Support
+ - Skalierung nach Belieben
+ - Dashboard
+ - Einzigartiges Ethereum-SDK
+ - Einzigartige API-Endpunkte
+ - Direkter, technischer Support
+- [**Pocket Network**](https://www.pokt.network/)
+ - [Dokumentation](https://docs.pokt.network/home/)
+ - Eigenschaften
+ - Dezentrales RPC-Protokoll und Marktplatz
+ - 1 Mio. Anfragen pro Tag für kostenlose Tiers (pro Endpunkt, max. 2)
+ - [Öffentliche Endpunkte](https://docs.pokt.network/home/resources/public-rpc-endpoints)
+ - Pre-Stake+-Programm (wenn du mehr als 1 Mio. Anfragen pro Tag benötigst)
+ - Unterstützung von 15+ Blockchains
+ - 6400+ Nodes verdienen POKT für die Bedienung von Anwendungen
+ - Archivierungs- und Archivierungsnodes mit Rückverfolgung und Testnetz-Node-Unterstützung
+ - Ethereum Mainnet Node-Client-Diversität
+ - Kein einzelner Ausfallpunkt
+ - Keine Ausfallzeit
+ - Kosteneffiziente Near-Zero Tokenomics (POKT einmal für Netzwerkbandbreite einsetzen)
+ - Keine monatlichen versunkenen Kosten: Verwandle deine Infrastruktur in einen Vermögenswert
+ - Load-Balancing im Protokoll integriert
+ - Unendliche Skalierung der Anzahl von Anfragen pro Tag und der Nodes pro Stunde
+ - Die privatste und zensurresistenteste Option
+ - Praktische Unterstützung für Entwickler
+ - [Pocket Portal](https://bit.ly/ETHorg_POKTportal)-Dashboard und Analysen
+- [**QuikNode**](https://www.quiknode.io/)
+ - Eigenschaften
+ - 7 Tage kostenlos
+ - Vielseitiger Support
+ - Webhooks
+ - Dashboard
+ - Analyse
+- [**Rivet**](https://rivet.cloud/)
+ - [Dokumentation](https://rivet.readthedocs.io/en/latest/)
+ - Eigenschaften
+ - Kostenlose Tier-Option
+ - Skalierung nach Belieben
+- [**SettleMint**](https://console.settlemint.com/)
+ - [Dokumentation](https://docs.settlemint.com/)
+ - Eigenschaften
+ - Kostenlose Testphase
+ - Skalierung nach Belieben
+ - GraphQL-Support
+ - RPC- und WSS-Endpunkte
+ - Dedizierte vollständige Nodes
+ - Bring deine Cloud mit
+ - Analysetools
+ - Dashboard
+ - Bezahlung pro Stunde
+ - Direkter Support
+- [**Watchdata**](https://watchdata.io/)
+ - [Dokumentation](https://docs.watchdata.io/)
+ - Eigenschaften
+ - Zuverlässigkeit der Daten
+ - Ununterbrochene Verbindung ohne Ausfallzeiten
+ - Prozessautomatisierung
+ - Kostenlose Tarife
+ - Hohe Limits, für jeden Benutzer geeignet
+ - Unterstützung für unterschiedliche Nodes
+ - Ressourcenskalierung
+ - Hohe Verarbeitungsgeschwindigkeit
+
+## Weiterführende Informationen {#further-reading}
+
+- [Liste der Ethereum-Nodedienste](https://ethereumnodes.com/)
+
+## Verwandte Themen {#related-topics}
+
+- [Nodes und Clients](/developers/docs/nodes-and-clients/)
+
+## Verwandte Tutorials {#related-tutorials}
+
+- [Erste Schritte in der Ethereum-Entwicklung mit Alchemy](/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/)
+- [Leitfaden zum Versenden von Transaktionen über web3 und Alchemy](/developers/tutorials/sending-transactions-using-web3-and-alchemy/)
diff --git a/src/content/translations/de/developers/docs/nodes-and-clients/run-a-node/index.md b/src/content/translations/de/developers/docs/nodes-and-clients/run-a-node/index.md
new file mode 100644
index 00000000000..3b87a2a49a8
--- /dev/null
+++ b/src/content/translations/de/developers/docs/nodes-and-clients/run-a-node/index.md
@@ -0,0 +1,166 @@
+---
+title: Errichte deinen eigenen Ethereum-Node
+description: Allgemeine Einführung in den Betrieb einer eigenen Ethereum-Client-Instanz.
+lang: de
+sidebar: true
+sidebarDepth: 2
+---
+
+Der Betrieb einer eigener Node bietet dir verschiedene Vorteile, eröffnet neue Möglichkeiten und trägt zur Unterstützung des Ökosystems bei. Diese Seite führt dich durch die Einrichtung deines eigenen Nodes und die Teilnahme an der Validierung von Ethereum-Transaktionen.
+
+## Voraussetzungen {#prerequisites}
+
+Du solltest verstehen, was ein Ethereum-Node ist und warum du möglicherweise einen Client betreiben solltest. Dies wird in [Nodes und Clients](/developers/docs/nodes-and-clients/) behandelt.
+
+Wenn das Thema neu für dich ist oder du nach einem weniger technischen Weg suchst, empfehlen wir dir, zunächst unsere benutzerfreundliche Einführung zum [Betrieb eines Ethereum-Nodes](/run-a-node) zu lesen.
+
+## Herangehensweise bestimmen {#choosing-approach}
+
+Der erste Schritt beim Einrichten deines Nodes besteht in der Wahl der Herangehensweise. Du musst den Client (die Software), die Umgebung und die Parameter auswählen, mit denen du beginnen möchtest. >Hier sind alle verfügbaren [Mainnet-Clients](/developers/docs/nodes-and-clients/#advantages-of-different-implementations).
+
+#### Client-Einstellungen {#client-settings}
+
+Client-Implementierungen ermöglichen unterschiedliche Synchronisierungsmodi und verschiedene andere Optionen. [Synchronisierungsmodi](/developers/docs/nodes-and-clients/#sync-modes) stellen verschiedene Methoden zum Herunterladen und Validieren von Blockchain-Daten dar. Bevor du den Node startest, solltest du entscheiden, welchen Netzwerk- und Synchronisierungsmodus du verwenden möchtest. Das Wichtigste sind der Speicherplatz und die Synchronisierungszeit, die der Client benötigt.
+
+Alle Funktionen und Optionen sind in der Dokumentation des Clients zu finden. Es können verschiedene Client-Konfigurationen eingestellt werden, indem der Client mit den entsprechenden Flags ausgeführt wird. Weitere Informationen zu Flags findest du auf [EthHub](https://docs.ethhub.io/using-ethereum/running-an-ethereum-node/#client-settings) oder in der Client-Dokumentation. Zu Testzwecken kannst du einen Client in einem der Testnetze betreiben. [Übersicht der unterstützten Netzwerke](/developers/docs/nodes-and-clients/#execution-clients)
+
+### Umgebung und Hardware {#environment-and-hardware}
+
+#### Lokal oder Cloud {#local-vs-cloud}
+
+Ethereum-Clients können auf gewöhnlichen Computern laufen und benötigen keine spezielle Hardware, wie zum Beispiel beim Mining. Daher hast du je nach Bedarf verschiedene Optionen für den Einsatz. Zur Vereinfachung stellen wir uns vor, dass ein Node sowohl auf einem lokalen physischen Computer als auch auf einem Cloud-Server läuft:
+
+- Cloud
+ - Anbieter bieten eine hohe Serververfügbarkeit, statische öffentliche IP-Adressen
+ - Ein dedizierter oder virtueller Server kann bequemer sein als ein eigener
+ - Die Gegenleistung ist das Vertrauen in eine dritte Partei – den Serveranbieter
+ - Aufgrund der erforderlichen Speichergröße für einen vollständigen Node kann der Preis für einen gemieteten Server hoch werden
+- Eigene Hardware
+ - Vertrauenslosere und souveränere Vorgehensweise
+ - Einmalige Investition
+ - Option zum Kauf vorkonfigurierter Maschinen
+ - Du musst die Maschine physisch vorbereiten, warten und ggf. Fehler beheben
+
+Beide Optionen haben verschiedene Vorteile, die oben zusammengefasst sind. Wenn du eine Cloudlösung suchst, gibt es neben vielen traditionellen Cloud-Computing-Anbietern auch Dienste, die sich auf die Bereitstellung von Nodes konzentrieren. Beispiel:
+
+- [QuikNode](https://www.quiknode.io/)
+- [Blockdaemon](https://blockdaemon.com)
+- [LunaNode](https://www.lunanode.com/)
+- [Alchemy](https://www.alchemy.com/)
+
+#### Hardware {#hardware}
+
+Ein zensurresistentes, dezentrales Netz sollte sich jedoch nicht auf Cloudanbieter verlassen. Es ist gesünder für das Ökosystem, wenn du deinen eigenen Node auf einer Hardware betreibst. Die einfachsten Optionen sind vorkonfigurierte Geräte, z. B.:
+
+- [DappNode](https://dappnode.io/)
+- [Avado](https://ava.do/)
+
+Überprüfe die minimalen und empfohlenen [Festplattenspeicherplatzanforderungen für jeden Client und Synchronisierungsmodus](/developers/docs/nodes-and-clients/#requirements). Im Allgemeinen sollte eine bescheidene Rechenleistung ausreichen. Das Problem ist in der Regel die Geschwindigkeit der Datenträger. Während der anfänglichen Synchronisierung führen Ethereum-Clients eine Menge Lese- und Schreibvorgänge durch. Daher wird SSD dringend empfohlen. Ein Client ist möglicherweise nicht einmal [in der Lage, den aktuellen Stand auf der Festplatte zu synchronisieren](https://github.com/ethereum/go-ethereum/issues/16796#issuecomment-391649278), und bleibt ein paar Blöcke hinter dem Mainnet zurück. Du kannst die meisten Clients auf einem [Einplatinencomputer mit ARM](/developers/docs/nodes-and-clients/#ethereum-on-a-single-board-computer/) betreiben. Du kannst auch das [Ethbian](https://ethbian.org/index.html)-Betriebssystem für Raspberry Pi 4 verwenden. Damit können Sie [einen Client durch das Flashen der SD-Karte](/developers/tutorials/run-node-raspberry-pi/) starten. Je nach Software und Hardware können die anfängliche Synchronisierungszeit und die Speicheranforderungen variieren. Achte darauf, [die Synchronisierungszeiten und Speicheranforderungen zu überprüfen](/developers/docs/nodes-and-clients/#recommended-specifications). Vergewissere dich auch, dass deine Internetverbindung nicht durch eine [Bandbreitenbeschränkung](https://wikipedia.org/wiki/Data_cap) begrenzt ist. Es wird empfohlen, eine nicht gebührenpflichtige Verbindung zu verwenden, da die anfängliche Synchronisierung und die an das Netzwerk übertragenen Daten dein Limit überschreiten könnten.
+
+#### Das Betriebssystem {#operating-system}
+
+Alle Clients unterstützen die wichtigsten Betriebssysteme: Linux, MacOS, Windows. Das bedeutet, dass deine Nodes auf normalen Desktop- oder Server-Rechnern mit dem Betriebssystem (OS), welches dir am besten passt, betrieben werden können. Stelle sicher, dass dein Betriebssystem auf dem neuesten Stand ist, um mögliche Probleme und Sicherheitslücken zu vermeiden.
+
+## Hochfahren des Nodes {#spinning-up-node}
+
+### Abrufen der Client-Software {#getting-the-client}
+
+Lade zunächst deine bevorzugte [Client-Software](/developers/docs/nodes-and-clients/#execution-clients) herunter.
+
+Du kannst einfach eine ausführbare Anwendung oder ein Installationspaket herunterladen, das für dein Betriebssystem und deine Architektur geeignet ist. Überprüfe immer die Signaturen und Prüfsummen der heruntergeladenen Pakete. Einige Clients bieten auch Repositorys zur einfacheren Installation und Aktualisierung an. Wenn du es bevorzugst, kannst du diese aus dem Quellcode erstellen. Alle Clients sind quelloffen, so dass du sie mit dem richtigen Compiler aus dem Quellcode erstellen kannst.
+
+Ausführbare Binärdateien für stabile Mainnet-Client-Implementierungen können von den jeweiligen Release-Seiten heruntergeladen werden:
+
+- [Geth](https://geth.ethereum.org/downloads/)
+- [OpenEthereum](https://github.com/openethereum/openethereum/releases)
+- [Nethermind](https://downloads.nethermind.io/)
+- [Besu](https://pegasys.tech/solutions/hyperledger-besu/)
+- [Erigon](https://github.com/ledgerwatch/erigon)
+
+**Beachte, dass OpenEthereum [veraltet](https://medium.com/openethereum/gnosis-joins-erigon-formerly-turbo-geth-to-release-next-gen-ethereum-client-c6708dd06dd) ist und nicht mehr gewartet wird.** Verwende es mit Vorsicht und wechsle lieber zu einer anderen Client-Implementierung.
+
+### Starten des Clients {#starting-the-client}
+
+Bevor du die Ethereum-Client-Software startest, überprüfe noch einmal, ob deine Umgebung bereit ist. Vergewissere dich z. B.
+
+- dass unter Berücksichtigung des gewählten Netzwerk- und Synchronisationsmodus genügend Speicherplatz vorhanden ist,
+- dass Speicher und CPU nicht durch andere Programme angehalten werden,
+- dass das Betriebssystem auf die neueste Version aktualisiert wird,
+- dass das System die richtige Uhrzeit und das richtige Datum hat,
+- dass dein Router und deine Firewall Verbindungen an abhörenden Ports akzeptieren. Standardmäßig verwenden Ethereum-Clients einen Listener(TCP)-Port und einen UDP-Port, beide standardmäßig 30303.
+
+Führe deinen Client zunächst in einem Testnetz aus, um sicherzustellen, dass alles korrekt funktioniert. [Die Ausführung eines Geth light node](/developers/tutorials/run-light-node-geth/) sollte helfen. Du musst alle Client-Einstellungen, die nicht standardmäßig sind, zu Beginn angeben. Du kannst Flags oder die Konfigurationsdatei verwenden, um deine bevorzugte Konfiguration zu deklarieren. Die Einzelheiten findest du in der Dokumentation deines Clients. Der Client führt seine Kernfunktionen aus, wählt die Endpunkte und beginnt mit der Suche nach Peers. Nach erfolgreicher Erkennung von Peers beginnt der Client mit der Synchronisierung. Die aktuellen Blockchain-Daten sind verfügbar, sobald der Client erfolgreich mit dem aktuellen Zustand synchronisiert wurde.
+
+### Nutzung des Clients {#using-the-client}
+
+Clients bieten RPC-API-Endpunkte, mit denen du den Client steuerst und auf verschiedene Weise mit dem Ethereum-Netzwerk interagieren kannst:
+
+- manueller Aufruf mit einem geeigneten Protokoll (z. B. mit `curl`)
+- Anhängen einer bereitgestellten Konsole (z. B. `geth attach`)
+- ihre Implementierung in Anwendungen
+
+Verschiedene Clients haben unterschiedliche Implementierungen der RPC-Endpunkte. Es gibt jedoch einen Standard-JSON-RPC, den du mit jedem Client verwenden kannst. Für einen Überblick, [lies die JSON-RPC-Dokumente](https://eth.wiki/json-rpc/API). Anwendungen, die Informationen aus dem Ethereum-Netzwerk benötigen, können diesen RPC verwenden. Mit der beliebten Wallet MetaMask kannst du zum Beispiel [eine lokale Blockchain-Instanz betreiben und dich mit ihr verbinden](https://metamask.zendesk.com/hc/en-us/articles/360015290012-Using-a-Local-Node).
+
+#### Erreichen von RPC {#reaching-rpc}
+
+Der Standard-Port von JSON-RPC ist `8545`, aber du kannst die Ports der lokalen Endpunkte in der Konfigurationsdatei ändern. Standardmäßig ist die RPC-Schnittstelle nur über den localhost deines Computers erreichbar. Um sie aus der Ferne zugänglich zu machen, kannst du sie der Öffentlichkeit präsentieren, indem du die Adresse auf `0.0.0.0` änderst. Dadurch ist sie über lokale und öffentliche IP-Adressen zugänglich. In den meisten Fällen musst du auch eine Portweiterleitung auf deinem Router einrichten.
+
+Du solltest dies jedoch mit Vorsicht tun, da dadurch jeder im Internet deinen Node kontrollieren kann. Böswillige Akteure könnten auf deinen Node zugreifen, um dein System zum Absturz zu bringen oder dein Geld zu stehlen, wenn du deinen Client als Geldbörse verwendest.
+
+Eine Möglichkeit, dies zu umgehen, besteht darin, zu verhindern, dass potenziell schädliche RPC-Methoden geändert werden können. Beispielsweise kannst du mit `geth` veränderbare Methoden mit einem Flag deklarieren: `--http.api web3,eth,txpool`.
+
+Du kannst den Zugriff auf deine RPC-Schnittstelle auch hosten, indem du einen Webserverdienst wie Nginx auf die lokale Adresse und den Port deines Clients verweisen lässt.
+
+Die datenschutzfreundlichste und einfachste Art, einen öffentlich erreichbaren Endpunkt einzurichten, ist das Hosten auf deinem eigenen [Tor](https://www.torproject.org/)-Onion-Dienst. Auf diese Weise kannst du den RPC außerhalb deines lokalen Netzes erreichen, ohne eine statische öffentliche IP-Adresse oder geöffnete Ports. Du kannst das folgendermaßen tun:
+
+- Installiere `tor`.
+- Bearbeite die `torrc`-Konfiguration, um den versteckten Dienst mit der RPC-Adresse und dem Port deines Clients zu aktivieren.
+- Starte den `tor`-Dienst neu.
+
+Sobald du Tor neu gestartet hast, erhältst du versteckte Dienstschlüssel und einen Hostnamen in deinem gewünschten Verzeichnis. Von diesem Zeitpunkt an wird dein RPC unter einem `.onion`-Hostnamen erreichbar sein.
+
+### Betreiben des Nodes {#operating-the-node}
+
+Du solltest deinen Node regelmäßig überwachen, um sicherzustellen, dass er ordnungsgemäß funktioniert. Möglicherweise musst du gelegentlich Wartungsarbeiten durchführen.
+
+#### Den Node online halten {#keeping-node-online}
+
+Dein Node muss nicht ununterbrochen online sein, aber du solltest ihn so oft wie möglich online halten, um ihn mit dem Netzwerk zu synchronisieren. Du könntest ihn ausschalten, um ihn neu zu starten, aber bedenke, dass
+
+- das Herunterfahren einige Minuten dauern kann, wenn der aktuelle Zustand noch auf die Festplatte geschrieben wird,
+- erzwungene Abschaltungen die Datenbank beschädigen können,
+- Dein Client wird nicht mehr mit dem Netzwerk synchronisiert und muss neu synchronisiert werden, wenn du ihn neu startest.
+
+_Dies gilt nicht für Konsensschicht-Validierungs-Nodes._ Wenn du deinen Node offline schaltest, wirkt sich dies auf alle von ihm abhängigen Dienste aus. Wenn du einen Node für _Sicherungszwecke_ betreibst, solltest du versuchen, die Ausfallzeiten so gering wie möglich zu halten.
+
+#### Erstellung eines Client-Dienstes {#creating-client-service}
+
+Ziehe in Erwägung, einen Dienst zu erstellen, der deinen Client beim Start automatisch ausführt. Auf Linux-Servern wäre es beispielsweise eine gute Praxis, einen Dienst zu erstellen, der den Client mit der richtigen Konfiguration und unter einem Benutzer mit begrenzten Rechten ausführt und automatisch neu startet.
+
+#### Aktualisieren des Clients {#updating-client}
+
+Du müsstest deine Client-Software mit den neuesten Sicherheitspatches, Funktionen und [EIPs](/eips/) auf dem neuesten Stand halten. Besonders vor [hard forks](/history/) solltest du sicherstellen, dass du die richtige Client-Version verwendest.
+
+Jede Client-Implementierung hat eine von Menschen lesbare Versionszeichenfolge, die im Peer-to-Peer-Protokoll verwendet wird, aber auch über die Befehlszeile zugänglich ist. Anhand dieses Versionsstrings können die Benutzer überprüfen, ob sie die richtige Version verwenden. Außerdem ermöglicht er es Blockexplorern und anderen Analysewerkzeugen eine quantitative Analyse der Verteilung bestimmter Clients im Netz. Weitere Informationen zu den Versionsstrings finden Sie in der jeweiligen Client-Dokumentation.
+
+#### Durchführung zusätzlicher Dienste {#running-additional-services}
+
+Wenn du deinen eigenen Node betreibst, kannst du Dienste nutzen, die einen direkten Zugang zum Ethereum-Client-RPC erfordern. Dies sind Dienste, die auf Ethereum aufbauen, wie [Layer-2-Lösungen](/developers/docs/scaling/#layer-2-scaling), [Konsens-Clients](/upgrades/get-involved/#clients) und andere Ethereum-Infrastruktur.
+
+#### Überwachung des Nodes {#monitoring-the-node}
+
+"Um deine Node richtig zu überwachen, solltest du Metriken sammeln. Clients stellen Metrik-Endpunkte bereit, damit du umfassende Daten über deinen Node erhalten kannst. Verwende Tools wie [InfluxDB](https://www.influxdata.com/get-influxdb/) oder [Prometheus](https://prometheus.io/) um Datenbanken zu erstellen, die du in Software wie [Grafana](https://grafana.com/) in Visualisierungen und Diagramme umwandeln kannst. Es gibt viele Setups für die Verwendung dieser Software und verschiedene Grafana-Dashboards, mit denen du deine Nodes und das Netzwerk als Ganzes visualisieren kannst. Behalte im Rahmen der Überwachung auch die Leistung deiner Maschine im Auge. Während der ersten Synchronisierung deiner Node kann die Client-Software sehr viel CPU und RAM beanspruchen. Zusätzlich zu Grafana kannst du die Tools deines Betriebssystems wie `htop` oder `uptime` verwenden, um dies zu tun.
+
+## Weiterführende Informationen {#further-reading}
+
+- [Analyzing the hardware requirements to be an Ethereum full validated node](https://medium.com/coinmonks/analyzing-the-hardware-requirements-to-be-an-ethereum-full-validated-node-dc064f167902) _– Albert Palau, 24 September 2018_
+- [Running Ethereum Full Nodes: A Guide for the Barely Motivated](https://medium.com/@JustinMLeroux/running-ethereum-full-nodes-a-guide-for-the-barely-motivated-a8a13e7a0d31) _– Justin Leroux, 7 November 2019_
+- [Running an Ethereum Node](https://docs.ethhub.io/using-ethereum/running-an-ethereum-node/) _– ETHHub, updated often_
+- [Running a Hyperledger Besu Node on the Ethereum Mainnet: Benefits, Requirements, and Setup](https://pegasys.tech/running-a-hyperledger-besu-node-on-the-ethereum-mainnet-benefits-requirements-and-setup/) _– Felipe Faraggi, 7 May 2020_
+- [Deploying Nethermind Ethereum Client with Monitoring Stack](https://medium.com/nethermind-eth/deploying-nethermind-ethereum-client-with-monitoring-stack-55ce1622edbd) _– Nethermind.eth, 8 July 2020_
+
+## Verwandte Themen {#related-topics}
+
+- [Nodes und Clients](/developers/docs/nodes-and-clients/)
+- [Blöcke](/developers/docs/blocks/)
+- [Netzwerke](/developers/docs/networks/)
diff --git a/src/content/translations/de/developers/docs/transactions/index.md b/src/content/translations/de/developers/docs/transactions/index.md
new file mode 100644
index 00000000000..1444902b747
--- /dev/null
+++ b/src/content/translations/de/developers/docs/transactions/index.md
@@ -0,0 +1,209 @@
+---
+title: Transaktionen
+description: Eine Übersicht über die Transaktionen von Ethereum – wie sie arbeiten, ihre Datenstruktur und wie sie über eine App gesendet werden.
+lang: de
+sidebar: true
+---
+
+Transaktionen sind kryptographisch signierte Anweisungen von Konten. Ein Konto wird eine Transaktion starten, um den Zustand des Ethereum-Netzwerks zu aktualisieren. Die einfachste Transaktion ist die Übertragung von ETH von einem Konto auf ein anderes.
+
+## Voraussetzungen {#prerequisites}
+
+Um dir zu helfen, diese Seite besser zu verstehen, empfehlen wir dir, zuerst [ Konten](/developers/docs/accounts/), [Transaktionen](/en/developers/docs/transactions/) und unsere [Einführung in Ethereum](/developers/docs/intro-to-ethereum/) zu lesen.
+
+## Was ist eine Transaktion? {#whats-a-transaction}
+
+Eine Transaktion von Ethereum bezieht sich auf eine Aktion, die von einem externen Konto initiiert wird; mit anderen Worten auf ein Konto, das von einem Menschen verwaltet wird und nicht von einem Vertrag. Wenn zum Beispiel Bob Alice 1 ETH sendet, muss Bobs Konto belastet werden und das von Alice muss eine Gutschrift erhalten. Diese zustandsverändernde Aktion findet innerhalb einer Transaktion statt.
+
+![Diagramm mit einer Zustandsänderung aus einer Transaktion](./tx.png) _Diagramm angepasst von [Ethereum EVM illustriert](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+
+Transaktionen, die den Zustand der EVM verändern, müssen auf das gesamte Netzwerk übertragen werden. Jede Node kann eine Anfrage für eine Transaktion auf der EVM senden. Dann wird ein Miner/Validator die Transaktion ausführen und die daraus resultierende Zustandsänderung an den Rest des Netzwerks weiterleiten.
+
+Transaktionen erfordern eine Gebühr und müssen gemint werden, um Gültigkeit zu erlangen. Um diese Übersicht zu vereinfachen, werden wir die Gasgebühren und das Mining an anderer Stelle abdecken.
+
+Eine abgeschlossene Transaktion enthält folgende Informationen:
+
+- `recipient` – die Empfangsadresse (im Fall eines externen Kontos wird die Transaktion den Wert übertragen. Bei einem Smart-Contract-Konto wird die Transaktion den Vertragscode ausführen.)
+- `signature` – der Identifikator des Absenders. Dies wird generiert, wenn der private Schlüssel des Absenders die Transaktion signiert und bestätigt, dass der Absender diese Transaktion autorisiert hat.
+- `value` – Betrag der ETH zum Übertragen vom Absender zum Empfänger (in WEI, einer Stückelung von ETH)
+- `data` – optionales Feld, um beliebige Daten einzubinden
+- `gasLimit` – Die maximale Menge an Gaseinheiten, die von der Transaktion verbraucht werden können. Gaseinheiten stellen Berechnungsschritte dar.
+- `maxPriorityFeePerGas` – die maximale Menge an Gas, die für den Miner als Trinkgeld enhalten sein soll
+- `maxFeePerGas` – die maximale Menge an Gas, die für die Transaktion gezahlt werden soll (einschließlich `baseFeePerGas` und `maxPriorityFeePerGas`)
+
+Gas ist eine Referenz auf die Berechnung, die erforderlich ist, um die Transaktion durch einen Miner/Validator zu verarbeiten. Benutzer müssen für diese Berechnung eine Gebühr bezahlen. Das `gasLimit` und `maxPriorityFeePerGas` bestimmen die maximale Transaktionsgebühr, die an den Miner gezahlt wird. [Mehr zu Gas](/developers/docs/gas/).
+
+Das Transaktionsobjekt wird in etwa wie folgt aussehen:
+
+```js
+{
+ from: "0xEA674fdDe714fd979de3EdF0F56AA9716B898ec8",
+ to: "0xac03bb73b6a9e108530aff4df5077c2b3d481e5a",
+ gasLimit: "21000",
+ maxFeePerGas: "300",
+ maxPriorityFeePerGas: "10",
+ nonce: "0",
+ value: "10000000000"
+}
+```
+
+Aber ein Transaktionsobjekt muss mit dem privaten Schlüssel des Absenders signiert werden. Dies beweist, dass die Transaktion nur vom Absender hätte kommen können und nicht betrügerisch verschickt wurde.
+
+Ein Ethereum-Client wie Geth wird diesen Signaturprozess bearbeiten.
+
+Beispiel-[JSON-RPC](https://eth.wiki/json-rpc/API)-Aufruf:
+
+```json
+{
+ "id": 2,
+ "jsonrpc": "2.0",
+ "method": "account_signTransaction",
+ "params": [
+ {
+ "from": "0x1923f626bb8dc025849e00f99c25fe2b2f7fb0db",
+ "gas": "0x55555",
+ "maxFeePerGas": "0x1234",
+ "maxPriorityFeePerGas": "0x1234",
+ "input": "0xabcd",
+ "nonce": "0x0",
+ "to": "0x07a565b7ed7d7a678680a4c162885bedbb695fe0",
+ "value": "0x1234"
+ }
+ ]
+}
+```
+
+Beispielantwort:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 2,
+ "result": {
+ "raw": "0xf88380018203339407a565b7ed7d7a678680a4c162885bedbb695fe080a44401a6e4000000000000000000000000000000000000000000000000000000000000001226a0223a7c9bcf5531c99be5ea7082183816eb20cfe0bbc322e97cc5c7f71ab8b20ea02aadee6b34b45bb15bc42d9c09de4a6754e7000908da72d48cc7704971491663",
+ "tx": {
+ "nonce": "0x0",
+ "maxFeePerGas": "0x1234",
+ "maxPriorityFeePerGas": "0x1234",
+ "gas": "0x55555",
+ "to": "0x07a565b7ed7d7a678680a4c162885bedbb695fe0",
+ "value": "0x1234",
+ "input": "0xabcd",
+ "v": "0x26",
+ "r": "0x223a7c9bcf5531c99be5ea7082183816eb20cfe0bbc322e97cc5c7f71ab8b20e",
+ "s": "0x2aadee6b34b45bb15bc42d9c09de4a6754e7000908da72d48cc7704971491663",
+ "hash": "0xeba2df809e7a612a0a0d444ccfa5c839624bdc00dd29e3340d46df3870f8a30e"
+ }
+ }
+}
+```
+
+- Das `raw` ist die signierte Transaktion in rekursivem Längenpräfix (RLP) kodiertem Format.
+- Das `tx` ist die signierte Transaktion im JSON-Format.
+
+Mit dem Signatur-Hash kann für die Transaktion kryptographisch nachgewiesen werden, dass sie vom Absender stammt und dem Netzwerk übermittelt wurde.
+
+### Das Datenfeld {#the-data-field}
+
+Die überwiegende Mehrheit der Transaktionen greift auf einen Vertrag über ein externes Konto zu. Die meisten Verträge sind in Solidity geschrieben und interpretieren ihr Datenfeld entsprechedn dem [application binary interface (ABI)](/glossary/#abi/).
+
+Die ersten vier Bytes geben an, welche Funktion aufgerufen werden soll, wobei der Hash des Funktionsnamens und der Argumente verwendet wird. Manchmal kannst du die Funktion anhand des Selektors aus [dieser Datenbank](https://www.4byte.directory/signatures/) identifizieren.
+
+Der Rest der Aufrufdaten sind die Argumente, [codiert wie in den ABI-Spezifikationen angegeben](https://docs.soliditylang.org/en/latest/abi-spec.html#formal-specification-of-the-encoding).
+
+Betrachten wir zum Beispiel [diese Transaktion](https://etherscan.io/tx/0xd0dcbe007569fcfa1902dae0ab8b4e078efe42e231786312289b1eee5590f6a1). Verwende **Für mehr hier klicken**, um die Aufrufdaten zu sehen.
+
+Der Funktions-Selektor ist `0xa9059cbb`. Es gibt mehrere [bekannte Funktionen mit dieser Signatur](https://www.4byte.directory/signatures/?bytes4_signature=0xa9059cbb). In diesem Fall wurde [der Contract-Quellcode](https://etherscan.io/address/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48#code) auf Etherscan hochgeladen, so dass wir wissen, dass die Funktion `transfer(address,uint256)` ist.
+
+Der Rest der Daten lautet:
+
+```
+0000000000000000000000004f6742badb049791cd9a37ea913f2bac38d01279
+000000000000000000000000000000000000000000000000000000003b0559f4
+```
+
+Entsprechend den ABI-Spezifikationen erscheinen Ganzzahlwerte (wie Adressen, die 20-Byte-Ganzzahlen sind) in ABI als 32-Byte-Wörter, die vorne mit Nullen aufgefüllt werden. Also wissen wir, dass die Adresse von `to` [`4f6742badb049791cd9a37ea913f2bac38d01279`](https://etherscan.io/address/0x4f6742badb049791cd9a37ea913f2bac38d01279) ist. Der Wert ist `value` 0x3b0559f4 = 990206452.
+
+## Arten von Transaktionen {#types-of-transactions}
+
+Bei Ethereum gibt es unterschiedliche Arten von Transaktionen:
+
+- Reguläre Transaktionen: eine Transaktion von einer Wallet zur anderen.
+- Vertragseinsatz-Transaktionen: eine Transaktion ohne "An"-Adresse, bei der das Datenfeld für den Vertragscode verwendet wird.
+- Ausführung eines Vertrags: eine Transaktion, die mit einem bereitgestellten Smart Contract interagiert. In diesem Fall ist die Adresse von "to" die des Smart Contracts.
+
+### Über Gas {#on-gas}
+
+Wie bereits erwähnt, kosten das Ausführen von Transaktionen [gas](/developers/docs/gas/). Einfache Überweisungstransaktionen erfordern 21000 Gas.
+
+Damit Bob also Alice 1 ETH zu einer `BasisgebührPerGas` von 190 gwei und einer `maximalenPrioritätsgebührPerGas` von 10 gwei schicken kann, muss er folgende Gebühr bezahlen:
+
+```
+(190 + 10) * 21000 = 4.200.000 gwei
+--oder--
+0,0042 ETH
+```
+
+Bobs Konto wird belastet mit **-1,0042 ETH**
+
+Alices Konto wird **+1,0 ETH** gutgeschrieben
+
+Die Grundgebühr wird **-0,00399 ETH** verbrannt
+
+Miner behält das Trinkgeld **+0,000210 ETH**
+
+Gas ist auch für alle Smart Contracts erforderlich.
+
+![Diagramm zeigt, wie ungenutztes Gas zurückerstattet wird](./gas-tx.png) _Diagramm angepasst von [Ethereum EVM illustriert](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+
+Jedes Gas, das nicht in einer Transaktion verwendet wird, wird auf das Benutzerkonto zurückerstattet.
+
+## Transaktions-Lebenszyklus {#transaction-lifecycle}
+
+Sobald die Transaktion abgeschickt wurde, passiert Folgendes:
+
+1. Sobald du eine Transaktion gesendet hast, erzeugt die Kryptographie einen Transaktions-Hash: `0x97d99bc77292111a21b12c933c949d4f31684f1d6954ff477d0477538ff017`
+2. Die Transaktion wird dann in das Netzwerk übertragen und in einen Pool mit vielen anderen Transaktionen aufgenommen.
+3. Ein Miner/Validator muss deine Transaktion auswählen und in einen Block einbinden, um die Transaktion zu überprüfen und sie als "erfolgreich" einzustufen.
+ - Du musst eventuell warten, wenn das Netzwerk beschäftigt ist und Miner/Validatoren nicht in der Lage sind, mit der Menge zu validierender Transaktionen mitzuhalten.
+4. Deine Transaktion wird "Bestätigungen" erhalten. Die Anzahl der Bestätigungen ist die Anzahl der Blöcke, die seit dem Block, der deine Transaktion enthielt, erstellt wurde. Je höher die Zahl, desto größer ist die Gewissheit, dass das Netzwerk die Transaktion verarbeitet und anerkannt hat.
+ - Neuere Blöcke können umorganisiert werden, was den Eindruck erweckt, dass die Transaktion nicht erfolgreich war; die Transaktion kann jedoch noch gültig, aber in einem anderen Block enthalten sein.
+ - Die Wahrscheinlichkeit einer Reorganisation sinkt mit jedem weiteren geminten Block, d. h., je größer die Anzahl der Bestätigungen ist, desto unveränderlicher ist die Transaktion.
+
+## Eine visuelle Demo {#a-visual-demo}
+
+Schaue Austin bei einer Führung durch Transaktionen, Gas und Mining zu.
+
+
+
+## Typisierter Transaktionsumschlag {#typed-transaction-envelope}
+
+Ursprünglich hatte Ethereum ein einziges Format für Transaktionen. Jede Transaktion enthielt eine Nonce, einen Gaspreis, ein Gaslimit, eine Zieladresse, einen Wert, Daten, v, r und s. Diese Felder sind RLP-codiert und sehen in etwa so aus:
+
+`RLP([nonce, gasPrice, gasLimit, to, value, data, v, r, s])`
+
+Ethereum hat sich so entwickelt, dass es mehrere Transaktionsarten unterstützt, damit neue Funktionen wie Zugriffslisten und [EIP-1559](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md) implementiert werden können, ohne die alten Transaktionsformate zu beeinflussen.
+
+[EIP-2718: Typisierter Transaktionsumschlag](https://eips.ethereum.org/EIPS/eip-2718) definiert einen Transaktionstyp, der ein Umschlag für zukünftige Transaktionstypen ist.
+
+EIP-2718 ist ein neuer allgemeiner Umschlag für typisierte Transaktionen. In dem neuen Standard werden Transaktionen wie folgt interpretiert:
+
+`TransactionType || TransactionPayload`
+
+Die Felder sind wie folgt definiert:
+
+- `TransactionType` – eine Zahl zwischen 0 und 0x7f, für insgesamt 128 mögliche Transaktionsarten.
+- `TransactionPayload` – ein beliebiges Byte-Array, das durch den Transaktionstyp definiert wird.
+
+## Weiterführende Informationen {#further-reading}
+
+- [EIP-2718: Typisierter Transaktionsumschlag](https://eips.ethereum.org/EIPS/eip-2718)
+
+_Kennst du eine Community-Ressource, die dir geholfen hat? Bearbeite diese Seite und füge sie hinzu!_
+
+## Verwandte Themen {#related-topics}
+
+- [Konten](/developers/docs/accounts/)
+- [Ethereum Virtual Machine (EVM)](/developers/docs/evm/)
+- [Gas](/developers/docs/gas/)
+- [Mining](/developers/docs/consensus-mechanisms/pow/mining/)
diff --git a/src/content/translations/de/developers/docs/web2-vs-web3/index.md b/src/content/translations/de/developers/docs/web2-vs-web3/index.md
new file mode 100644
index 00000000000..595dcb12213
--- /dev/null
+++ b/src/content/translations/de/developers/docs/web2-vs-web3/index.md
@@ -0,0 +1,62 @@
+---
+title: Web2 vs Web3
+description:
+lang: de
+sidebar: true
+---
+
+Web2 bezieht sich auf die Version des Internets, die die meisten von uns heute kennen. Ein Internet dominiert von Unternehmen, die im Austausch für deine persönlichen Daten Dienstleistungen erbringen. Web3 bezieht sich im Kontext von Ethereum auf dezentrale Apps, die auf der Blockchain laufen. Dies sind Apps, mit denen jeder teilnehmen kann, ohne seine persönlichen Daten zu monetarisieren.
+
+Suchen Sie nach einer anfängerfreundlicheren Einführung? Siehe unsere [Einführung in web3](/web3/).
+
+## Web3 – Vorteile {#web3-benefits}
+
+Viele Web3-Entwickler haben aufgrund der inhärenten Dezentralisierung von Ethereum beschlossen, dApps zu erstellen:
+
+- Jeder, der im Netzwerk ist, hat die Erlaubnis, den Dienst zu nutzen – oder anders ausgedrückt, es ist keine Erlaubnis erforderlich.
+- Niemand kann dich blockieren oder dir den Zugang zum Dienst verweigern.
+- Zahlungen sind über den nativen Token, Ether (ETH), eingebaut.
+- Ethereum ist turing-vollständig, was bedeutet, dass du fast alles programmieren kannst.
+
+## Praktische Vergleiche {#practical-comparisons}
+
+| Web2 | Web3 |
+| ------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------- |
+| Twitter kann jeden Account oder Tweet zensieren | Web3-Tweets wären unzensierbar, da die Kontrolle dezentral ist |
+| Ein Zahlungsservice kann beschließen, keine Zahlungen für bestimmte Arbeitsarten zuzulassen | Web3-Zahlungs-Apps erfordern keine persönlichen Daten und können Zahlungen nicht verhindern |
+| Server für Gig-Economy-Apps könnten ausfallen und die Einkommen der Arbeitnehmer beeinträchtigen | Web3-Server können nicht ausfallen – sie verwenden Ethereum, ein dezentralisiertes Netzwerk von tausenden Computern als Backend |
+
+Dies bedeutet nicht, dass alle Dienste in eine dApp umgewandelt werden müssen. Diese Beispiele zeigen die wichtigsten Unterschiede zwischen Web2- und Web3-Dienstleistungen.
+
+## Web3 – Einschränkungen {#web3-limitations}
+
+Web3 hat momentan einige Einschränkungen:
+
+- Skalierbarkeit – Transaktionen sind auf Web3 langsamer, da sie dezentral sind. Änderungen am Zustand, wie eine Zahlung, müssen von einem Miner/Validator bearbeitet und über das gesamte Netzwerk verbreitet werden.
+- UX – Eine Interaktion mit Web3-Anwendungen kann zusätzliche Schritte, Software und Ausbildung erfordern. Dies kann eine Hürde für die Adoption sein.
+- Barrierefreiheit – Die fehlende Integration in moderne Webbrowser macht Web3 für die meisten Benutzer weniger zugänglich.
+- Kosten – Die erfolgreichsten dApps legen sehr kleine Teile ihres Codes auf die Blockchain, da dies teuer ist.
+
+## Zentralisierung vs. Dezentralisierung {#centralization-vs-decentralization}
+
+In der unten stehenden Tabelle findest du einige Vor- und Nachteile zentralisierter und dezentralisierter digitaler Netzwerke.
+
+| Zentralisierte Systeme | Dezentralisierte Systeme |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Niedriger Netzwerkdurchmesser (alle Teilnehmer sind mit einer zentralen Behörde verbunden); Informationen werden schnell verbreitet, da die Verbreitung durch eine zentrale Autorität mit vielen rechnerischen Ressourcen gehandhabt wird. | Die am weitesten entfernten Teilnehmer im Netzwerk können möglicherweise viele Abstände voneinander entfernt sein. Von einer Seite des Netzwerks ausgestrahlte Informationen können lange brauchen, bis sie die andere Seite erreichen. |
+| In der Regel leistungsfähiger (höherer Durchsatz, weniger gesamte Rechenressourcen nötig) und leichter implementierbar. | In der Regel niedrigere Leistung (niedrigerer Durchsatz, mehr gesamte Rechenressourcen nötig) und komplexer zu implementieren. |
+| Im Falle widersprüchlicher Daten ist die Auflösung klar und einfach: Die ultimative Quelle der Wahrheit ist die zentrale Autorität. | Ein Protokoll (oft komplex) wird für die Streitbeilegung benötigt , wenn Peers widersprüchliche Ansprüche auf den Zustand der Daten erheben, auf die die Teilnehmer synchronisiert werden sollen. |
+| Single Point of Failure: Böswillige Akteure können das Netzwerk möglicherweise durch gezielte Angriffe auf die zentrale Autorität ausschalten. | No Single Point of Failure: Das Netzwerk kann immer noch funktionieren, auch wenn ein großer Teil der Teilnehmer angegriffen bzw. ausgeschaltet wird. |
+| Die Koordination zwischen den Netzwerkteilnehmern ist viel einfacher und wird von einer zentralen Autorität verwaltet. Die zentrale Autorität kann Netzwerkteilnehmer dazu zwingen, Upgrades, Protokoll-Updates etc. mit sehr wenig Widerstand zu übernehmen. | Die Koordinierung ist oft schwierig, da kein einziger Agent das letzte Wort bei Entscheidungen auf Netzwerkebene, Protokoll-Upgrades usw. hat. Im schlimmsten Fall neigt das Netzwerk zur Zersplitterung, wenn es Meinungsverschiedenheiten über Änderungen des Protokolls gibt. |
+| Die zentrale Autorität kann Daten zensieren, wodurch Teile des Netzwerks von der Interaktion mit dem Rest des Netzes abgeschnitten werden könnten. | Zensur ist viel schwieriger, da Informationen viele Möglichkeiten haben, sich über das Netzwerk zu verbreiten. |
+| Die Teilnahme am Netzwerk wird von der zentralen Autorität kontrolliert. | Jeder kann am Netzwerk teilnehmen; es gibt keine „Gatekeeper“. Idealerweise sind die Teilnahmekosten sehr niedrig. |
+
+Beachte, dass dies allgemeine Muster sind, die nicht in jedem Netzwerk zutreffend sind. Darüber hinaus liegt in Wirklichkeit der Grad der Zentralisierung bzw. Dezentralisierung eines Netzwerks auf einem Spektrum; kein Netzwerk ist vollständig zentralisiert oder vollständig dezentralisiert.
+
+## Weiterführende Informationen {#further-reading}
+
+- [Was ist Web3?](/web3/) – _ethereum.org_
+- [Die Architektur einer Web 3.0 Anwendung](https://www.preethikasireddy.com/post/the-architecture-of-a-web-3-0-application) – _Preethi Kasireddy_
+- [Die Bedeutung der Dezentralisierung](https://medium.com/@VitalikButerin/the-meaning-of-decentralization-a0c92b76a274) _Feb 6, 2017 – Vitalik Buterin_
+- [Why Decentralization Matters](https://medium.com/s/story/why-decentralization-matters-5e3f79f7638e) _Feb 18, 2018 – Chris Dixon_
+- [Was ist Web 3.0 & Warum es wichtig ist](https://medium.com/fabric-ventures/what-is-web-3-0-why-it-matters-934eb07f3d2b) _Dez 31, 2019 – Max Mersch und Richard Muirhead_
diff --git a/src/intl/de/page-developers-docs.json b/src/intl/de/page-developers-docs.json
index efba1bca982..33eceb268be 100644
--- a/src/intl/de/page-developers-docs.json
+++ b/src/intl/de/page-developers-docs.json
@@ -1,60 +1,99 @@
{
"docs-nav-accounts": "Konten",
+ "docs-nav-accounts-description": "Entitäten im Netzwerk, die ein Guthaben halten und Transaktionen senden können",
"docs-nav-advanced": "Fortgeschritten",
"docs-nav-backend-apis": "Backend-APIs",
"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-compiling-smart-contracts": "Kompilieren von Smart Contracts",
"docs-nav-composability": "Zusammensetzbarkeit",
"docs-nav-consensus-mechanisms": "Konsensmechanismus",
+ "docs-nav-consensus-mechanisms-description": "Wie sich die einzelnen Nodes eines verteilten Netzwerks auf den aktuellen Zustand des Systems einigen",
"docs-nav-data-and-analytics": "Daten und Analysen",
+ "docs-nav-data-and-analytics-description": "Wie Blockchain-Daten aggregiert, organisiert und in dApps implementiert werden",
"docs-nav-dart": "Dart",
"docs-nav-delphi": "Delphi",
"docs-nav-deploying-smart-contracts": "Einsetzen von Smart Contracts",
"docs-nav-development-frameworks": "Entwicklungs-Frameworks",
+ "docs-nav-development-frameworks-description": "Werkzeuge, die das Entwickeln mit Ethereum erleichtern",
"docs-nav-development-networks": "Entwicklungsnetzwerke",
+ "docs-nav-development-networks-description": "Lokale Blockchain-Umgebungen zum Testen von dApps vor dem Deployment",
"docs-nav-dot-net": ".NET",
- "docs-nav-erc-20": "ERC-20",
- "docs-nav-erc-721": "ERC-721",
+ "docs-nav-erc-20": "ERC-20: Fungible Tokens",
+ "docs-nav-erc-721": "ERC-721: NFTs",
"docs-nav-erc-777": "ERC-777",
"docs-nav-erc-1155": "ERC-1155",
"docs-nav-ethereum-client-apis": "Ethereum-Client-APIs",
+ "docs-nav-ethereum-client-apis-description": "Bequeme Bibliotheken, die es deiner Webapplikation erlauben, mit Ethereum und Smart Contracts zu interagieren",
"docs-nav-ethereum-stack": "Ethereum-Stack",
"docs-nav-evm": "Ethereum Virtual Machine (EVM)",
+ "docs-nav-evm-description": "Die EVM übernimmt die gesamte Transaktionsabwicklung im Ethereum-Netzwerk",
"docs-nav-foundational-topics": "Grundsätzliche Themen",
"docs-nav-gas": "Gas",
+ "docs-nav-gas-description": "Rechenleistung, die benötigt wird, um Transaktionen zu bearbeiten, die von Transaktionsabsendern in ETH bezahlt werden",
"docs-nav-golang": "Golang",
"docs-nav-integrated-development-environments-ides": "Integrierte Entwicklungsumgebungen (IDEs)",
+ "docs-nav-integrated-development-environments-ides-description": "Die besten Umgebungen zum Schreiben von dApp-Code",
"docs-nav-intro-to-dapps": "Einführung in dApps",
+ "docs-nav-intro-to-dapps-description": "Eine Einführung in dezentralisierte Anwendungen",
+ "docs-nav-intro-to-ether": "Einführung in Ether",
+ "docs-nav-intro-to-ether-description": "Eine kurze Übersicht über Ether",
"docs-nav-intro-to-ethereum": "Einführung in Ethereum",
+ "docs-nav-intro-to-ethereum-description": "Eine kurze Übersicht über Ethereum",
"docs-nav-intro-to-the-stack": "Einführung in den Stack",
+ "docs-nav-intro-to-the-stack-description": "Eine Übersicht des Ethereum-/web3-Stacks",
"docs-nav-java": "Java",
"docs-nav-java-script-apis": "JavaScript-APIs",
"docs-nav-javascript": "JavaScript",
+ "docs-nav-json-rpc": "JSON-RPC",
+ "docs-nav-mev": "Miner 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-networks": "Netzwerke",
+ "docs-nav-networks-description": "Implementierung von Ethereum inklusive Testnetzen",
"docs-nav-nodes-and-clients": "Nodes und Clients",
+ "docs-nav-nodes-and-clients-description": "Die Personen, die am Netzwerk teilnehmen, und die Software, die sie zur Überprüfung von Transaktionen verwenden",
+ "docs-nav-opcodes": "Operationscodes",
+ "docs-nav-run-a-node": "Einen Node ausführen",
+ "docs-nav-client-diversity": "Client-Diversität",
"docs-nav-nodes-as-a-service": "Nodes als Dienstleistung",
"docs-nav-oracles": "Oracles",
+ "docs-nav-oracles-description": "Wie Informationen in die Ethereum-Blockchain eingefügt werden",
"docs-nav-programming-languages": "Programmiersprachen",
- "docs-nav-proof-of-stake": "Proof-of-stake",
- "docs-nav-proof-of-work": "Proof-of-work",
+ "docs-nav-programming-languages-description": "Wie man mit Ethereum mit Sprachen beginnt, die man vielleicht schon kennt",
+ "docs-nav-proof-of-stake": "Proof-of-Stake",
+ "docs-nav-proof-of-work": "Proof-of-Work",
"docs-nav-python": "Python",
- "docs-nav-readme": "README",
+ "docs-nav-readme": "Übersicht",
+ "docs-nav-ruby": "Ruby",
"docs-nav-rust": "Rust",
"docs-nav-scaling": "Skalierung",
- "docs-nav-smart-contract-security": "Sicherheit",
+ "docs-nav-scaling-description": "Methoden zur Erhaltung der Dezentralisierung und Sicherheit während des Wachstums von Ethereum",
+ "docs-nav-scaling-optimistic-rollups": "Optimistic Rollups",
+ "docs-nav-scaling-zk-rollups": "Zero-Knowledge Rollups",
+ "docs-nav-scaling-channels": "State Channels",
+ "docs-nav-scaling-sidechains": "Sidechains",
+ "docs-nav-scaling-plasma": "Plasma",
+ "docs-nav-scaling-validium": "Validium",
+ "docs-nav-smart-contract-security": "Smart-Contract-Sicherheit",
+ "docs-nav-smart-contract-security-description": "Best Practices für das Management von Smart-Contract-Angriffen und Schwachstellen",
"docs-nav-smart-contract-anatomy": "Anatomie von Smart Contracts",
"docs-nav-smart-contract-languages": "Sprachen von Smart Contracts",
"docs-nav-smart-contracts": "Smart Contracts",
+ "docs-nav-smart-contracts-description": "Programme, die sich an einer Ethereum-Adresse befinden und Funktionen ausführen, wenn sie durch Transaktionen ausgelöst werden",
"docs-nav-smart-contracts-libraries": "Sammlungen von Smart Contracts",
"docs-nav-standards": "Standards",
+ "docs-nav-standards-description": "Einvernehmen über Protokolle zur Erhaltung der Effizienz und Zugänglichkeit von Projekten für die Community",
"docs-nav-storage": "Speicher",
+ "docs-nav-storage-description": "Dezentralisierte Speicherstrukturen und -mechanismen",
"docs-nav-testing-smart-contracts": "Testen von Smart Contracts",
"docs-nav-token-standards": "Tokenstandards",
"docs-nav-transactions": "Transaktionen",
+ "docs-nav-transactions-description": "Transfers und andere Aktionen, die Ethereums Zustand ändern",
"docs-nav-web2-vs-web3": "Web2 vs Web3",
- "page-calltocontribute-desc-1": "Wenn du in diesem Bereich ein Experte bist und gerne etwas beitragen möchtest, editiere diese Seite und versprühe dein Wissen.",
+ "docs-nav-web2-vs-web3-description": "Die grundlegenden Unterschiede, die blockchain-basierte Anwendungen bieten",
+ "page-calltocontribute-desc-1": "Wenn du in diesem Bereich ein Experte bist und gerne etwas beitragen möchtest, editiere diese Seite und verbreite dein Wissen.",
"page-calltocontribute-desc-2": "Dies wird dir angerechnet und du wirst der Ethereum-Community helfen!",
"page-calltocontribute-desc-3": "Verwende dies flexibel",
"page-calltocontribute-desc-4": "Fragen? Frag uns im #content-Kanal auf unserem Discord-Server",
From b2c04f0381e8bb29bf3b04cedfb2c12dada0d530 Mon Sep 17 00:00:00 2001
From: luminoir-dustin <93941381+luminoir-dustin@users.noreply.github.com>
Date: Mon, 9 May 2022 22:36:36 +0800
Subject: [PATCH 012/298] Update index.md
Update index.md
Update index.md
Revert "Update index.md"
This reverts commit 752bacc1ed767218968a8a1056ea6250e28f43c3.
Revert "Update index.md"
This reverts commit c419dd6496c02d79c1bd720f9935c79d2588b0ab.
Revert "Update index.md"
This reverts commit 05a931a382c7989a138bb506c900b75405a25790.
Revert "Revert "Update index.md""
This reverts commit c7f3c3e3298190cb24c0750a38cfbccd8238caed.
Revert "Revert "Update index.md""
This reverts commit 8f253d024513502ffb12a02be40cf7e214127bf0.
Revert "Revert "Update index.md""
This reverts commit e4f673980d702f6586844bef94e6b8d3d83f81b1.
---
.../get-involved/open-research/index.md | 41 ++++++++++++++++++-
1 file changed, 40 insertions(+), 1 deletion(-)
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
index 5ec80ea2a5e..af73d7c6eef 100644
--- a/src/content/community/get-involved/open-research/index.md
+++ b/src/content/community/get-involved/open-research/index.md
@@ -14,7 +14,46 @@ Do you have a background in mathematics, cryptography, or economics? You might b
- [x] Create basic page
- [ ] Talk to researchers - what are the open questions? What are topics & resources?
- [ ] Decide how topics should be categorized - what's the hierarchy?
-
+## Page Content Structure
+- There should be as few categories as possible needed to achieve the following:
+ - encompass the full gamut of research topics
+ - differentiated enough from each other to minimise sub-category redundancy and duplication
+ - sub-categories may qualify in multiple Parent Categories, but this should be minimised to reduce confusion
+- Ideally, less than [10 main categories, with less than 12 sub-categories within each](https://www.researchgate.net/publication/303676802_HICK%27S_LAW_IS_MIRRORED_IN_THE_BRAIN_AN_FMRI_STUDY_OF_THE_CHOICE_REACTION_TIME).
+ - This is to reduce the cognitive load of parsing too many categories if they are all displayed at once
+ - There should be an AJAX style search bar that allows users to search categories, with some intelligent matching of synonyms
+ - The Parent Categories should be sufficiently broad, yet clearly delineated so the location of Sub-Categories are obvious to the average user familiar with the Topic.
+- Researchers should weigh in on whether the categories are redundant/incomplete/contradictory.
+- Sub-Categories as tags, not folders.
+ - In some cases, sub-categories may appear across multiple main categories based on application
+ - eg: Zero Knowledge Proofs can appear in Privacy, Security AND Scalability, depending on the context ZKPs are being used or applied.
+ - Or should ZKPs be their own Parent Category?
+ - These are the kinds of discussions/arguments we need to have around the organisational hierarchy of the information
+
+## Sample: ESP’s [Parent Categories](https://esp.ethereum.foundation/_next/image?url=%2F_next%2Fstatic%2Fmedia%2Fabout.9c9105a9.png&w=828&q=75)
+
+> ESP's categories are very clear and have good delineation, many topics would fall very clearly into one Category exclusively. One area to improve would be to make “Research” less broad, and to specify more discrete Topics which require Research.
+>
+- Community & Education
+- Consensus Layer
+- Cryptography & zkp
+- Execution Layer
+- Layer 2
+- Libraries & Tooling
+- Research
+
+## Metadata displayed under Content/Research Topic
+
+- Title (Header would be the name of the area of research)
+ - Outline (Brief writeup of the Scope or Research Topic within larger Area of Research) [sample](https://blog.ethereum.org/2022/02/24/japan-local-grants-round/)
+ - List of Teams/Researchers/People working on Research Topic
+- Additional Information (optional/good to have)
+ - Existing funding and grants
+
+### Open Source Submission Inputs
+
+- Allow user submission of Areas of Research
+- Allow user submission of Teams/Researchers/People under Area of Research
## Community
List general communities / resources for general topics?
From 3e5fddbb5042ec3b905617813797d0ef9e2a144e Mon Sep 17 00:00:00 2001
From: Emmanuel Awosika <102589267+emmanuel-awosika@users.noreply.github.com>
Date: Fri, 13 May 2022 14:37:39 +0100
Subject: [PATCH 013/298] Update
src/content/developers/docs/smart-contracts/composability/index.md
Co-authored-by: Paul Wackerow <54227730+wackerow@users.noreply.github.com>
---
.../developers/docs/smart-contracts/composability/index.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/content/developers/docs/smart-contracts/composability/index.md b/src/content/developers/docs/smart-contracts/composability/index.md
index f1b12a38a83..f324f625e06 100644
--- a/src/content/developers/docs/smart-contracts/composability/index.md
+++ b/src/content/developers/docs/smart-contracts/composability/index.md
@@ -20,7 +20,7 @@ In Ethereum, every smart contract is a Lego of sorts—you can use smart contrac
Ethereum smart contracts are like public APIs, so anyone can interact with the contract or integrate them into dapps for added functionality. Smart contract composability generally works off three principles: modularity, autonomy, and discoverability:
-**1. Modularity**: This is the ability of individual components to perform a specific task. In Ethereum, every smart contract has specific use-case (as shown in the Uniswap example).
+**1. Modularity**: This is the ability of individual components to perform a specific task. In Ethereum, every smart contract has a specific use case (as shown in the Uniswap example).
**2. Autonomy**: Composable components must be able to operate independently. Each smart contract in Ethereum is self-executing and can function without relying on other parts of the system.
From 3383545a0b74de09f4557475daf3136109b6edf9 Mon Sep 17 00:00:00 2001
From: Emmanuel Awosika <102589267+emmanuel-awosika@users.noreply.github.com>
Date: Fri, 13 May 2022 14:51:49 +0100
Subject: [PATCH 014/298] Update index.md
Added an example under "Better user experience" section to illustrate how composability allows users to use complex features.
---
.../docs/smart-contracts/composability/index.md | 9 ++++++++-
1 file changed, 8 insertions(+), 1 deletion(-)
diff --git a/src/content/developers/docs/smart-contracts/composability/index.md b/src/content/developers/docs/smart-contracts/composability/index.md
index f324f625e06..3adb58c5097 100644
--- a/src/content/developers/docs/smart-contracts/composability/index.md
+++ b/src/content/developers/docs/smart-contracts/composability/index.md
@@ -38,11 +38,18 @@ If there is a smart contract that solves one problem, other developers can reuse
Composability encourages innovation and experimentation because developers are free to reuse, modify, duplicate, or integrate open-source code to create desired results. As a result, development teams spend less time on basic functionality and can allocate more time experimenting with new features.
-
### Better user experience {#better-user-experience}
Interoperability between components of the Ethereum ecosystem improves the user experience. Users can access greater functionality when dapps integrate external smart contracts than in a fragmented ecosystem where applications cannot communicate.
+We'll use an example from arbitrage trading to illustrate the benefits of interoperability:
+
+If a token is trading higher on `exchange A` than `exchange B`, you can take advantage of the price difference to make profit. However, you can only do that if you have enough capital to fund the transaction (i.e., buying the token from `exchange B` and selling it on `exchange A`).
+
+In a scenario where you don't have enough funds to cover the trade, a flash loan might be ideal. [Flash loans](/defi/#flash-loans) are highly technical, but the basic idea is that you can borrow assets (without collateral) and return same within *one* transaction.
+
+Going back to our initial example, an arbitrage trader can take out a large flash loan, buy tokens from `exchange B`, sell them on `exchange A`, pay back the capital + interest, and keep the profit, within the same transaction. This complex logic requires combining calls to multiple contracts, which wouldn't be possible if smart contracts lacked interoperability.
+
## Examples of composability in Ethereum {#composability-in-ethereum}
### Token swaps {#token-swaps}
From a2b170224f1be0f36296eb0067774557fd2f2aa1 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Sun, 15 May 2022 23:16:34 -0600
Subject: [PATCH 015/298] Update src/content/developers/docs/bridges/index.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
src/content/developers/docs/bridges/index.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/content/developers/docs/bridges/index.md b/src/content/developers/docs/bridges/index.md
index 0332fd9c3d2..c3a5d9be698 100644
--- a/src/content/developers/docs/bridges/index.md
+++ b/src/content/developers/docs/bridges/index.md
@@ -21,7 +21,7 @@ Bridges offer a way for isolated blockchain environments to connect with each ot
Put simply, bridges unlock developer potential by allowing blockchain networks to exchange data and move assets between them.
-Different blockchains and communities have unique strengths, weaknesses, and approaches to building applications (such as speed, throughput, costliness, etc.). Bridges help the development of the overall crypto ecosystem by enabling blockchains to leverage the innovations of each other.
+Blockchains have unique strengths, weaknesses, and approaches to building applications (such as speed, throughput, costliness, etc.). Bridges help the development of the overall crypto ecosystem by enabling blockchains to leverage the innovations of each other.
Moreover, bridges unlock new use cases and possibilities for both users and developers. For example, users can now move assets across different ecosystems, making them more productive. For developers and protocols, bridges open up an almost limitless amount of possibilities by expanding the design space for [dApps](/developers/docs/dapps/) across multiple crypto ecosystems.
From 04efb0805a5adaba14198018e88d9818842dde38 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Sun, 15 May 2022 23:17:16 -0600
Subject: [PATCH 016/298] Update src/content/developers/docs/bridges/index.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
src/content/developers/docs/bridges/index.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/content/developers/docs/bridges/index.md b/src/content/developers/docs/bridges/index.md
index c3a5d9be698..afe62a385f4 100644
--- a/src/content/developers/docs/bridges/index.md
+++ b/src/content/developers/docs/bridges/index.md
@@ -35,7 +35,7 @@ While there are many [types of bridge designs](https://blog.li.fi/what-are-block
## Bridge types {#bridge-types}
-Bridges come in different types and flavors. Broadly, bridges can usually be classified into one of the following buckets:
+Bridges can usually be classified into one of the following buckets:
- **Native Bridges –** These bridges are typically built to bootstrap liquidity on a particular blockchain, making it easier for users to move funds to the ecosystem. For example, the Avalanche Bridge is built to make it convenient for users to bridge from [Ethereum](/developers/docs/intro-to-ethereum/) to Avalanche. Other such bridges include Polygon PoS Bridge, Arbitrum Bridge, etc.
- **Validator or Oracle Based Bridges –** These bridges rely on an external validator set or oracles to validate cross-chain transfers. Examples: Multichain and Across.
From 5e661396846555a3a6754e9a2c4be481b0ee208a Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Sun, 15 May 2022 23:18:23 -0600
Subject: [PATCH 017/298] Update src/content/developers/docs/bridges/index.md
Co-authored-by: Paul Wackerow <54227730+wackerow@users.noreply.github.com>
---
src/content/developers/docs/bridges/index.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/content/developers/docs/bridges/index.md b/src/content/developers/docs/bridges/index.md
index afe62a385f4..1487765e0be 100644
--- a/src/content/developers/docs/bridges/index.md
+++ b/src/content/developers/docs/bridges/index.md
@@ -5,7 +5,7 @@ lang: en
sidebar: true
---
-With the proliferation of L1 blockchains and L2 [scaling](/developers/docs/scaling/) solutions, alongside an ever-growing number of decentralized applications going cross-chain, the need for communication and asset movement across chains has never been more important.
+With the proliferation of L1 blockchains and L2 [scaling](/developers/docs/scaling/) solutions, alongside an ever-growing number of decentralized applications going cross-chain, the need for communication and asset movement across chains has become an essential part of network infrastructure. Different types of bridges exist to help make this possible.
This is where blockchain bridges come in.
From f79380d54d7ad465ecd12927bf9b6309c2bcf247 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Sun, 15 May 2022 23:19:25 -0600
Subject: [PATCH 018/298] Update src/content/developers/docs/bridges/index.md
Co-authored-by: Paul Wackerow <54227730+wackerow@users.noreply.github.com>
---
src/content/developers/docs/bridges/index.md | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/src/content/developers/docs/bridges/index.md b/src/content/developers/docs/bridges/index.md
index 1487765e0be..dbb777c31ed 100644
--- a/src/content/developers/docs/bridges/index.md
+++ b/src/content/developers/docs/bridges/index.md
@@ -55,7 +55,10 @@ With bridges, there are no perfect solutions. Rather, there are only trade-offs
At a high level, bridges can be categorized as trusted and trustless.
- **Trusted –** Trusted bridges are externally verified. They use an external set of verifiers (Federations with multi-sig, multi-party computation systems, oracle network) to send data across chains. As a result, they can offer great connectivity and enable fully generalized message passing across chains. They also tend to perform well with speed and cost-effectiveness. This comes at the cost of security, as users have to rely on the security of the bridge.
-- **Trustless –** These bridges rely on the blockchains they are connecting and their validators to transfer messages and tokens. They are 'trustless' because they do not add new trust assumptions (in addition to the blockchains). As a result, trustless bridges are considered to be more secure than trusted bridges. To evaluate trustless bridges based on other factors, we must break them down into generalized message passing bridges and liquidity networks.
+- **Trustless –** These bridges rely on the blockchains they are connecting and their validators to transfer messages and tokens. They are 'trustless' because they do not add new trust assumptions (in addition to the blockchains). As a result, trustless bridges are considered to be more secure than trusted bridges.
+
+To evaluate trustless bridges based on other factors, we must break them down into generalized message passing bridges and liquidity networks.
+
- **Generalized Message Passing Bridges –** These bridges excel with security and the ability to transfer more complex data across chains. Typically, they are also good with cost-effectiveness. However, these strengths generally come at the cost of connectivity for light client bridges (ex: IBC) and speed drawbacks for optimistic bridges (ex: Nomad) that use fraud proofs.
- **Liquidity Networks –** These bridges use atomic swaps for transferring assets and are locally verified systems (i.e., they use the underlying blockchains’ validators to verify transactions). As a result, they excel with security and speed. Moreover, they are considered comparatively cost-effective and offer good connectivity. However, the major tradeoff is their ability to pass more complex data – as they don’t support cross-chain message passing.
From 8260ff1e1e32db7fc511f64d0e4a857bb0513dfd Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Sun, 15 May 2022 23:22:29 -0600
Subject: [PATCH 019/298] Update src/content/developers/docs/bridges/index.md
Co-authored-by: Paul Wackerow <54227730+wackerow@users.noreply.github.com>
---
src/content/developers/docs/bridges/index.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/content/developers/docs/bridges/index.md b/src/content/developers/docs/bridges/index.md
index dbb777c31ed..d6b8df6af59 100644
--- a/src/content/developers/docs/bridges/index.md
+++ b/src/content/developers/docs/bridges/index.md
@@ -42,7 +42,7 @@ Bridges can usually be classified into one of the following buckets:
- **Generalized Message Passing Bridges –** These bridges can transfer assets, along with messages and arbitrary data across chains. Examples: Nomad and LayerZero.
- **Liquidity Networks –** These bridges primarily focus on transferring assets from one chain to another via atomic swaps. Generally, they don’t support cross-chain message passing. Examples: Connext and Hop.
-## Evolution of bridges {#evolution-of-bridges}
+## Trade-offs to consider {#trade-offs}
With bridges, there are no perfect solutions. Rather, there are only trade-offs made to fulfill a purpose. Developers and users can evaluate bridges based on the following factors:
From d9ebde8f4b2963fd7004ab1c865ab9175fe1138b Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Sun, 15 May 2022 23:22:42 -0600
Subject: [PATCH 020/298] Update src/content/developers/docs/bridges/index.md
Co-authored-by: Paul Wackerow <54227730+wackerow@users.noreply.github.com>
---
src/content/developers/docs/bridges/index.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/content/developers/docs/bridges/index.md b/src/content/developers/docs/bridges/index.md
index d6b8df6af59..23fedc9527d 100644
--- a/src/content/developers/docs/bridges/index.md
+++ b/src/content/developers/docs/bridges/index.md
@@ -64,7 +64,7 @@ To evaluate trustless bridges based on other factors, we must break them down in
## Risk with bridges {#risk-with-bridges}
-Bridges account for the top 3 [biggest hacks in DeFi](https://rekt.news/leaderboard/) and are still in the early stages of development. Using any bridge carries the following risks:
+Bridges account for the top three [biggest hacks in DeFi](https://rekt.news/leaderboard/) and are still in the early stages of development. Using any bridge carries the following risks:
- **Smart Contract Risk –** While many bridges have successfully passed audits, all it takes is one flaw in a smart contract for assets to be exposed to hacks (ex: [Solana’s Wormhole Bridge](https://rekt.news/wormhole-rekt/)).
- **Technology Risk –** Given the complexity of bridge operations, there is a possibility of technology risks like software failure, buggy code, human error, spam, and malicious attacks.
From 187898feb36f053430d2f3bcf7cf47410a89f65e Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Sun, 15 May 2022 23:22:57 -0600
Subject: [PATCH 021/298] Update src/content/developers/docs/bridges/index.md
Co-authored-by: Paul Wackerow <54227730+wackerow@users.noreply.github.com>
---
src/content/developers/docs/bridges/index.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/content/developers/docs/bridges/index.md b/src/content/developers/docs/bridges/index.md
index 23fedc9527d..98f7942f635 100644
--- a/src/content/developers/docs/bridges/index.md
+++ b/src/content/developers/docs/bridges/index.md
@@ -69,7 +69,7 @@ Bridges account for the top three [biggest hacks in DeFi](https://rekt.news/lead
- **Smart Contract Risk –** While many bridges have successfully passed audits, all it takes is one flaw in a smart contract for assets to be exposed to hacks (ex: [Solana’s Wormhole Bridge](https://rekt.news/wormhole-rekt/)).
- **Technology Risk –** Given the complexity of bridge operations, there is a possibility of technology risks like software failure, buggy code, human error, spam, and malicious attacks.
- **Systematic Financial Risks** – Many bridges use wrapped assets to mint canonical versions of the original asset on a new chain. This exposes the ecosystem to systematic risk, as we have seen wrapped versions of tokens exploited.
-- **Trusted Third-Party Risk –** Some bridges utilize a trusted design that requires users to rely on the assumption that validators will not collude to steal user funds. The need for users to trust these third-party actors exposes them to risks such as rugs, censorship, and other malicious activities.
+- **Trusted Third-Party Risk –** Some bridges utilize a trusted design that requires users to rely on the assumption that validators will not collude to steal user funds. The need for users to trust these third-party actors exposes them to risks such as rug pulls, censorship, and other malicious activities.
- **Open Issues –** Given that bridges are in the nascent stages of development, there are many unanswered questions related to how bridges will perform in different market conditions, like times of network congestion and during unforeseen events such as network-level attacks or state rollbacks. This uncertainty poses certain risks, the degree of which is still unknown.
## How can dapps use bridges? {#how-can-dapps-use-bridges}
From e7d18b33ac53519cefca9de6f9b2965a5a3e502b Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Sun, 15 May 2022 23:24:52 -0600
Subject: [PATCH 022/298] change dApp -> dapp
---
src/content/developers/docs/bridges/index.md | 24 ++++++++++----------
1 file changed, 12 insertions(+), 12 deletions(-)
diff --git a/src/content/developers/docs/bridges/index.md b/src/content/developers/docs/bridges/index.md
index 98f7942f635..8cd4b9b88cd 100644
--- a/src/content/developers/docs/bridges/index.md
+++ b/src/content/developers/docs/bridges/index.md
@@ -23,7 +23,7 @@ Put simply, bridges unlock developer potential by allowing blockchain networks t
Blockchains have unique strengths, weaknesses, and approaches to building applications (such as speed, throughput, costliness, etc.). Bridges help the development of the overall crypto ecosystem by enabling blockchains to leverage the innovations of each other.
-Moreover, bridges unlock new use cases and possibilities for both users and developers. For example, users can now move assets across different ecosystems, making them more productive. For developers and protocols, bridges open up an almost limitless amount of possibilities by expanding the design space for [dApps](/developers/docs/dapps/) across multiple crypto ecosystems.
+Moreover, bridges unlock new use cases and possibilities for both users and developers. For example, users can now move assets across different ecosystems, making them more productive. For developers and protocols, bridges open up an almost limitless amount of possibilities by expanding the design space for [dapps](/developers/docs/dapps/) across multiple crypto ecosystems.
## How do bridges work? {#how-do-bridges-work}
@@ -55,12 +55,12 @@ With bridges, there are no perfect solutions. Rather, there are only trade-offs
At a high level, bridges can be categorized as trusted and trustless.
- **Trusted –** Trusted bridges are externally verified. They use an external set of verifiers (Federations with multi-sig, multi-party computation systems, oracle network) to send data across chains. As a result, they can offer great connectivity and enable fully generalized message passing across chains. They also tend to perform well with speed and cost-effectiveness. This comes at the cost of security, as users have to rely on the security of the bridge.
-- **Trustless –** These bridges rely on the blockchains they are connecting and their validators to transfer messages and tokens. They are 'trustless' because they do not add new trust assumptions (in addition to the blockchains). As a result, trustless bridges are considered to be more secure than trusted bridges.
+- **Trustless –** These bridges rely on the blockchains they are connecting and their validators to transfer messages and tokens. They are 'trustless' because they do not add new trust assumptions (in addition to the blockchains). As a result, trustless bridges are considered to be more secure than trusted bridges.
To evaluate trustless bridges based on other factors, we must break them down into generalized message passing bridges and liquidity networks.
- - **Generalized Message Passing Bridges –** These bridges excel with security and the ability to transfer more complex data across chains. Typically, they are also good with cost-effectiveness. However, these strengths generally come at the cost of connectivity for light client bridges (ex: IBC) and speed drawbacks for optimistic bridges (ex: Nomad) that use fraud proofs.
- - **Liquidity Networks –** These bridges use atomic swaps for transferring assets and are locally verified systems (i.e., they use the underlying blockchains’ validators to verify transactions). As a result, they excel with security and speed. Moreover, they are considered comparatively cost-effective and offer good connectivity. However, the major tradeoff is their ability to pass more complex data – as they don’t support cross-chain message passing.
+- **Generalized Message Passing Bridges –** These bridges excel with security and the ability to transfer more complex data across chains. Typically, they are also good with cost-effectiveness. However, these strengths generally come at the cost of connectivity for light client bridges (ex: IBC) and speed drawbacks for optimistic bridges (ex: Nomad) that use fraud proofs.
+- **Liquidity Networks –** These bridges use atomic swaps for transferring assets and are locally verified systems (i.e., they use the underlying blockchains’ validators to verify transactions). As a result, they excel with security and speed. Moreover, they are considered comparatively cost-effective and offer good connectivity. However, the major tradeoff is their ability to pass more complex data – as they don’t support cross-chain message passing.
## Risk with bridges {#risk-with-bridges}
@@ -74,29 +74,29 @@ Bridges account for the top three [biggest hacks in DeFi](https://rekt.news/lead
## How can dapps use bridges? {#how-can-dapps-use-bridges}
-Here are some practical applications that developers can consider about bridges and taking their dApp cross-chain:
+Here are some practical applications that developers can consider about bridges and taking their dapp cross-chain:
### Integrating bridges {#integrating-bridges}
For developers, there are many ways to add support for bridges:
1. **Building your own bridge –** Building a secure and reliable bridge is not easy, especially if you take a more trust-minimized route. Moreover, it requires years of experience and technical expertise related to scalability and interoperability studies. Additionally, it would require a hands-on team to maintain a bridge and attract sufficient liquidity to make it feasible.
-2. **Showing users multiple bridge options –** Many dApps require users to have their native token to interact with them. To enable users to access their tokens, they offer different bridge options on their website. However, this method is a quick fix to the problem as it takes the user away from the dApp interface and still requires them to interact with other dApps and bridges. This is a cumbersome onboarding experience with the increased scope of making mistakes.
-3. **Integrating a bridge –** This solution doesn’t require the dApp to send users to the external bridge and DEX interfaces. It allows dApps to improve the user onboarding experience. However, this approach has its limitations:
+2. **Showing users multiple bridge options –** Many dapps require users to have their native token to interact with them. To enable users to access their tokens, they offer different bridge options on their website. However, this method is a quick fix to the problem as it takes the user away from the dapp interface and still requires them to interact with other dapps and bridges. This is a cumbersome onboarding experience with the increased scope of making mistakes.
+3. **Integrating a bridge –** This solution doesn’t require the dapp to send users to the external bridge and DEX interfaces. It allows dapps to improve the user onboarding experience. However, this approach has its limitations:
- Assessment and maintenance of bridges are hard and time-consuming.
- Selecting one bridge creates a single point of failure and dependency.
- - The dApp is limited by the bridge’s capabilities.
- - Bridges alone might not be enough. dApps might need DEXs to offer more functionality such as cross-chain swaps.
+ - The dapp is limited by the bridge’s capabilities.
+ - Bridges alone might not be enough. dapps might need DEXs to offer more functionality such as cross-chain swaps.
4. **Integrating multiple bridges –** This solution solves many problems associated with integrating a single bridge. However, it also has limitations, as integrating multiple bridges is resource-consuming and creates technical and communication overheads for developers – the scarcest resource in crypto.
-5. **Integrating a bridge aggregator –** Another option for dApps is integrating a bridge aggregation solution that gives them access to multiple bridges. Bridge aggregators inherit the strengths of all the bridges and thus are not limited by any single bridge’s capabilities. Notably, the bridge aggregators typically maintain the bridge integrations, which saves the dApp from the hassle of staying on top of the technical and operational aspects of a bridge integration.
+5. **Integrating a bridge aggregator –** Another option for dapps is integrating a bridge aggregation solution that gives them access to multiple bridges. Bridge aggregators inherit the strengths of all the bridges and thus are not limited by any single bridge’s capabilities. Notably, the bridge aggregators typically maintain the bridge integrations, which saves the dapp from the hassle of staying on top of the technical and operational aspects of a bridge integration.
That being said, bridge aggregators also have their limitations. For instance, while they can offer more bridge options, many more bridges are typically available in the market other than those offered on the aggregator's platform. Moreover, just like bridges, bridge aggregators are also exposed to smart contracts and technology risks (more smart contracts = more risks).
-If a dApp goes down the route of integrating a bridge or an aggregator, there are different options based on how deep the integration is meant to be. For instance, if it’s only a front-end integration to improve the user onboarding experience, a dApp would integrate the widget. However, if the integration is to explore deeper cross-chain strategies like staking, yield farming, etc., the dApp integrates the SDK or API.
+If a dapp goes down the route of integrating a bridge or an aggregator, there are different options based on how deep the integration is meant to be. For instance, if it’s only a front-end integration to improve the user onboarding experience, a dapp would integrate the widget. However, if the integration is to explore deeper cross-chain strategies like staking, yield farming, etc., the dapp integrates the SDK or API.
### Deploying a dapp on multiple chains {#deploying-a-dapp-on-multiple-chains}
-To deploy a dApp on multiple chains, developers can use development platforms like Alchemy, Hardhat, Truffle, etc. Typically, these platforms come with composable plugins that can enable dApps to go cross-chain. For instance, developers can use a deterministic deployment proxy offered by the hardhat-deploy plugin.
+To deploy a dapp on multiple chains, developers can use development platforms like Alchemy, Hardhat, Truffle, etc. Typically, these platforms come with composable plugins that can enable dapps to go cross-chain. For instance, developers can use a deterministic deployment proxy offered by the hardhat-deploy plugin.
### Monitoring contract activity across chains {#monitoring-contract-activity-across-chains}
From be1a4b175072eeed5a2af6c391f561bcdb3f70f0 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Sun, 15 May 2022 23:25:22 -0600
Subject: [PATCH 023/298] Update src/content/developers/docs/bridges/index.md
Co-authored-by: Paul Wackerow <54227730+wackerow@users.noreply.github.com>
---
src/content/developers/docs/bridges/index.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/content/developers/docs/bridges/index.md b/src/content/developers/docs/bridges/index.md
index 8cd4b9b88cd..e7233a686aa 100644
--- a/src/content/developers/docs/bridges/index.md
+++ b/src/content/developers/docs/bridges/index.md
@@ -90,7 +90,7 @@ For developers, there are many ways to add support for bridges:
4. **Integrating multiple bridges –** This solution solves many problems associated with integrating a single bridge. However, it also has limitations, as integrating multiple bridges is resource-consuming and creates technical and communication overheads for developers – the scarcest resource in crypto.
5. **Integrating a bridge aggregator –** Another option for dapps is integrating a bridge aggregation solution that gives them access to multiple bridges. Bridge aggregators inherit the strengths of all the bridges and thus are not limited by any single bridge’s capabilities. Notably, the bridge aggregators typically maintain the bridge integrations, which saves the dapp from the hassle of staying on top of the technical and operational aspects of a bridge integration.
- That being said, bridge aggregators also have their limitations. For instance, while they can offer more bridge options, many more bridges are typically available in the market other than those offered on the aggregator's platform. Moreover, just like bridges, bridge aggregators are also exposed to smart contracts and technology risks (more smart contracts = more risks).
+ That being said, bridge aggregators also have their limitations. For instance, while they can offer more bridge options, many more bridges are typically available in the market other than those offered on the aggregator's platform. Moreover, just like bridges, bridge aggregators are also exposed to smart contract and technology risks (more smart contracts = more risks).
If a dapp goes down the route of integrating a bridge or an aggregator, there are different options based on how deep the integration is meant to be. For instance, if it’s only a front-end integration to improve the user onboarding experience, a dapp would integrate the widget. However, if the integration is to explore deeper cross-chain strategies like staking, yield farming, etc., the dapp integrates the SDK or API.
From 87ff6193aceeb68949da6f93f9652656e368ebec Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Mon, 16 May 2022 21:29:16 -0600
Subject: [PATCH 024/298] Update src/content/developers/docs/bridges/index.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
src/content/developers/docs/bridges/index.md | 1 -
1 file changed, 1 deletion(-)
diff --git a/src/content/developers/docs/bridges/index.md b/src/content/developers/docs/bridges/index.md
index e7233a686aa..1b713bb2597 100644
--- a/src/content/developers/docs/bridges/index.md
+++ b/src/content/developers/docs/bridges/index.md
@@ -7,7 +7,6 @@ sidebar: true
With the proliferation of L1 blockchains and L2 [scaling](/developers/docs/scaling/) solutions, alongside an ever-growing number of decentralized applications going cross-chain, the need for communication and asset movement across chains has become an essential part of network infrastructure. Different types of bridges exist to help make this possible.
-This is where blockchain bridges come in.
## Need for bridges {#need-for-bridges}
From a5c35ca8d03eed6160e0daef27d259592b236dc3 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Mon, 16 May 2022 21:34:05 -0600
Subject: [PATCH 025/298] Update src/content/developers/docs/bridges/index.md
Co-authored-by: Paul Wackerow <54227730+wackerow@users.noreply.github.com>
---
src/content/developers/docs/bridges/index.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/content/developers/docs/bridges/index.md b/src/content/developers/docs/bridges/index.md
index 1b713bb2597..bf7824ff26f 100644
--- a/src/content/developers/docs/bridges/index.md
+++ b/src/content/developers/docs/bridges/index.md
@@ -30,7 +30,7 @@ While there are many [types of bridge designs](https://blog.li.fi/what-are-block
- **Lock and Mint –** Lock assets on the source chain and mint assets on the destination chain.
- **Burn and Mint –** Burn assets on the source chain and mint assets on the destination chain.
-- **Atomic Swaps –** Swap assets on the source chain for assets on the destination chain.
+- **Atomic Swaps –** Swap assets on the source chain for assets on the destination chain with another party.
## Bridge types {#bridge-types}
From 5c3a742e68bcd4904d903e1e098d48a6dd21b3b6 Mon Sep 17 00:00:00 2001
From: Emmanuel Awosika <102589267+emmanuel-awosika@users.noreply.github.com>
Date: Tue, 17 May 2022 11:13:59 +0100
Subject: [PATCH 026/298] Apply suggestions from code review
Co-authored-by: Paul Wackerow <54227730+wackerow@users.noreply.github.com>
---
src/content/developers/docs/scaling/plasma/index.md | 12 +++++-------
1 file changed, 5 insertions(+), 7 deletions(-)
diff --git a/src/content/developers/docs/scaling/plasma/index.md b/src/content/developers/docs/scaling/plasma/index.md
index f205187d5c5..d04abe56db6 100644
--- a/src/content/developers/docs/scaling/plasma/index.md
+++ b/src/content/developers/docs/scaling/plasma/index.md
@@ -27,18 +27,15 @@ You should have a good understanding of all the foundational topics and a high-l
Plasma, sidechains, and sharding all follow a similar pattern where a collection of "child chains" rely on a "main chain" for consensus. At intervals, cryptographic proofs of transaction validity (hashes) are submitted to the main chain to prevent fraudulent activity on child chains.
-However, the three scaling solutions have slight differences. Here is a quick comparison of Plasma chains, sidechains, and shard chains:
+However, the three scaling solutions have slight differences. Here is a quick comparison of plasma chains, sidechains, and shard chains:
### Plasma vs sidechains
-A [sidechain](https://ethereum.org/en/developers/docs/scaling/sidechains/) is a blockchain operating independently but connects to the main blockchain (Ethereum Mainnet) via a two-way bridge. [Bridges](https://ethereum.org/en/bridges/) allow users to exchange tokens between both blockchains, so they can transact on the sidechain—reducing congestion on the base layer and improving scalability.
-With sidechains, there's the risk of losing your funds. Sidechains use a separate consensus mechanism and, ergo, cannot rely on the security of Ethereum Mainnet (Layer 1).
+A [sidechain](/developers/docs/scaling/sidechains/) is an independently operated blockchain connected to the Ethereum Mainnet via a two-way bridge. [Bridges](/bridges/) allow users to exchange tokens between the two blockchains, so they can transact on the sidechain, reducing congestion on the base layer and improving scalability.
+Since sidechains use a separate consensus mechanism, and because these chains are typically much smaller than Ethereum Mainnet, bridging assets to these chains involves increased risk to your funds. Given the lack of security guarantees inherited from Mainnet in the sidechain model, users risk total loss of funds in the event of an attack on the sidechain.```
-Conversely, Plasma chains are somewhat safer than sidechains because they derive their security from Ethereum's base layer. Like sidechains, Plasma chains can have a different consensus protocol.
+Conversely, plasma chains derive their security from Mainnet are somewhat safer than sidechains. Both sidechains and plasma chains can have different consensus protocols, but the difference is that plasma chains publishes Merkle roots for each block on Ethereum Mainnet. Block roots are small pieces of information we can use to verify information about transactions that happen on a plasma chain. If an attack happens on a plasma chain, users can safely exit to Mainnet and withdraw their funds using the appropriate proofs.
-The difference is that Plasma publishes Merkle roots for each block on the Ethereum main chain. Block roots are small pieces of information we can use to verify information about transactions that happen on a Plasma chain. If an attack happens on a Plasma chain, users can safely exit to the main chain and withdraw their funds using the appropriate proofs.
-
-A simple way to differentiate between Plasma and sidechains is that Plasma chains are non-custodial, while sidechains are custodial.
### Plasma vs sharding
@@ -62,6 +59,7 @@ Multiple projects provide implementations of Plasma that you can integrate into
- [EthHub on Plasma](https://docs.ethhub.io/ethereum-roadmap/layer-2-scaling/plasma/)
- [Learn Plasma](https://www.learnplasma.org/en/)
+- [A quick reminder of what "shared security" means and why it's so important](https://old.reddit.com/r/ethereum/comments/sgd3zt/a_quick_reminder_of_what_shared_security_means/)
- [Sidechains vs Plasma vs Sharding](https://vitalik.ca/general/2019/06/12/plasma_vs_sharding.html)
_Know of a community resource that helped you? Edit this page and add it!_
From a2044a9637aff0ae36ea2ff3d5513ea13b63febe Mon Sep 17 00:00:00 2001
From: Emmanuel Awosika <102589267+emmanuel-awosika@users.noreply.github.com>
Date: Tue, 17 May 2022 13:50:18 +0100
Subject: [PATCH 027/298] Update index.md
Edits to incorporate feedback.
---
src/content/developers/docs/scaling/plasma/index.md | 8 +++-----
1 file changed, 3 insertions(+), 5 deletions(-)
diff --git a/src/content/developers/docs/scaling/plasma/index.md b/src/content/developers/docs/scaling/plasma/index.md
index d04abe56db6..8cce5db8f1e 100644
--- a/src/content/developers/docs/scaling/plasma/index.md
+++ b/src/content/developers/docs/scaling/plasma/index.md
@@ -36,15 +36,13 @@ Since sidechains use a separate consensus mechanism, and because these chains ar
Conversely, plasma chains derive their security from Mainnet are somewhat safer than sidechains. Both sidechains and plasma chains can have different consensus protocols, but the difference is that plasma chains publishes Merkle roots for each block on Ethereum Mainnet. Block roots are small pieces of information we can use to verify information about transactions that happen on a plasma chain. If an attack happens on a plasma chain, users can safely exit to Mainnet and withdraw their funds using the appropriate proofs.
-
### Plasma vs sharding
-Both Plasma chains and [shard chains](https://ethereum.org/en/upgrades/shard-chains/) periodically publish cryptographic proofs on the main chain. However, both have different security properties.
-Shard chains are tightly coupled to the main chain, but plasma chains are not. Even if one shard block is invalid, the entire chain will reorganize and discard the invalid block. Thus, shard chains can be as safe as the main chain.
+Both plasma chains and [shard chains](/upgrades/shard-chains/) periodically publish cryptographic proofs on the main chain. However, both have different security properties.
-While Plasma chains can benefit from Layer 1 security, they are not as tightly linked to the main chain as shard chains. It's possible to commit an invalid Plasma block header to the main chain since the larger network has little information about the state of the Plasma chain.
+Shard chains commit "collation headers" to Mainnet, which contain detailed information about each data shard. As such, nodes on the main chain verify and enforce the validity of data shards. This reduces the possibility of invalid shard transitions and protects the network against malicious activity.
-With sharding, the main chain knows how sharded sub-chains should operate and can reject an invalid shard transition. The upside to Plasma is the effects of a malicious activity can be restricted to the child chain, while the effect on malicious activity on shard chains would affect the entire network.
+Plasma is different because Mainnet only receives minimal information about the state of child chains. This means Mainnet cannot effectively verify transactions conducted on child chains, making the latter less secure.
### Use Plasma {#use-plasma}
From 06345a6d122e3c88d473df1ef1b49b8dd9a9b728 Mon Sep 17 00:00:00 2001
From: Emmanuel Awosika <102589267+emmanuel-awosika@users.noreply.github.com>
Date: Wed, 18 May 2022 14:58:10 +0100
Subject: [PATCH 028/298] Update index.md
Slight edits to incorporate feedback.
---
src/content/developers/docs/scaling/plasma/index.md | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/src/content/developers/docs/scaling/plasma/index.md b/src/content/developers/docs/scaling/plasma/index.md
index 8cce5db8f1e..745a8fef9a3 100644
--- a/src/content/developers/docs/scaling/plasma/index.md
+++ b/src/content/developers/docs/scaling/plasma/index.md
@@ -23,11 +23,11 @@ You should have a good understanding of all the foundational topics and a high-l
| | Withdrawals are delayed by several days to allow for challenges. For fungible assets this can be mitigated by liquidity providers, but there is an associated capital cost. |
| | If too many users try to exit their Plasma chain simultaneously (due to malicious activity or network failure), they could flood the root chain and congest the network. |
-## How does Plasma differ from sidechains and sharding?
+## How does Plasma differ from sidechains and sharding?
-Plasma, sidechains, and sharding all follow a similar pattern where a collection of "child chains" rely on a "main chain" for consensus. At intervals, cryptographic proofs of transaction validity (hashes) are submitted to the main chain to prevent fraudulent activity on child chains.
+Plasma, sidechains, and sharding are fairly similar because they all connect to Ethereum Mainnet in some way. However, the level and strength of these connections vary, which affects the security properties of each scaling solution.
-However, the three scaling solutions have slight differences. Here is a quick comparison of plasma chains, sidechains, and shard chains:
+Here's a quick comparison of plasma chains, sidechains, and shard chains:
### Plasma vs sidechains
From 658c3cfc5d79ced1c74709e585308102b3b13f51 Mon Sep 17 00:00:00 2001
From: Joseph Cook <33655003+jmcook1186@users.noreply.github.com>
Date: Thu, 19 May 2022 13:01:27 +0100
Subject: [PATCH 029/298] create index-temp.md
Adds MVP page (`index-temp.md`) as draft for `index.md`
---
.../get-involved/open-research/index-temp.md | 178 ++++++++++++++++++
1 file changed, 178 insertions(+)
create mode 100644 src/content/community/get-involved/open-research/index-temp.md
diff --git a/src/content/community/get-involved/open-research/index-temp.md b/src/content/community/get-involved/open-research/index-temp.md
new file mode 100644
index 00000000000..9d6338ad659
--- /dev/null
+++ b/src/content/community/get-involved/open-research/index-temp.md
@@ -0,0 +1,178 @@
+---
+title: Active areas of Ethereum research
+description: Explore different areas of open research and learn how to get involved.
+sidebar: true
+lang: en
+---
+
+# Ethereum open areas of research
+
+One of the primary strengths of Ethereum is that it is constantly being improved by an active research and engineering community. There are many enthusiastic, skilled people worldwide that would like to apply themselves to outstanding issues in Ethereum, but it is not always easy to find out what those issues are. This page aims to outline some of the key areas of active research as a rough guide to Ethereum's cutting edge.
+
+## General research resources
+
+Regardless of the specific topic, there is a wealth of information on Ethereum research to be found at [ethresear.ch](https://ethresear.ch) and the [Eth R&D discord channel](https://discord.gg/n7JxAeRu). These are the primary places where Ethereum researchers discuss the latest ideas and development opportunities.
+
+
+## Scaling and Performance
+
+### Layer 2
+
+There are now several Layer 2 protocols that scale Ethereum using different techniques for batching transactions and securing them on Ethereum layer 1. This is a very rapidly growing topic with a lot of research and development potential.
+
+### Bridges
+
+One particular area of Layer-2 that requires more research and development is safe and performant bridges. This includes bridges between various Layer-2s and bridges between Layer 1 and Layer 2.
+
+### Sharding
+
+Sharding Ethereums blockchain has long been part of the development roadmap. However, new scaling solutions such as "Danksharding" are currently taking center stage.
+
+### Hardware
+
+Running nodes on modest hardware is fundamental to keeping Ethereum decentralized. Therefore, active research into minimizing the hardware requirements to run nodes is an important area of research.
+
+### Links to current research
+
+[Ethereum on ARM](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/)
+
+[Ethresear.ch Scaling](https://ethresear.ch/c/sharding/6)
+
+[Ethresear.ch Layer 2](https://ethresear.ch/c/layer-2/32)
+
+[Ethereum Sharding Research Compendium](https://notes.ethereum.org/@serenity/H1PGqDhpm?type=view)
+
+[Danksharding (Polynya)](https://polynya.medium.com/danksharding-36dc0c8067fe)
+
+
+
+## Security
+
+Security is a broad topic that might include spam/scam prevention, wallet security, hardware security, crypto-economic security, bug hunting and testing of applications and client software and key-management. Contributing to knowledge in these areas will help stimulate mainstream adoption.
+
+### Cryptography & zkp
+
+Zero-knowledge proofs and crytopgraphy are critical for building privacy and security into Ethereum and its applications. Zero-knowledge is a relatively young but fast-moving space with many open research and development opportunities.
+
+### Wallets
+
+User-wallets can be browser extensions, desktop and mobile apps or smart contracts on Ethereum. There is active research into social recovery wallets that reduce some of the risk associated with individual-user key management.
+
+### Links to current research
+
+[Three Attacks on PoS Ethereum](https://arxiv.org/abs/2110.10086)
+
+[ethresear.ch Security](https://ethresear.ch/tag/security)
+
+[Ethresear.ch ZK](https://ethresear.ch/c/zk-s-nt-arks/13)
+
+[zkp.science](https://zkp.science/)
+
+[Zero Knowledge podcast](https://zeroknowledge.fm/)
+
+
+## Community, Education and Outreach
+
+Onboarding new users onto Ethereum requires new educational resources and approaches to outreach. This might include blog posts and articles, books, podcasts, memes, teaching resources events and anything else that builds communities, welcomes new starters and educates people about Ethereum.
+
+### UX/UI
+
+For Ethereum to onboard more people the UX/UI must be improved. This requires designers and UI and product experts to re-examine the design of wallets and apps.
+
+### Links to current research
+
+[Ethresear.ch UX/UI](https://ethresear.ch/c/ui-ux/24)
+[Ethereum.org community page](https://ethereum.org/en/learn/)
+
+
+## Economics
+
+There are complex crypto-economic factors relating to Ethereum's native asset (ether) and the tokens built on top of it (for example NFTs and ERC20 tokens).
+
+### PoS incentives
+
+When Ethereum transitions to proof of stake, its native asset (ether) will be used as collateral by validators. The cryptoeconomics of this
+
+### Liquid staking and derivatives
+
+Liquid staking allows users with less than 32 ETH to receive staking yields by swapping ether for a token representing staked ether that can be used in DeFi. However, the incentives and market dynamics associated with liquid staking as well as its effect on Ethereum's security (e.g. centralization risks, )
+
+### DeFi
+
+Decentralized finance (DeFi) is one of the primary classes of application built on top of Ethereum. DeFi aims to create composable "money legos" that allow users to store, transfer, lend, borrow and and invest crypto-assets using smart contracts. This is a fast-moving space that is constantly updating. Research into secure, efficient and accessible protocols is constantly needed.
+
+### Taxation and accounting
+
+Crypto taxation is a complicated issue that likely requires a software solution. There are some nascent crypto accounting project but this area requires much more attention.
+
+### Payment systems
+
+Using Ethereum for everyday purchases is not common right now. This is because of accessibility and cost issues. These are probably resolvable with additional R&D especially on top of Layer 2 infrastructure.
+
+
+### Links to current research
+
+[Ethresear.ch liquid staking](https://ethresear.ch/search?q=liquid%20staking)
+
+[Ethresear.ch Economics](https://ethresear.ch/c/economics/16)
+
+[Rotki crypto accounting](https://rotki.com/)
+
+
+## Clients and Protocol Development
+
+### Consensus Clients
+
+The consensus layer is concerned with the proof-of-stake mechanism securing Ethereum from the merge onwards. There is abundant ongoing research and development relating to PoS concepts and implementation, for example identifying and patching vulnerabilities, quantifying cryptoeconomic security, increasing the security or performance of client implementations, building light clients and developing staking apps.
+
+### Execution Clients
+
+The execution layer is concerned with executing transactions, running the EVM and generating execution payloads to pass to the consensus layer. There are many active areas of research, especially as execution clients are updated ready for the merge. This includes building out light client support, research into gas limits and incorporating new data structures (e.g. Verkle Tries).
+
+### Data Science and Analytics
+
+There is a need for more data analysis tools and dashboards that give detailed information about activity on Ethereum and the health of the network.
+
+### Links to current research
+
+[Ethresear.ch The Merge](https://ethresear.ch/c/the-merge/38)
+
+[Ethresear.ch Consensus](https://ethresear.ch/c/consensus/29)
+
+[Ethresear.ch Networking](https://ethresear.ch/c/networking/27)
+
+[Dune Analytics](https://dune.com/browse/dashboards)
+
+[Client diversity dashboard](https://clientdiversity.org/)
+
+
+## Apps and Tooling
+
+### DAOs
+
+DAOs are one of the key classes of application being built on top of Ethereum. There is a lot of very active research into how they may develop to replace corporations and other traditional organizations.
+
+### Developer tools
+
+Tools for Ethereum developers are rapidly improving. There is lots of active research and development to do in this general area.
+
+### App security
+
+Hacks on Ethereum nearly always exploit vulnerabilities in individual applications rather than the base protocol. Hackers and app developers are locked in an arms race to develop new attacks and defenses. This means there is always important research and development required to keep apps safe from hacks.
+
+### Technology stack
+
+Apps on Ethereum are rarely fully decentralized because they rely on some centralized tooling or infrastructure. Decentralizing the full tech stack is an important research area.
+
+### Composability
+
+Composability is the ability for different apps to work in parallel or on top of one another so that users are not locked-in to specific protocols. This is something that requires best-practises in interoperability and data standards. This is an area that would benefit from more ongoing research and development.
+
+
+### Links to current research
+
+[ethresear.ch Applications](https://ethresear.ch/c/applications/18)
+
+
+
+
From 4bcfd8fc0d81984bef2e6a584b27d6f4251d9257 Mon Sep 17 00:00:00 2001
From: Sam Richards
Date: Thu, 19 May 2022 14:13:34 +0200
Subject: [PATCH 030/298] Consolidate drafts into index.md
---
.../get-involved/open-research/index-temp.md | 178 -----------------
.../get-involved/open-research/index.md | 187 +++++++++++-------
2 files changed, 119 insertions(+), 246 deletions(-)
delete mode 100644 src/content/community/get-involved/open-research/index-temp.md
diff --git a/src/content/community/get-involved/open-research/index-temp.md b/src/content/community/get-involved/open-research/index-temp.md
deleted file mode 100644
index 9d6338ad659..00000000000
--- a/src/content/community/get-involved/open-research/index-temp.md
+++ /dev/null
@@ -1,178 +0,0 @@
----
-title: Active areas of Ethereum research
-description: Explore different areas of open research and learn how to get involved.
-sidebar: true
-lang: en
----
-
-# Ethereum open areas of research
-
-One of the primary strengths of Ethereum is that it is constantly being improved by an active research and engineering community. There are many enthusiastic, skilled people worldwide that would like to apply themselves to outstanding issues in Ethereum, but it is not always easy to find out what those issues are. This page aims to outline some of the key areas of active research as a rough guide to Ethereum's cutting edge.
-
-## General research resources
-
-Regardless of the specific topic, there is a wealth of information on Ethereum research to be found at [ethresear.ch](https://ethresear.ch) and the [Eth R&D discord channel](https://discord.gg/n7JxAeRu). These are the primary places where Ethereum researchers discuss the latest ideas and development opportunities.
-
-
-## Scaling and Performance
-
-### Layer 2
-
-There are now several Layer 2 protocols that scale Ethereum using different techniques for batching transactions and securing them on Ethereum layer 1. This is a very rapidly growing topic with a lot of research and development potential.
-
-### Bridges
-
-One particular area of Layer-2 that requires more research and development is safe and performant bridges. This includes bridges between various Layer-2s and bridges between Layer 1 and Layer 2.
-
-### Sharding
-
-Sharding Ethereums blockchain has long been part of the development roadmap. However, new scaling solutions such as "Danksharding" are currently taking center stage.
-
-### Hardware
-
-Running nodes on modest hardware is fundamental to keeping Ethereum decentralized. Therefore, active research into minimizing the hardware requirements to run nodes is an important area of research.
-
-### Links to current research
-
-[Ethereum on ARM](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/)
-
-[Ethresear.ch Scaling](https://ethresear.ch/c/sharding/6)
-
-[Ethresear.ch Layer 2](https://ethresear.ch/c/layer-2/32)
-
-[Ethereum Sharding Research Compendium](https://notes.ethereum.org/@serenity/H1PGqDhpm?type=view)
-
-[Danksharding (Polynya)](https://polynya.medium.com/danksharding-36dc0c8067fe)
-
-
-
-## Security
-
-Security is a broad topic that might include spam/scam prevention, wallet security, hardware security, crypto-economic security, bug hunting and testing of applications and client software and key-management. Contributing to knowledge in these areas will help stimulate mainstream adoption.
-
-### Cryptography & zkp
-
-Zero-knowledge proofs and crytopgraphy are critical for building privacy and security into Ethereum and its applications. Zero-knowledge is a relatively young but fast-moving space with many open research and development opportunities.
-
-### Wallets
-
-User-wallets can be browser extensions, desktop and mobile apps or smart contracts on Ethereum. There is active research into social recovery wallets that reduce some of the risk associated with individual-user key management.
-
-### Links to current research
-
-[Three Attacks on PoS Ethereum](https://arxiv.org/abs/2110.10086)
-
-[ethresear.ch Security](https://ethresear.ch/tag/security)
-
-[Ethresear.ch ZK](https://ethresear.ch/c/zk-s-nt-arks/13)
-
-[zkp.science](https://zkp.science/)
-
-[Zero Knowledge podcast](https://zeroknowledge.fm/)
-
-
-## Community, Education and Outreach
-
-Onboarding new users onto Ethereum requires new educational resources and approaches to outreach. This might include blog posts and articles, books, podcasts, memes, teaching resources events and anything else that builds communities, welcomes new starters and educates people about Ethereum.
-
-### UX/UI
-
-For Ethereum to onboard more people the UX/UI must be improved. This requires designers and UI and product experts to re-examine the design of wallets and apps.
-
-### Links to current research
-
-[Ethresear.ch UX/UI](https://ethresear.ch/c/ui-ux/24)
-[Ethereum.org community page](https://ethereum.org/en/learn/)
-
-
-## Economics
-
-There are complex crypto-economic factors relating to Ethereum's native asset (ether) and the tokens built on top of it (for example NFTs and ERC20 tokens).
-
-### PoS incentives
-
-When Ethereum transitions to proof of stake, its native asset (ether) will be used as collateral by validators. The cryptoeconomics of this
-
-### Liquid staking and derivatives
-
-Liquid staking allows users with less than 32 ETH to receive staking yields by swapping ether for a token representing staked ether that can be used in DeFi. However, the incentives and market dynamics associated with liquid staking as well as its effect on Ethereum's security (e.g. centralization risks, )
-
-### DeFi
-
-Decentralized finance (DeFi) is one of the primary classes of application built on top of Ethereum. DeFi aims to create composable "money legos" that allow users to store, transfer, lend, borrow and and invest crypto-assets using smart contracts. This is a fast-moving space that is constantly updating. Research into secure, efficient and accessible protocols is constantly needed.
-
-### Taxation and accounting
-
-Crypto taxation is a complicated issue that likely requires a software solution. There are some nascent crypto accounting project but this area requires much more attention.
-
-### Payment systems
-
-Using Ethereum for everyday purchases is not common right now. This is because of accessibility and cost issues. These are probably resolvable with additional R&D especially on top of Layer 2 infrastructure.
-
-
-### Links to current research
-
-[Ethresear.ch liquid staking](https://ethresear.ch/search?q=liquid%20staking)
-
-[Ethresear.ch Economics](https://ethresear.ch/c/economics/16)
-
-[Rotki crypto accounting](https://rotki.com/)
-
-
-## Clients and Protocol Development
-
-### Consensus Clients
-
-The consensus layer is concerned with the proof-of-stake mechanism securing Ethereum from the merge onwards. There is abundant ongoing research and development relating to PoS concepts and implementation, for example identifying and patching vulnerabilities, quantifying cryptoeconomic security, increasing the security or performance of client implementations, building light clients and developing staking apps.
-
-### Execution Clients
-
-The execution layer is concerned with executing transactions, running the EVM and generating execution payloads to pass to the consensus layer. There are many active areas of research, especially as execution clients are updated ready for the merge. This includes building out light client support, research into gas limits and incorporating new data structures (e.g. Verkle Tries).
-
-### Data Science and Analytics
-
-There is a need for more data analysis tools and dashboards that give detailed information about activity on Ethereum and the health of the network.
-
-### Links to current research
-
-[Ethresear.ch The Merge](https://ethresear.ch/c/the-merge/38)
-
-[Ethresear.ch Consensus](https://ethresear.ch/c/consensus/29)
-
-[Ethresear.ch Networking](https://ethresear.ch/c/networking/27)
-
-[Dune Analytics](https://dune.com/browse/dashboards)
-
-[Client diversity dashboard](https://clientdiversity.org/)
-
-
-## Apps and Tooling
-
-### DAOs
-
-DAOs are one of the key classes of application being built on top of Ethereum. There is a lot of very active research into how they may develop to replace corporations and other traditional organizations.
-
-### Developer tools
-
-Tools for Ethereum developers are rapidly improving. There is lots of active research and development to do in this general area.
-
-### App security
-
-Hacks on Ethereum nearly always exploit vulnerabilities in individual applications rather than the base protocol. Hackers and app developers are locked in an arms race to develop new attacks and defenses. This means there is always important research and development required to keep apps safe from hacks.
-
-### Technology stack
-
-Apps on Ethereum are rarely fully decentralized because they rely on some centralized tooling or infrastructure. Decentralizing the full tech stack is an important research area.
-
-### Composability
-
-Composability is the ability for different apps to work in parallel or on top of one another so that users are not locked-in to specific protocols. This is something that requires best-practises in interoperability and data standards. This is an area that would benefit from more ongoing research and development.
-
-
-### Links to current research
-
-[ethresear.ch Applications](https://ethresear.ch/c/applications/18)
-
-
-
-
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
index af73d7c6eef..16365a4883d 100644
--- a/src/content/community/get-involved/open-research/index.md
+++ b/src/content/community/get-involved/open-research/index.md
@@ -7,108 +7,159 @@ lang: en
# Ethereum open areas of research
-Do you have a background in mathematics, cryptography, or economics? You might be interested in some of the cutting-edge work being done within the Ethereum ecosystem.
+One of the primary strengths of Ethereum is that it is constantly being improved by an active research and engineering community. There are many enthusiastic, skilled people worldwide that would like to apply themselves to outstanding issues in Ethereum, but it is not always easy to find out what those issues are. This page aims to outline some of the key areas of active research as a rough guide to Ethereum's cutting edge.
-**TODOs**
+## General research resources
-- [x] Create basic page
-- [ ] Talk to researchers - what are the open questions? What are topics & resources?
-- [ ] Decide how topics should be categorized - what's the hierarchy?
-## Page Content Structure
-- There should be as few categories as possible needed to achieve the following:
- - encompass the full gamut of research topics
- - differentiated enough from each other to minimise sub-category redundancy and duplication
- - sub-categories may qualify in multiple Parent Categories, but this should be minimised to reduce confusion
-- Ideally, less than [10 main categories, with less than 12 sub-categories within each](https://www.researchgate.net/publication/303676802_HICK%27S_LAW_IS_MIRRORED_IN_THE_BRAIN_AN_FMRI_STUDY_OF_THE_CHOICE_REACTION_TIME).
- - This is to reduce the cognitive load of parsing too many categories if they are all displayed at once
- - There should be an AJAX style search bar that allows users to search categories, with some intelligent matching of synonyms
- - The Parent Categories should be sufficiently broad, yet clearly delineated so the location of Sub-Categories are obvious to the average user familiar with the Topic.
-- Researchers should weigh in on whether the categories are redundant/incomplete/contradictory.
-- Sub-Categories as tags, not folders.
- - In some cases, sub-categories may appear across multiple main categories based on application
- - eg: Zero Knowledge Proofs can appear in Privacy, Security AND Scalability, depending on the context ZKPs are being used or applied.
- - Or should ZKPs be their own Parent Category?
- - These are the kinds of discussions/arguments we need to have around the organisational hierarchy of the information
+Regardless of the specific topic, there is a wealth of information on Ethereum research to be found at [ethresear.ch](https://ethresear.ch) and the [Eth R&D discord channel](https://discord.gg/n7JxAeRu). These are the primary places where Ethereum researchers discuss the latest ideas and development opportunities.
-## Sample: ESP’s [Parent Categories](https://esp.ethereum.foundation/_next/image?url=%2F_next%2Fstatic%2Fmedia%2Fabout.9c9105a9.png&w=828&q=75)
+## Scaling and Performance
-> ESP's categories are very clear and have good delineation, many topics would fall very clearly into one Category exclusively. One area to improve would be to make “Research” less broad, and to specify more discrete Topics which require Research.
->
-- Community & Education
-- Consensus Layer
-- Cryptography & zkp
-- Execution Layer
-- Layer 2
-- Libraries & Tooling
-- Research
+### Layer 2
-## Metadata displayed under Content/Research Topic
+There are now several Layer 2 protocols that scale Ethereum using different techniques for batching transactions and securing them on Ethereum layer 1. This is a very rapidly growing topic with a lot of research and development potential.
-- Title (Header would be the name of the area of research)
- - Outline (Brief writeup of the Scope or Research Topic within larger Area of Research) [sample](https://blog.ethereum.org/2022/02/24/japan-local-grants-round/)
- - List of Teams/Researchers/People working on Research Topic
-- Additional Information (optional/good to have)
- - Existing funding and grants
+### Bridges
-### Open Source Submission Inputs
+One particular area of Layer-2 that requires more research and development is safe and performant bridges. This includes bridges between various Layer-2s and bridges between Layer 1 and Layer 2.
-- Allow user submission of Areas of Research
-- Allow user submission of Teams/Researchers/People under Area of Research
-## Community
+### Sharding
-List general communities / resources for general topics?
+Sharding Ethereums blockchain has long been part of the development roadmap. However, new scaling solutions such as "Danksharding" are currently taking center stage.
-- [Ethresear.ch](https://ethresear.ch) - Ethereum’s primary forum for research
+### Hardware
-List different categories of research...
+Running nodes on modest hardware is fundamental to keeping Ethereum decentralized. Therefore, active research into minimizing the hardware requirements to run nodes is an important area of research.
-## Protocol
+### Links to current research
-Is this a valid category? What best captures these topics?
-e.g. various upgrades https://ethereum.org/en/upgrades/
+[Ethereum on ARM](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/)
-### Consensus
+[Ethresear.ch Scaling](https://ethresear.ch/c/sharding/6)
-Should this just be "proof-of-stake" at this point? Or other relevant areas of consensus research?
+[Ethresear.ch Layer 2](https://ethresear.ch/c/layer-2/32)
-Separate consensus layer & execution layer as top-level categories?
+[Ethereum Sharding Research Compendium](https://notes.ethereum.org/@serenity/H1PGqDhpm?type=view)
-Derp derp derp
+[Danksharding (Polynya)](https://polynya.medium.com/danksharding-36dc0c8067fe)
-### Sharding
+## Security
+
+Security is a broad topic that might include spam/scam prevention, wallet security, hardware security, crypto-economic security, bug hunting and testing of applications and client software and key-management. Contributing to knowledge in these areas will help stimulate mainstream adoption.
+
+### Cryptography & zkp
+
+Zero-knowledge proofs and crytopgraphy are critical for building privacy and security into Ethereum and its applications. Zero-knowledge is a relatively young but fast-moving space with many open research and development opportunities.
+
+### Wallets
+
+User-wallets can be browser extensions, desktop and mobile apps or smart contracts on Ethereum. There is active research into social recovery wallets that reduce some of the risk associated with individual-user key management.
+
+### Links to current research
+
+[Three Attacks on PoS Ethereum](https://arxiv.org/abs/2110.10086)
+
+[ethresear.ch Security](https://ethresear.ch/tag/security)
+
+[Ethresear.ch ZK](https://ethresear.ch/c/zk-s-nt-arks/13)
-Derp derp derp
+[zkp.science](https://zkp.science/)
+
+[Zero Knowledge podcast](https://zeroknowledge.fm/)
+
+## Community, Education and Outreach
+
+Onboarding new users onto Ethereum requires new educational resources and approaches to outreach. This might include blog posts and articles, books, podcasts, memes, teaching resources events and anything else that builds communities, welcomes new starters and educates people about Ethereum.
+
+### UX/UI
+
+For Ethereum to onboard more people the UX/UI must be improved. This requires designers and UI and product experts to re-examine the design of wallets and apps.
+
+### Links to current research
+
+[Ethresear.ch UX/UI](https://ethresear.ch/c/ui-ux/24)
+[Ethereum.org community page](https://ethereum.org/en/learn/)
## Economics
-## Cryptography
+There are complex crypto-economic factors relating to Ethereum's native asset (ether) and the tokens built on top of it (for example NFTs and ERC20 tokens).
+
+### PoS incentives
+
+When Ethereum transitions to proof of stake, its native asset (ether) will be used as collateral by validators. The cryptoeconomics of this
+
+### Liquid staking and derivatives
+
+Liquid staking allows users with less than 32 ETH to receive staking yields by swapping ether for a token representing staked ether that can be used in DeFi. However, the incentives and market dynamics associated with liquid staking as well as its effect on Ethereum's security (e.g. centralization risks, )
+
+### DeFi
+
+Decentralized finance (DeFi) is one of the primary classes of application built on top of Ethereum. DeFi aims to create composable "money legos" that allow users to store, transfer, lend, borrow and and invest crypto-assets using smart contracts. This is a fast-moving space that is constantly updating. Research into secure, efficient and accessible protocols is constantly needed.
+
+### Taxation and accounting
+
+Crypto taxation is a complicated issue that likely requires a software solution. There are some nascent crypto accounting project but this area requires much more attention.
+
+### Payment systems
+
+Using Ethereum for everyday purchases is not common right now. This is because of accessibility and cost issues. These are probably resolvable with additional R&D especially on top of Layer 2 infrastructure.
+
+### Links to current research
+
+[Ethresear.ch liquid staking](https://ethresear.ch/search?q=liquid%20staking)
+
+[Ethresear.ch Economics](https://ethresear.ch/c/economics/16)
+
+[Rotki crypto accounting](https://rotki.com/)
+
+## Clients and Protocol Development
+
+### Consensus Clients
+
+The consensus layer is concerned with the proof-of-stake mechanism securing Ethereum from the merge onwards. There is abundant ongoing research and development relating to PoS concepts and implementation, for example identifying and patching vulnerabilities, quantifying cryptoeconomic security, increasing the security or performance of client implementations, building light clients and developing staking apps.
+
+### Execution Clients
+
+The execution layer is concerned with executing transactions, running the EVM and generating execution payloads to pass to the consensus layer. There are many active areas of research, especially as execution clients are updated ready for the merge. This includes building out light client support, research into gas limits and incorporating new data structures (e.g. Verkle Tries).
+
+### Data Science and Analytics
+
+There is a need for more data analysis tools and dashboards that give detailed information about activity on Ethereum and the health of the network.
+
+### Links to current research
+
+[Ethresear.ch The Merge](https://ethresear.ch/c/the-merge/38)
+
+[Ethresear.ch Consensus](https://ethresear.ch/c/consensus/29)
+
+[Ethresear.ch Networking](https://ethresear.ch/c/networking/27)
-e.g. topics on https://crypto.ethereum.org/research
+[Dune Analytics](https://dune.com/browse/dashboards)
-### Hash Functions
+[Client diversity dashboard](https://clientdiversity.org/)
-Derp derp derp
+## Apps and Tooling
-### Polynomial and vector commitments
+### DAOs
-Derp derp derp
+DAOs are one of the key classes of application being built on top of Ethereum. There is a lot of very active research into how they may develop to replace corporations and other traditional organizations.
-### Verifiable delay functions and random beacons
+### Developer tools
-Derp derp derp
+Tools for Ethereum developers are rapidly improving. There is lots of active research and development to do in this general area.
-### Zero-Knowledge Proofs
+### App security
-Derp derp derp
+Hacks on Ethereum nearly always exploit vulnerabilities in individual applications rather than the base protocol. Hackers and app developers are locked in an arms race to develop new attacks and defenses. This means there is always important research and development required to keep apps safe from hacks.
-## Layer 2
+### Technology stack
-## Privacy
+Apps on Ethereum are rarely fully decentralized because they rely on some centralized tooling or infrastructure. Decentralizing the full tech stack is an important research area.
-## Data Science
+### Composability
-Include miscellaneous places to find areas of opportunity/investment?
+Composability is the ability for different apps to work in parallel or on top of one another so that users are not locked-in to specific protocols. This is something that requires best-practises in interoperability and data standards. This is an area that would benefit from more ongoing research and development.
-- [Challenges.ethereum.org](https://challenges.ethereum.org/) - a series of high-value research bounties, where you can earn >$100,000 USD
+### Links to current research
-- [Ecosystem Support Program's wishlist](https://esp.ethereum.foundation/wishlist/) - research areas where the Ethereum Ecosystem Support Program is actively seeking grant applications
+[ethresear.ch Applications](https://ethresear.ch/c/applications/18)
From a2239ad011b406dcec2ef05170e401dc7d120ece Mon Sep 17 00:00:00 2001
From: Sam Richards
Date: Thu, 19 May 2022 17:51:29 +0200
Subject: [PATCH 031/298] Typo fixes
---
.../community/get-involved/open-research/index.md | 10 +++++-----
1 file changed, 5 insertions(+), 5 deletions(-)
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
index 16365a4883d..a4560b846ae 100644
--- a/src/content/community/get-involved/open-research/index.md
+++ b/src/content/community/get-involved/open-research/index.md
@@ -11,7 +11,7 @@ One of the primary strengths of Ethereum is that it is constantly being improved
## General research resources
-Regardless of the specific topic, there is a wealth of information on Ethereum research to be found at [ethresear.ch](https://ethresear.ch) and the [Eth R&D discord channel](https://discord.gg/n7JxAeRu). These are the primary places where Ethereum researchers discuss the latest ideas and development opportunities.
+Regardless of the specific topic, there is a wealth of information on Ethereum research to be found at [ethresear.ch](https://ethresear.ch) and the [Eth R&D Discord channel](https://discord.gg/n7JxAeRu). These are the primary places where Ethereum researchers discuss the latest ideas and development opportunities.
## Scaling and Performance
@@ -25,7 +25,7 @@ One particular area of Layer-2 that requires more research and development is sa
### Sharding
-Sharding Ethereums blockchain has long been part of the development roadmap. However, new scaling solutions such as "Danksharding" are currently taking center stage.
+Sharding Ethereum's blockchain has long been part of the development roadmap. However, new scaling solutions such as "Danksharding" are currently taking center stage.
### Hardware
@@ -47,9 +47,9 @@ Running nodes on modest hardware is fundamental to keeping Ethereum decentralize
Security is a broad topic that might include spam/scam prevention, wallet security, hardware security, crypto-economic security, bug hunting and testing of applications and client software and key-management. Contributing to knowledge in these areas will help stimulate mainstream adoption.
-### Cryptography & zkp
+### Cryptography & ZKP
-Zero-knowledge proofs and crytopgraphy are critical for building privacy and security into Ethereum and its applications. Zero-knowledge is a relatively young but fast-moving space with many open research and development opportunities.
+Zero-knowledge proofs (ZKP) and cryptography are critical for building privacy and security into Ethereum and its applications. Zero-knowledge is a relatively young but fast-moving space with many open research and development opportunities.
### Wallets
@@ -158,7 +158,7 @@ Apps on Ethereum are rarely fully decentralized because they rely on some centra
### Composability
-Composability is the ability for different apps to work in parallel or on top of one another so that users are not locked-in to specific protocols. This is something that requires best-practises in interoperability and data standards. This is an area that would benefit from more ongoing research and development.
+Composability is the ability for different apps to work in parallel or on top of one another so that users are not locked-in to specific protocols. This is something that requires best-practices in interoperability and data standards. This is an area that would benefit from more ongoing research and development.
### Links to current research
From 57024124191c0ed3125b1ee8b7daa976c6eed46d Mon Sep 17 00:00:00 2001
From: Joseph Cook <33655003+jmcook1186@users.noreply.github.com>
Date: Fri, 20 May 2022 11:36:47 +0100
Subject: [PATCH 032/298] apply changes from @samajammin review
---
.../get-involved/open-research/index.md | 16 +++++++++++-----
1 file changed, 11 insertions(+), 5 deletions(-)
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
index a4560b846ae..198ed957e55 100644
--- a/src/content/community/get-involved/open-research/index.md
+++ b/src/content/community/get-involved/open-research/index.md
@@ -15,21 +15,23 @@ Regardless of the specific topic, there is a wealth of information on Ethereum r
## Scaling and Performance
+There are ongoing efforts to scale Ethereum using a variety of techniques including sharding the blockchain, danksharding and using rollups. Introductory information on scaling Ethereum is available on our [scaling page](https://ethereum.org/en/developers/docs/scaling).
+
### Layer 2
There are now several Layer 2 protocols that scale Ethereum using different techniques for batching transactions and securing them on Ethereum layer 1. This is a very rapidly growing topic with a lot of research and development potential.
### Bridges
-One particular area of Layer-2 that requires more research and development is safe and performant bridges. This includes bridges between various Layer-2s and bridges between Layer 1 and Layer 2.
+One particular area of Layer-2 that requires more research and development is safe and performant bridges. This includes bridges between various Layer-2s and bridges between Layer 1 and Layer 2. Introductory information on bridges is available at our [bridges page](https://ethereum.org/en/developers/docs/bridges).
### Sharding
-Sharding Ethereum's blockchain has long been part of the development roadmap. However, new scaling solutions such as "Danksharding" are currently taking center stage.
+Sharding Ethereum's blockchain has long been part of the development roadmap. However, new scaling solutions such as "Danksharding" are currently taking center stage. Introductory information on sharding the Ethereum blockchain can be found on our [sharding page](https://ethereum.org/en/develoeprs/docs/shard-chains).
### Hardware
-Running nodes on modest hardware is fundamental to keeping Ethereum decentralized. Therefore, active research into minimizing the hardware requirements to run nodes is an important area of research.
+Running nodes (see our [nodes page](https://ethereum.org/en/developers/docs/nodes-and-clients/run-a-node)) on modest hardware is fundamental to keeping Ethereum decentralized. Therefore, active research into minimizing the hardware requirements to run nodes is an important area of research.
### Links to current research
@@ -51,6 +53,9 @@ Security is a broad topic that might include spam/scam prevention, wallet securi
Zero-knowledge proofs (ZKP) and cryptography are critical for building privacy and security into Ethereum and its applications. Zero-knowledge is a relatively young but fast-moving space with many open research and development opportunities.
+#### Links
+[0xparc blog](https://0xparc.org/blog)
+
### Wallets
User-wallets can be browser extensions, desktop and mobile apps or smart contracts on Ethereum. There is active research into social recovery wallets that reduce some of the risk associated with individual-user key management.
@@ -84,6 +89,9 @@ For Ethereum to onboard more people the UX/UI must be improved. This requires de
There are complex crypto-economic factors relating to Ethereum's native asset (ether) and the tokens built on top of it (for example NFTs and ERC20 tokens).
+#### Links
+[Robust Incentives Group](https://ethereum.github.io/rig/)
+
### PoS incentives
When Ethereum transitions to proof of stake, its native asset (ether) will be used as collateral by validators. The cryptoeconomics of this
@@ -110,8 +118,6 @@ Using Ethereum for everyday purchases is not common right now. This is because o
[Ethresear.ch Economics](https://ethresear.ch/c/economics/16)
-[Rotki crypto accounting](https://rotki.com/)
-
## Clients and Protocol Development
### Consensus Clients
From 1c3c72441b6fb1835fd9c861c45bc8db00d31118 Mon Sep 17 00:00:00 2001
From: Joseph Cook <33655003+jmcook1186@users.noreply.github.com>
Date: Fri, 20 May 2022 12:27:40 +0100
Subject: [PATCH 033/298] reorganize links
links for every subheading
---
.../get-involved/open-research/index.md | 111 ++++++++++++++----
1 file changed, 90 insertions(+), 21 deletions(-)
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
index 198ed957e55..5d906937904 100644
--- a/src/content/community/get-involved/open-research/index.md
+++ b/src/content/community/get-involved/open-research/index.md
@@ -21,19 +21,43 @@ There are ongoing efforts to scale Ethereum using a variety of techniques includ
There are now several Layer 2 protocols that scale Ethereum using different techniques for batching transactions and securing them on Ethereum layer 1. This is a very rapidly growing topic with a lot of research and development potential.
+#### Links
+
+[Our Layer-2 page](https://ethereum.org/en/layer-2/)
+
+[EthHub Layer-2](https://docs.ethhub.io/ethereum-roadmap/layer-2-scaling/zk-rollups/)
+
+[ethresear.ch Layer 2](https://ethresear.ch/c/layer-2/32)
+
+
### Bridges
-One particular area of Layer-2 that requires more research and development is safe and performant bridges. This includes bridges between various Layer-2s and bridges between Layer 1 and Layer 2. Introductory information on bridges is available at our [bridges page](https://ethereum.org/en/developers/docs/bridges).
+One particular area of Layer-2 that requires more research and development is safe and performant bridges. This includes bridges between various Layer-2s and bridges between Layer 1 and Layer 2. This is a particularly important area of researchg because bridges are commonly targeted by hackers.
+
+#### Links
+
+[Our Bridges page](https://ethereum.org/en/developers/docs/bridges)
+
+[Vitalik on bridges](https://old.reddit.com/r/ethereum/comments/rwojtk/ama_we_are_the_efs_research_team_pt_7_07_january/hrngyk8/)
+
### Sharding
-Sharding Ethereum's blockchain has long been part of the development roadmap. However, new scaling solutions such as "Danksharding" are currently taking center stage. Introductory information on sharding the Ethereum blockchain can be found on our [sharding page](https://ethereum.org/en/develoeprs/docs/shard-chains).
+Sharding Ethereum's blockchain has long been part of the development roadmap. However, new scaling solutions such as "Danksharding" are currently taking center stage.
+
+#### Links
+
+[Our Sharding page](https://ethereum.org/en/develoeprs/docs/shard-chains)
+
+[Proto-Danksharding notes](https://notes.ethereum.org/@vbuterin/proto_danksharding_faq)
+
+[Bankless Danksharding video](https://www.youtube.com/watch?v=N5p0TB77flM)
### Hardware
Running nodes (see our [nodes page](https://ethereum.org/en/developers/docs/nodes-and-clients/run-a-node)) on modest hardware is fundamental to keeping Ethereum decentralized. Therefore, active research into minimizing the hardware requirements to run nodes is an important area of research.
-### Links to current research
+#### Links
[Ethereum on ARM](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/)
@@ -54,23 +78,27 @@ Security is a broad topic that might include spam/scam prevention, wallet securi
Zero-knowledge proofs (ZKP) and cryptography are critical for building privacy and security into Ethereum and its applications. Zero-knowledge is a relatively young but fast-moving space with many open research and development opportunities.
#### Links
+
[0xparc blog](https://0xparc.org/blog)
+[Ethresear.ch ZK](https://ethresear.ch/c/zk-s-nt-arks/13)
+
+[zkp.science](https://zkp.science/)
+
+[Zero Knowledge podcast](https://zeroknowledge.fm/)
+
+
### Wallets
User-wallets can be browser extensions, desktop and mobile apps or smart contracts on Ethereum. There is active research into social recovery wallets that reduce some of the risk associated with individual-user key management.
-### Links to current research
+#### Links
-[Three Attacks on PoS Ethereum](https://arxiv.org/abs/2110.10086)
+[Our Security page](https://ethereum.org/en/security/)
[ethresear.ch Security](https://ethresear.ch/tag/security)
-[Ethresear.ch ZK](https://ethresear.ch/c/zk-s-nt-arks/13)
-[zkp.science](https://zkp.science/)
-
-[Zero Knowledge podcast](https://zeroknowledge.fm/)
## Community, Education and Outreach
@@ -80,7 +108,7 @@ Onboarding new users onto Ethereum requires new educational resources and approa
For Ethereum to onboard more people the UX/UI must be improved. This requires designers and UI and product experts to re-examine the design of wallets and apps.
-### Links to current research
+#### Links
[Ethresear.ch UX/UI](https://ethresear.ch/c/ui-ux/24)
[Ethereum.org community page](https://ethereum.org/en/learn/)
@@ -90,33 +118,46 @@ For Ethereum to onboard more people the UX/UI must be improved. This requires de
There are complex crypto-economic factors relating to Ethereum's native asset (ether) and the tokens built on top of it (for example NFTs and ERC20 tokens).
#### Links
+
[Robust Incentives Group](https://ethereum.github.io/rig/)
### PoS incentives
When Ethereum transitions to proof of stake, its native asset (ether) will be used as collateral by validators. The cryptoeconomics of this
+#### Links
+
+
### Liquid staking and derivatives
Liquid staking allows users with less than 32 ETH to receive staking yields by swapping ether for a token representing staked ether that can be used in DeFi. However, the incentives and market dynamics associated with liquid staking as well as its effect on Ethereum's security (e.g. centralization risks, )
+#### Links
+
+[Ethresear.ch liquid staking](https://ethresear.ch/search?q=liquid%20staking)
+
### DeFi
Decentralized finance (DeFi) is one of the primary classes of application built on top of Ethereum. DeFi aims to create composable "money legos" that allow users to store, transfer, lend, borrow and and invest crypto-assets using smart contracts. This is a fast-moving space that is constantly updating. Research into secure, efficient and accessible protocols is constantly needed.
+#### Links
+
+
### Taxation and accounting
Crypto taxation is a complicated issue that likely requires a software solution. There are some nascent crypto accounting project but this area requires much more attention.
+
+#### Links
+
+
### Payment systems
Using Ethereum for everyday purchases is not common right now. This is because of accessibility and cost issues. These are probably resolvable with additional R&D especially on top of Layer 2 infrastructure.
-### Links to current research
-[Ethresear.ch liquid staking](https://ethresear.ch/search?q=liquid%20staking)
+#### Links
-[Ethresear.ch Economics](https://ethresear.ch/c/economics/16)
## Clients and Protocol Development
@@ -124,21 +165,39 @@ Using Ethereum for everyday purchases is not common right now. This is because o
The consensus layer is concerned with the proof-of-stake mechanism securing Ethereum from the merge onwards. There is abundant ongoing research and development relating to PoS concepts and implementation, for example identifying and patching vulnerabilities, quantifying cryptoeconomic security, increasing the security or performance of client implementations, building light clients and developing staking apps.
+#### Links
+
+[Prysm client](https://docs.prylabs.network/docs/how-prysm-works/beacon-node/)
+
+[Lighthouse client](https://lighthouse-book.sigmaprime.io/)
+
+[Lodestar client](https://lodestar.chainsafe.io/)
+
+[Teku client](https://consensys.net/knowledge-base/ethereum-2/teku/)
+
+[Nimbus client](https://nimbus.team/)
+
+[Ethresear.ch Consensus](https://ethresear.ch/c/consensus/29)
+
+
### Execution Clients
The execution layer is concerned with executing transactions, running the EVM and generating execution payloads to pass to the consensus layer. There are many active areas of research, especially as execution clients are updated ready for the merge. This includes building out light client support, research into gas limits and incorporating new data structures (e.g. Verkle Tries).
-### Data Science and Analytics
+[Geth client](geth.ethereum.org)
-There is a need for more data analysis tools and dashboards that give detailed information about activity on Ethereum and the health of the network.
+[Nethermind client](nethermind.io)
-### Links to current research
+[Besu client](https://consensys.net/quorum/developers/)
-[Ethresear.ch The Merge](https://ethresear.ch/c/the-merge/38)
+[Erigon client](https://github.com/ledgerwatch/erigon)
-[Ethresear.ch Consensus](https://ethresear.ch/c/consensus/29)
-[Ethresear.ch Networking](https://ethresear.ch/c/networking/27)
+### Data Science and Analytics
+
+There is a need for more data analysis tools and dashboards that give detailed information about activity on Ethereum and the health of the network.
+
+### Links
[Dune Analytics](https://dune.com/browse/dashboards)
@@ -150,22 +209,32 @@ There is a need for more data analysis tools and dashboards that give detailed i
DAOs are one of the key classes of application being built on top of Ethereum. There is a lot of very active research into how they may develop to replace corporations and other traditional organizations.
+#### Links
+
### Developer tools
Tools for Ethereum developers are rapidly improving. There is lots of active research and development to do in this general area.
+#### Links
+
### App security
Hacks on Ethereum nearly always exploit vulnerabilities in individual applications rather than the base protocol. Hackers and app developers are locked in an arms race to develop new attacks and defenses. This means there is always important research and development required to keep apps safe from hacks.
+#### Links
+
+[ethresear.ch Applications](https://ethresear.ch/c/applications/18)
+
+
### Technology stack
Apps on Ethereum are rarely fully decentralized because they rely on some centralized tooling or infrastructure. Decentralizing the full tech stack is an important research area.
+#### Links
+
### Composability
Composability is the ability for different apps to work in parallel or on top of one another so that users are not locked-in to specific protocols. This is something that requires best-practices in interoperability and data standards. This is an area that would benefit from more ongoing research and development.
-### Links to current research
+#### Links
-[ethresear.ch Applications](https://ethresear.ch/c/applications/18)
From eeb88cede60aac82c97bdf4b5d1eae2fe61cb0ac Mon Sep 17 00:00:00 2001
From: Joseph Cook <33655003+jmcook1186@users.noreply.github.com>
Date: Fri, 20 May 2022 14:35:10 +0100
Subject: [PATCH 034/298] add some more links, add account abstraction info
---
.../community/get-involved/open-research/index.md | 14 ++++++++------
1 file changed, 8 insertions(+), 6 deletions(-)
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
index 5d906937904..20c02e92247 100644
--- a/src/content/community/get-involved/open-research/index.md
+++ b/src/content/community/get-involved/open-research/index.md
@@ -53,6 +53,10 @@ Sharding Ethereum's blockchain has long been part of the development roadmap. Ho
[Bankless Danksharding video](https://www.youtube.com/watch?v=N5p0TB77flM)
+[Ethereum Sharding Research Compendium](https://notes.ethereum.org/@serenity/H1PGqDhpm?type=view)
+
+[Danksharding (Polynya)](https://polynya.medium.com/danksharding-36dc0c8067fe)
+
### Hardware
Running nodes (see our [nodes page](https://ethereum.org/en/developers/docs/nodes-and-clients/run-a-node)) on modest hardware is fundamental to keeping Ethereum decentralized. Therefore, active research into minimizing the hardware requirements to run nodes is an important area of research.
@@ -63,11 +67,6 @@ Running nodes (see our [nodes page](https://ethereum.org/en/developers/docs/node
[Ethresear.ch Scaling](https://ethresear.ch/c/sharding/6)
-[Ethresear.ch Layer 2](https://ethresear.ch/c/layer-2/32)
-
-[Ethereum Sharding Research Compendium](https://notes.ethereum.org/@serenity/H1PGqDhpm?type=view)
-
-[Danksharding (Polynya)](https://polynya.medium.com/danksharding-36dc0c8067fe)
## Security
@@ -90,7 +89,7 @@ Zero-knowledge proofs (ZKP) and cryptography are critical for building privacy a
### Wallets
-User-wallets can be browser extensions, desktop and mobile apps or smart contracts on Ethereum. There is active research into social recovery wallets that reduce some of the risk associated with individual-user key management.
+User-wallets can be browser extensions, desktop and mobile apps or smart contracts on Ethereum. There is active research into social recovery wallets that reduce some of the risk associated with individual-user key management. Associated with dveelopment of wallets is research into alternative forms of account abstraction, which is an important area of nascent research.
#### Links
@@ -98,6 +97,8 @@ User-wallets can be browser extensions, desktop and mobile apps or smart contrac
[ethresear.ch Security](https://ethresear.ch/tag/security)
+[EIP 2938 Account Abstraction](https://eips.ethereum.org/EIPS/eip-2938)
+
## Community, Education and Outreach
@@ -111,6 +112,7 @@ For Ethereum to onboard more people the UX/UI must be improved. This requires de
#### Links
[Ethresear.ch UX/UI](https://ethresear.ch/c/ui-ux/24)
+
[Ethereum.org community page](https://ethereum.org/en/learn/)
## Economics
From b0ddc170fd0496b6e97f2587035b2fa204698fd9 Mon Sep 17 00:00:00 2001
From: Joseph Cook <33655003+jmcook1186@users.noreply.github.com>
Date: Fri, 20 May 2022 14:45:27 +0100
Subject: [PATCH 035/298] Apply suggestions from code review
Co-authored-by: Sam Richards
---
src/content/community/get-involved/open-research/index.md | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
index 20c02e92247..53e2570d03b 100644
--- a/src/content/community/get-involved/open-research/index.md
+++ b/src/content/community/get-involved/open-research/index.md
@@ -5,7 +5,7 @@ sidebar: true
lang: en
---
-# Ethereum open areas of research
+# Open areas of Ethereum research
One of the primary strengths of Ethereum is that it is constantly being improved by an active research and engineering community. There are many enthusiastic, skilled people worldwide that would like to apply themselves to outstanding issues in Ethereum, but it is not always easy to find out what those issues are. This page aims to outline some of the key areas of active research as a rough guide to Ethereum's cutting edge.
@@ -15,7 +15,7 @@ Regardless of the specific topic, there is a wealth of information on Ethereum r
## Scaling and Performance
-There are ongoing efforts to scale Ethereum using a variety of techniques including sharding the blockchain, danksharding and using rollups. Introductory information on scaling Ethereum is available on our [scaling page](https://ethereum.org/en/developers/docs/scaling).
+There are ongoing efforts to scale Ethereum using a variety of techniques including sharding the blockchain, danksharding and using rollups. Introductory information on scaling Ethereum is available on our [scaling page](/developers/docs/scaling).
### Layer 2
@@ -47,7 +47,7 @@ Sharding Ethereum's blockchain has long been part of the development roadmap. Ho
#### Links
-[Our Sharding page](https://ethereum.org/en/develoeprs/docs/shard-chains)
+[Our Sharding page](/upgrades/shard-chains/)
[Proto-Danksharding notes](https://notes.ethereum.org/@vbuterin/proto_danksharding_faq)
@@ -59,7 +59,7 @@ Sharding Ethereum's blockchain has long been part of the development roadmap. Ho
### Hardware
-Running nodes (see our [nodes page](https://ethereum.org/en/developers/docs/nodes-and-clients/run-a-node)) on modest hardware is fundamental to keeping Ethereum decentralized. Therefore, active research into minimizing the hardware requirements to run nodes is an important area of research.
+[Running nodes](/developers/docs/nodes-and-clients/run-a-node/) on modest hardware is fundamental to keeping Ethereum decentralized. Therefore, active research into minimizing the hardware requirements to run nodes is an important area of research.
#### Links
From f877cecfe27a8b52e9448e05848292fdbf213b75 Mon Sep 17 00:00:00 2001
From: Joseph Cook <33655003+jmcook1186@users.noreply.github.com>
Date: Fri, 20 May 2022 14:48:08 +0100
Subject: [PATCH 036/298] add fee markets and eip4337
---
src/content/community/get-involved/open-research/index.md | 7 +++++--
1 file changed, 5 insertions(+), 2 deletions(-)
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
index 53e2570d03b..a227c8a55c2 100644
--- a/src/content/community/get-involved/open-research/index.md
+++ b/src/content/community/get-involved/open-research/index.md
@@ -65,8 +65,6 @@ Sharding Ethereum's blockchain has long been part of the development roadmap. Ho
[Ethereum on ARM](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/)
-[Ethresear.ch Scaling](https://ethresear.ch/c/sharding/6)
-
## Security
@@ -99,6 +97,8 @@ User-wallets can be browser extensions, desktop and mobile apps or smart contrac
[EIP 2938 Account Abstraction](https://eips.ethereum.org/EIPS/eip-2938)
+[EIP 4337 Account Abstraction](https://eips.ethereum.org/EIPS/eip-4337)
+
## Community, Education and Outreach
@@ -144,6 +144,9 @@ Decentralized finance (DeFi) is one of the primary classes of application built
#### Links
+### Fee markets
+
+#### Links
### Taxation and accounting
From 89ce7edcc24e11e98284601550eb16351a5b1512 Mon Sep 17 00:00:00 2001
From: Joseph Cook <33655003+jmcook1186@users.noreply.github.com>
Date: Mon, 23 May 2022 10:11:06 +0100
Subject: [PATCH 037/298] >=1 link per category
---
.../get-involved/open-research/index.md | 28 +++++++++++++++----
1 file changed, 22 insertions(+), 6 deletions(-)
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
index a227c8a55c2..4da49245966 100644
--- a/src/content/community/get-involved/open-research/index.md
+++ b/src/content/community/get-involved/open-research/index.md
@@ -129,6 +129,7 @@ When Ethereum transitions to proof of stake, its native asset (ether) will be us
#### Links
+[Robist Incentives Group: PoS incentives](https://ethereum.github.io/beaconrunner/)
### Liquid staking and derivatives
@@ -144,10 +145,19 @@ Decentralized finance (DeFi) is one of the primary classes of application built
#### Links
+[DeFi](https://ethereum.org/en/defi/)
+
+[Coinbase: What is DeFi?](https://www.coinbase.com/learn/crypto-basics/what-is-defi)
+
### Fee markets
+Ethereum transaction fees protect the network from spam, denial-of-service attacks and bad smart-contract code. However, it also affects the end-user by influencing the cost of interacting with Ethereum. Balancing network security with end-user user-experience is an ongoing challenge that requires further research and development.
+
#### Links
+[EIP 1559 (Robust Incentives Group)](https://ethereum.github.io/abm1559/notebooks/eip1559.html)
+
+
### Taxation and accounting
Crypto taxation is a complicated issue that likely requires a software solution. There are some nascent crypto accounting project but this area requires much more attention.
@@ -155,13 +165,8 @@ Crypto taxation is a complicated issue that likely requires a software solution.
#### Links
+[Example of taxation and accounting research: Cumming et al. 2019](https://www.mdpi.com/1911-8074/12/3/126)
-### Payment systems
-
-Using Ethereum for everyday purchases is not common right now. This is because of accessibility and cost issues. These are probably resolvable with additional R&D especially on top of Layer 2 infrastructure.
-
-
-#### Links
## Clients and Protocol Development
@@ -216,12 +221,20 @@ DAOs are one of the key classes of application being built on top of Ethereum. T
#### Links
+[Dao Collective](https://daocollective.xyz/)
+
+
### Developer tools
Tools for Ethereum developers are rapidly improving. There is lots of active research and development to do in this general area.
#### Links
+[Developer Frameworks](https://ethereum.org/en/developers/docs/frameworks/)
+
+[Consensus developer tools list](https://github.com/ConsenSys/ethereum-developer-tools-list)
+
+
### App security
Hacks on Ethereum nearly always exploit vulnerabilities in individual applications rather than the base protocol. Hackers and app developers are locked in an arms race to develop new attacks and defenses. This means there is always important research and development required to keep apps safe from hacks.
@@ -237,9 +250,12 @@ Apps on Ethereum are rarely fully decentralized because they rely on some centra
#### Links
+[Coinbase: Intro to Web3 Stack](https://blog.coinbase.com/a-simple-guide-to-the-web3-stack-785240e557f0)
+
### Composability
Composability is the ability for different apps to work in parallel or on top of one another so that users are not locked-in to specific protocols. This is something that requires best-practices in interoperability and data standards. This is an area that would benefit from more ongoing research and development.
#### Links
+[Smart contract composability](https://ethereum.org/en/developers/docs/smart-contracts/composability/)
From f3e759152609a6a58d2433f2484357beacefbf53 Mon Sep 17 00:00:00 2001
From: Emmanuel Awosika <102589267+emmanuel-awosika@users.noreply.github.com>
Date: Mon, 23 May 2022 16:07:31 +0100
Subject: [PATCH 038/298] Apply suggestions from code review
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.../developers/docs/scaling/plasma/index.md | 20 +++++++++----------
1 file changed, 9 insertions(+), 11 deletions(-)
diff --git a/src/content/developers/docs/scaling/plasma/index.md b/src/content/developers/docs/scaling/plasma/index.md
index 745a8fef9a3..21a918b4815 100644
--- a/src/content/developers/docs/scaling/plasma/index.md
+++ b/src/content/developers/docs/scaling/plasma/index.md
@@ -21,28 +21,26 @@ You should have a good understanding of all the foundational topics and a high-l
| Good for transactions between arbitrary users (no overhead per user pair if both are established on the plasma chain) | Need to periodically watch the network (liveness requirement) or delegate this responsibility to someone else to ensure the security of your funds. |
| Plasma chains can be adapted to specific use-cases that are unrelated to the main chain. Anyone, including businesses, can customize Plasma smart contracts to provide scalable infrastructure that works in different contexts. | Relies on one or more operators to store data and serve it upon request. |
| | Withdrawals are delayed by several days to allow for challenges. For fungible assets this can be mitigated by liquidity providers, but there is an associated capital cost. |
-| | If too many users try to exit their Plasma chain simultaneously (due to malicious activity or network failure), they could flood the root chain and congest the network. |
+| | If too many users try to exit simultaneously, Ethereum Mainnet could get congested. |
-## How does Plasma differ from sidechains and sharding?
+## How does Plasma differ from sidechains and sharding? {#plasma-sidechains-sharding}
Plasma, sidechains, and sharding are fairly similar because they all connect to Ethereum Mainnet in some way. However, the level and strength of these connections vary, which affects the security properties of each scaling solution.
-Here's a quick comparison of plasma chains, sidechains, and shard chains:
+### Plasma vs sidechains {#plasma-vs-sidechains}
-### Plasma vs sidechains
-
-A [sidechain](/developers/docs/scaling/sidechains/) is an independently operated blockchain connected to the Ethereum Mainnet via a two-way bridge. [Bridges](/bridges/) allow users to exchange tokens between the two blockchains, so they can transact on the sidechain, reducing congestion on the base layer and improving scalability.
-Since sidechains use a separate consensus mechanism, and because these chains are typically much smaller than Ethereum Mainnet, bridging assets to these chains involves increased risk to your funds. Given the lack of security guarantees inherited from Mainnet in the sidechain model, users risk total loss of funds in the event of an attack on the sidechain.```
+A [sidechain](/developers/docs/scaling/sidechains/) is an independently operated blockchain connected to Ethereum Mainnet via a two-way bridge. [Bridges](/bridges/) allow users to exchange tokens between the two blockchains to transact on the sidechain, reducing congestion on Ethereum Mainnet and improving scalability.
+Sidechains use a separate consensus mechanism and are typically much smaller than Ethereum Mainnet. As a result, bridging assets to these chains involves increased risk; given the lack of security guarantees inherited from Ethereum Mainnet in the sidechain model, users risk the loss of funds in an attack on the sidechain.
Conversely, plasma chains derive their security from Mainnet are somewhat safer than sidechains. Both sidechains and plasma chains can have different consensus protocols, but the difference is that plasma chains publishes Merkle roots for each block on Ethereum Mainnet. Block roots are small pieces of information we can use to verify information about transactions that happen on a plasma chain. If an attack happens on a plasma chain, users can safely exit to Mainnet and withdraw their funds using the appropriate proofs.
-### Plasma vs sharding
+### Plasma vs sharding {#plasma-vs-sharding}
-Both plasma chains and [shard chains](/upgrades/shard-chains/) periodically publish cryptographic proofs on the main chain. However, both have different security properties.
+Both plasma chains and [shard chains](/upgrades/shard-chains/) periodically publish cryptographic proofs to Ethereum Mainnet. However, both have different security properties.
-Shard chains commit "collation headers" to Mainnet, which contain detailed information about each data shard. As such, nodes on the main chain verify and enforce the validity of data shards. This reduces the possibility of invalid shard transitions and protects the network against malicious activity.
+Shard chains commit "collation headers" to Mainnet containing detailed information about each data shard. Nodes on Mainnet verify and enforce the validity of data shards, reducing the possibility of invalid shard transitions and protecting the network against malicious activity.
-Plasma is different because Mainnet only receives minimal information about the state of child chains. This means Mainnet cannot effectively verify transactions conducted on child chains, making the latter less secure.
+Plasma is different because Mainnet only receives minimal information about the state of child chains. This means Mainnet cannot effectively verify transactions conducted on child chains, making them less secure.
### Use Plasma {#use-plasma}
From 2882732fbc9fd69b9a456c9ef461638fbfab71d6 Mon Sep 17 00:00:00 2001
From: Sam Richards
Date: Mon, 23 May 2022 21:03:57 +0200
Subject: [PATCH 039/298] Copy over content from GH issue (#6434)
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 211 +++++++++++++----------
1 file changed, 116 insertions(+), 95 deletions(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 2a8363c7fbe..adede508700 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -6,98 +6,119 @@ labels: "wallet :purse:,"
assignees: ""
---
-_Please note as part of [our Q2 product roadmap](https://github.com/ethereum/ethereum-org-website/issues/6161) we paused adding new wallets until we establish new, expanded criteria._
-
-Before suggesting a wallet, make sure you've read [our listing policy](https://www.ethereum.org/en/contributing/adding-products/).
-
-Only continue with the issue if your wallet meets the criteria listed there.
-
-If it does complete the following information which we need to accurately list the wallet.
-
-**Is your wallet security tested? Please explain security measures i.e. security audit, internal security team or some other method.**
-
-
-
-**When did your wallet go live to users?**
-
-
-
-**Does your wallet have an active development team?**
-
-
-
-**Is your wallet open-source?**
-
-
-
-**Is your wallet globally accessible?**
-
-
-
-**Is your wallet custodial, non-custodial, or a hardware wallet?**
-
-
-
-**Please describe the measures taken to ensure the wallet's security and provide documentation wherever possible**
-
-
-
-**Does the wallet support layer 2 networks?**
-
-
-
-**Can the wallet be used with arbitrary Ethereum RPC endpoint?**
-
-
-
-**Does the wallet have fiat on-ramps?**
-
-
-
-**Does the wallet allow users to explore dapps?**
-
-
-
-**Does the wallet have integrated defi/financial tools?**
-
-
-
-**Can a user withdraw to their card?**
-
-
-
-**Does the wallet offer limits protection?**
-
-
-
-**Does the wallet allow high-volume purchases?**
-
-
-
-**Does the wallet have an integrated token swap?**
-
-
-
-**Is the wallet a multi-signature wallet?**
-
-
-
-**Wallet title**
-
-
-
-**Wallet description**
-
-
-
-**Wallet logo**
-
-
-
-**Background colour for brand logo**
-
-
-
-**URL**
-
-
+Before suggesting a wallet, make sure you've read [our listing policy](https://www.ethereum.org/en/contributing/adding-products/). Only continue with the issue if your wallet meets the criteria listed there.
+
+If the wallet does meet our list policy, please complete the following information which we need to accurately list the wallet.
+
+### Project info
+
+- Wallet name
+ - Please provide the official name of the wallet
+- Wallet description
+ - Please provide a short 1-2 sentence description of the wallet without marketing claims. Avoid claims like “the best Ethereum wallet”. We will ask for revisions if this comes across as marketing-focused.
+- Wallet logo
+ - Please provide a hi-res SVG or transparent PNG
+- Background color for brand logo
+ - Please provide a hex code for the brand color. This will be added to the background of the wallet card.
+- URL to the project
+ - Please provide a URL (e.g. to the website of the wallet)
+- URL to the documentation
+ - Please provide a URL to the documentation
+- Is your wallet security tested? Please explain security measures i.e. security audit, internal security team, or some other method.
+ - Please explain any security measures you have taken to ensure your wallet is secure
+- When did your wallet go live to users?
+ - Please provide a date when your wallet was usable by the public. Please provide some user metrics for how many users are using this wallet.
+- Does your wallet have an active development team?
+ - Are developers actively working on the wallet? Provide proof that the wallet is actively being worked on (ex. GitHub repo link).
+- Is your wallet globally accessible?
+ - Please list any KYC requirements or geographic limitations of your wallet, if any exist.
+- Is there internationalization support for your wallet?
+ - Please list languages that the wallet actively supports
+- What is the repository for your codebase?
+ - If you’re project is open source, please provide a link to the codebase.
+- What social links are there for the project?
+ - Please provide social links for the wallet (Discord, Twitter, etc.)
+- What is your wallet's onboarding experience?
+ - Please provide an explanation of where to find the user onboarding experience (links, is it built into the app, etc.), and what the onboarding experience is.
+
+### Device
+
+- Does the wallet have a mobile app? If yes, which operating systems are supported (iOS, Android)?
+ - If the wallet has a mobile interface, please provide information and links to the app store for the operating systems supported.
+- Does the wallet have a desktop app? If yes, which operating systems are supported (Windows, Mac, Linux)?
+ - If the wallet has a desktop interface, please provide links and information for the operating systems supported.
+- Does the wallet have a browser extension? If yes, which browsers are supported (Chromium, Firefox, Safari)?
+ - If the wallet has a browser extension, please provide links and information for the browsers that are supported.
+- Is it a hardware wallet?
+ - How is it used / how does it connect (e.g. USB)? What software wallets does it integrate with (e.g. MetaMask)?
+
+### Security
+
+- Is the wallet code open-sourced?
+ - If yes, please provide a direct link to the repository.
+- What license was the wallet software released under?
+ - Please provide information on the software license used for the wallet.
+- Is your wallet custodial, or non-custodial?
+ - Do users have access to their public and/or private keys? If your company/project were to disappear, would users still be able to access their funds?
+ - Custodial - users don't own keys
+ - Non-custodial - users own keys
+- Please describe the measures taken to ensure the wallet's security and provide documentation wherever possible
+ - Please provide a link to any security audits or code reports. If you haven't been audited but think your wallet should be listed anyway, explain here.
+- Spam protection?
+ - Does the wallet employ any practices to warn users against potential spam (e.g. when interacting with suspicious accounts/contracts)?
+
+### Features
+
+- Does the wallet have hardware wallet support?
+ - Please provide information on how a user can connect a hardware wallet to this wallet.
+- Does the wallet support WalletConnect?
+ - Please provide information on if the wallet supports WalletConnect.
+- Does the wallet support importing Ethereum RPC endpoints?
+ - Please provide documentation on how a user can import an Ethereum RPC into the wallet.
+- Does the wallet support viewing and interacting with NFTs?
+ - Please provide information on the experience of NFTs in the wallet.
+- Does the wallet support connecting to Ethereum applications?
+ - Please provide documentation for how users connect to applications. List examples (ie. connect wallet to dapp, in wallet browser, etc.)
+- Does the wallet support staking directly?
+ - Please provide documentation on direct staking this wallet supports.
+- Does the wallet support swaps directly?
+ - Please provide documentation on swaps.
+- Does the wallet support multi-chain networks?
+ - Please provide documentation on multi-chain networks this wallet supports.
+- Does the wallet allow the user to customize gas fees?
+ - Please provide documentation on how users can customize gas fees for transactions.
+- Does the wallet support ENS?
+ - Please provide information on ENS support.
+- Does the wallet support importing or automatically querying and displaying ERC-20 tokens?
+ - Please provide documentation on how to import tokens into the wallet.
+- Does the wallet support EIP-1559 style transactions?
+ - Please provide information on how the type of transactions this wallet supports.
+
+### Finance
+
+- Does the wallet have fiat on-ramps through credit/debit cards or wire transfers, or Bank transfers (ACH)?
+ - Please provide documentation on how a user is able to onboard and purchase crypto in the wallet.
+ - Credit/debit cards
+ - Wire transfer
+ - Bank Transfer (ACH)
+- Does the wallet support withdrawals to fiat?
+ - Can a user cash out their crypto assets directly to a card or bank account? Please provide documentation.
+
+### Smart Contract
+
+- Is the wallet a multi-signature wallet?
+ - Please provide documentation on how users set up and use the multisig functionality for the wallet.
+- Does the wallet support social recovery?
+ - Please provide documentation on how users set up guardians and use social recovery for the wallet.
+
+### Support
+
+- Does your wallet have a dedicated support team?
+ - Where should we send users that are having issues?
+ - How fast is your support?
+- What educational resources/documentation do you provide to users?
+
+### Extra
+
+- Does the wallet have any integrated tools not mentioned above?
+ - Please provide any information about extra features this wallet has that we may have missed in the above criteria. (e.g. privacy features, transaction batching, etc).
From 8499ca549f02084b0ea208acdac5c2428ee9e044 Mon Sep 17 00:00:00 2001
From: Sam Richards
Date: Mon, 23 May 2022 21:08:49 +0200
Subject: [PATCH 040/298] Format template
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 251 +++++++++++++++--------
1 file changed, 162 insertions(+), 89 deletions(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index adede508700..9d73ccc85a4 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -12,113 +12,186 @@ If the wallet does meet our list policy, please complete the following informati
### Project info
-- Wallet name
- - Please provide the official name of the wallet
-- Wallet description
- - Please provide a short 1-2 sentence description of the wallet without marketing claims. Avoid claims like “the best Ethereum wallet”. We will ask for revisions if this comes across as marketing-focused.
-- Wallet logo
- - Please provide a hi-res SVG or transparent PNG
-- Background color for brand logo
- - Please provide a hex code for the brand color. This will be added to the background of the wallet card.
-- URL to the project
- - Please provide a URL (e.g. to the website of the wallet)
-- URL to the documentation
- - Please provide a URL to the documentation
-- Is your wallet security tested? Please explain security measures i.e. security audit, internal security team, or some other method.
- - Please explain any security measures you have taken to ensure your wallet is secure
-- When did your wallet go live to users?
- - Please provide a date when your wallet was usable by the public. Please provide some user metrics for how many users are using this wallet.
-- Does your wallet have an active development team?
- - Are developers actively working on the wallet? Provide proof that the wallet is actively being worked on (ex. GitHub repo link).
-- Is your wallet globally accessible?
- - Please list any KYC requirements or geographic limitations of your wallet, if any exist.
-- Is there internationalization support for your wallet?
- - Please list languages that the wallet actively supports
-- What is the repository for your codebase?
- - If you’re project is open source, please provide a link to the codebase.
-- What social links are there for the project?
- - Please provide social links for the wallet (Discord, Twitter, etc.)
-- What is your wallet's onboarding experience?
- - Please provide an explanation of where to find the user onboarding experience (links, is it built into the app, etc.), and what the onboarding experience is.
+**Wallet name**
+
+
+
+**Wallet description**
+
+
+
+**Wallet logo**
+
+
+
+**Background color for brand logo**
+
+
+
+**URL to the project**
+
+
+
+**URL to the documentation**
+
+
+
+**Is your wallet security tested? Please explain security measures i.e. security audit, internal security team, or some other method.**
+
+
+
+**When did your wallet go live to users?**
+
+
+
+**Does your wallet have an active development team?**
+
+
+
+**Is your wallet globally accessible?**
+
+
+
+**Is there internationalization support for your wallet?**
+
+
+
+**What is the repository for your codebase?**
+
+
+
+**What social links are there for the project?**
+
+
+
+**What is your wallet's onboarding experience?**
+
+
### Device
-- Does the wallet have a mobile app? If yes, which operating systems are supported (iOS, Android)?
- - If the wallet has a mobile interface, please provide information and links to the app store for the operating systems supported.
-- Does the wallet have a desktop app? If yes, which operating systems are supported (Windows, Mac, Linux)?
- - If the wallet has a desktop interface, please provide links and information for the operating systems supported.
-- Does the wallet have a browser extension? If yes, which browsers are supported (Chromium, Firefox, Safari)?
- - If the wallet has a browser extension, please provide links and information for the browsers that are supported.
-- Is it a hardware wallet?
- - How is it used / how does it connect (e.g. USB)? What software wallets does it integrate with (e.g. MetaMask)?
+**Does the wallet have a mobile app? If yes, which operating systems are supported (iOS, Android)?**
+
+
+
+**Does the wallet have a desktop app? If yes, which operating systems are supported (Windows, Mac, Linux)?**
+
+
+
+**Does the wallet have a browser extension? If yes, which browsers are supported (Chromium, Firefox, Safari)?**
+
+
+
+**Is it a hardware wallet?**
+
+
### Security
-- Is the wallet code open-sourced?
- - If yes, please provide a direct link to the repository.
-- What license was the wallet software released under?
- - Please provide information on the software license used for the wallet.
-- Is your wallet custodial, or non-custodial?
- - Do users have access to their public and/or private keys? If your company/project were to disappear, would users still be able to access their funds?
- - Custodial - users don't own keys
- - Non-custodial - users own keys
-- Please describe the measures taken to ensure the wallet's security and provide documentation wherever possible
- - Please provide a link to any security audits or code reports. If you haven't been audited but think your wallet should be listed anyway, explain here.
-- Spam protection?
- - Does the wallet employ any practices to warn users against potential spam (e.g. when interacting with suspicious accounts/contracts)?
+**Is the wallet code open-sourced?**
+
+
+
+**What license was the wallet software released under?**
+
+
+
+**Is your wallet custodial, or non-custodial?**
+
+
+
+**Please describe the measures taken to ensure the wallet's security and provide documentation wherever possible**
+
+
+
+**Spam protection?**
+
+
### Features
-- Does the wallet have hardware wallet support?
- - Please provide information on how a user can connect a hardware wallet to this wallet.
-- Does the wallet support WalletConnect?
- - Please provide information on if the wallet supports WalletConnect.
-- Does the wallet support importing Ethereum RPC endpoints?
- - Please provide documentation on how a user can import an Ethereum RPC into the wallet.
-- Does the wallet support viewing and interacting with NFTs?
- - Please provide information on the experience of NFTs in the wallet.
-- Does the wallet support connecting to Ethereum applications?
- - Please provide documentation for how users connect to applications. List examples (ie. connect wallet to dapp, in wallet browser, etc.)
-- Does the wallet support staking directly?
- - Please provide documentation on direct staking this wallet supports.
-- Does the wallet support swaps directly?
- - Please provide documentation on swaps.
-- Does the wallet support multi-chain networks?
- - Please provide documentation on multi-chain networks this wallet supports.
-- Does the wallet allow the user to customize gas fees?
- - Please provide documentation on how users can customize gas fees for transactions.
-- Does the wallet support ENS?
- - Please provide information on ENS support.
-- Does the wallet support importing or automatically querying and displaying ERC-20 tokens?
- - Please provide documentation on how to import tokens into the wallet.
-- Does the wallet support EIP-1559 style transactions?
- - Please provide information on how the type of transactions this wallet supports.
+**Does the wallet have hardware wallet support?**
+
+
+
+**Does the wallet support WalletConnect?**
+
+
+
+**Does the wallet support importing Ethereum RPC endpoints?**
+
+
+
+**Does the wallet support viewing and interacting with NFTs?**
+
+
+
+**Does the wallet support connecting to Ethereum applications?**
+
+
+
+**Does the wallet support staking directly?**
+
+
+
+**Does the wallet support swaps directly?**
+
+
+
+**Does the wallet support multi-chain networks?**
+
+
+
+**Does the wallet allow the user to customize gas fees?**
+
+
+
+**Does the wallet support ENS?**
+
+
+
+**Does the wallet support importing or automatically querying and displaying ERC-20 tokens?**
+
+
+
+**Does the wallet support EIP-1559 style transactions?**
+
+
### Finance
-- Does the wallet have fiat on-ramps through credit/debit cards or wire transfers, or Bank transfers (ACH)?
- - Please provide documentation on how a user is able to onboard and purchase crypto in the wallet.
- - Credit/debit cards
- - Wire transfer
- - Bank Transfer (ACH)
-- Does the wallet support withdrawals to fiat?
- - Can a user cash out their crypto assets directly to a card or bank account? Please provide documentation.
+**Does the wallet have fiat on-ramps through credit/debit cards or wire transfers, or Bank transfers (ACH)?**
+
+
+
+
+
+
+**Does the wallet support withdrawals to fiat?**
+
+
### Smart Contract
-- Is the wallet a multi-signature wallet?
- - Please provide documentation on how users set up and use the multisig functionality for the wallet.
-- Does the wallet support social recovery?
- - Please provide documentation on how users set up guardians and use social recovery for the wallet.
+**Is the wallet a multi-signature wallet?**
+
+
+
+**Does the wallet support social recovery?**
+
+
### Support
-- Does your wallet have a dedicated support team?
- - Where should we send users that are having issues?
- - How fast is your support?
-- What educational resources/documentation do you provide to users?
+**Does your wallet have a dedicated support team?**
+
+
+
+
+**What educational resources/documentation do you provide to users?**
### Extra
-- Does the wallet have any integrated tools not mentioned above?
- - Please provide any information about extra features this wallet has that we may have missed in the above criteria. (e.g. privacy features, transaction batching, etc).
+**Does the wallet have any integrated tools not mentioned above?**
+
+
From 0f3c16324089b0b60271e9095480eff413061e16 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Mon, 23 May 2022 18:57:32 -0600
Subject: [PATCH 041/298] setup l2 page for translation
---
src/components/Layer2/Layer2Onboard.js | 67 ++++---
src/intl/en/page-layer-2.json | 60 ++++++-
src/pages/layer-2.js | 236 +++++++++----------------
3 files changed, 190 insertions(+), 173 deletions(-)
diff --git a/src/components/Layer2/Layer2Onboard.js b/src/components/Layer2/Layer2Onboard.js
index e7c28b209d2..19f70fc4baa 100644
--- a/src/components/Layer2/Layer2Onboard.js
+++ b/src/components/Layer2/Layer2Onboard.js
@@ -2,10 +2,12 @@
import { GatsbyImage } from "gatsby-plugin-image"
import React, { useState } from "react"
import styled from "styled-components"
+import { useIntl } from "gatsby-plugin-intl"
// Components
import ButtonLink from "../../components/ButtonLink"
import Link from "../../components/Link"
+import Translation from "../../components/Translation"
import { StyledSelect as Select } from "../SharedStyledComponents"
// Data
@@ -13,6 +15,7 @@ import cexSupport from "../../data/layer-2/cex-layer-2-support.json"
//Utils
import { trackCustomEvent } from "../../utils/matomo"
+import { translateMessageId } from "../../utils/translations"
// Styles
const Content = styled.div`
@@ -162,26 +165,28 @@ const RightSelected = styled.div`
`
const Layer2Onboard = ({ layer2DataCombined, ethIcon }) => {
+ const intl = useIntl()
+
const [selectedExchange, setSelectedExchange] = useState(undefined)
const [selectedL2, setSelectedL2] = useState(undefined)
return (
-
How to get onto a layer 2
+
+
+
- There are two primary ways to get your assets onto a layer 2: bridge
- funds from Ethereum via a smart contract or withdraw your funds on an
- exchange directly onto the layer 2 network.
+
-
Funds in your wallet?
+
+
+
- If you've already got your ETH in your wallet, you'll need to use a
- bridge to move it from Ethereum Mainnet to a layer 2.{" "}
- More on bridges.
+
- Some centralized exchanges now offer direct withdrawals and deposits
- to layer 2s. Check which exchanges support layer 2 withdrawals and
- which layer 2s they support.
+
- You'll also need a wallet to withdraw your funds to.{" "}
- Find an Ethereum wallet.
+
- Layer 2 (L2) is a collective term to describe a specific set of
- Ethereum scaling solutions.{" "}
-
- A layer 2 is a separate blockchain that extends Ethereum and
- inherits the security guarantees of Ethereum
-
- .
- Layer 1 is the base blockchain. Ethereum and Bitcoin are both
- layer 1 blockchains because they are the{" "}
-
- underlying foundation that various layer 2 networks build on top
- of
-
- . Examples of layer 2 projects include "rollups" on Ethereum and
- the Lightning Network on top of Bitcoin. All user transaction
- activity on these layer 2 projects can ultimately settle back to
- the layer 1 blockchain.
- The Ethereum community has taken a strong stance that it would not
- throw out decentralization or security in order to scale. Until{" "}
- sharding, Ethereum
- Mainnet (layer 1) is only able to process{" "}
-
- roughly 15 transactions per second
-
- . When demand to use Ethereum is high, the network becomes
- congested, which increases transaction fees and prices out users
- who cannot afford those fees. That is where layer 2 comes in to
- scale Ethereum today.
- Now that you understand why layer 2 exists and how it works, let's get
- you up and running!
+
-
Generalized layer 2s
+
+
+
- Generalized layer 2s behave just like Ethereum — but cheaper. Anything
- that you can do on Ethereum layer 1, you can also do on layer 2. Many
- dapps have already begun to migrate to these networks or have skipped
- Mainnet altogether to deploy straight on a layer 2.
+
A note on sidechains, validiums, and alternative blockchains
+
+
+
- Sidechains and validiums are blockchains that allow assets
- from Ethereum to be bridged over and used on another blockchain.
- Sidechains and validiums run in parallel with Ethereum, and
- interact with Ethereum through bridges, but they do not derive
- their security or data availability from Ethereum.
+
- Both scale similarly to layer 2s - they offer lower transaction
- fees and higher transaction throughput - but have different trust
- assumptions.
+
- More on{" "}
- sidechains{" "}
- and validiums
+
- Some layer 1 blockchains have higher throughput and lower
- transaction fees than Ethereum. These alternative layer 1s have
- had to sacrifice on security or decentralization in order
- to achieve higher transactions per second and lower transaction
- fees.
+
- The Ethereum ecosystem is firmly aligned that{" "}
-
- layer 2 scaling is the only way to solve the scalability
- trilemma
- {" "}
- while remaining decentralized and secure.
+
- Just as there is no 'official' Ethereum client, there is no
- 'official' Ethereum layer 2. Ethereum is permissionless -
- technically anyone can create a layer 2! Multiple teams will
- implement their version of a layer 2, and the ecosystem as a whole
- will benefit from a diversity of design approaches that are
- optimized for different use cases. Much like we have multiple
- Ethereum clients developed by multiple teams in order to have
- diversity in the network, this too will be how layer 2s develop in
- the future.
+
-
+
- Both optimistic and zero-knowledge rollups bundle (or ’roll up’)
- hundreds of transactions into a single transaction on layer 1.
- Rollup transactions get executed outside of layer 1 but transaction
- data gets posted to layer 1.
+
- The primary difference is what data is posted to the layer 1 and how
- the data is verified. Validity proofs (used by zero-knowledge
- rollups) run the computations off-chain and post a proof, whereas
- fault proofs (used by optimistic rollups) only run the computations
- on-chain when fault is suspected and must be checked.
+
- At the moment, most zk-rollups are application specific, in contrast
- with optimistic rollups which have largely been generalizable.
+
- Yes. Currently in the Ethereum roadmap there are plans for shard
- chains. While these are in the roadmap, further scaling through
- layer 2 networks is still necessary.{" "}
- More info on sharding.
+
-
+
- Layer 2 projects contain additional risks compared to holding funds
- and transacting directly on Ethereum Mainnet. For instance,
- sequencers may go down, leading you to have to wait to access funds.
+
- We encourage you to do your own research before transferring
- significant funds to a layer 2. For more information on the
- technology, risks, and trust assumptions of layer 2s, we recommend
- checking out L2BEAT,
- which provides a comprehensive risk assessment framework of each
- project.
+
- Blockchain bridges, which facilitate asset transfers to layer 2, are
- in their early stages of development and it is likely that the
- optimal bridge design has not been discovered yet. There have been{" "}
-
- recent hacks of bridges
-
- . More information on bridges.
+
-
+
- We want to make sure we list the best resources possible so users
- can navigate the layer 2 space in a safe and confident manner. We
- maintain a framework of criteria for how projects are evaluated for
- inclusion.{" "}
-
- View our layer 2 listing policy here
-
- .
+
- Anyone is free to suggest adding a layer 2 on ethereum.org. If
- there's a layer 2 that we have missed,{" "}
-
- please suggest it
-
+
-
Further reading
+
+
+
From 2e6aa57f2a17064172bfaf62ff85ce556fbd196d Mon Sep 17 00:00:00 2001
From: byhow
Date: Mon, 23 May 2022 23:03:11 -0700
Subject: [PATCH 042/298] docs: update testnet header jumps
similar to 84299e7f1da7aabed07b6f3e2995b5141c8adfbe and what was being done in
issue #6384, replacing the rest of the links with similar issues
as well as references from their translations.
---
src/content/glossary/index.md | 6 ++----
src/content/translations/de/glossary/index.md | 10 +++++-----
.../docs/nodes-and-clients/nodes-as-a-service/index.md | 2 +-
src/content/translations/es/glossary/index.md | 2 +-
.../docs/nodes-and-clients/nodes-as-a-service/index.md | 2 +-
.../docs/nodes-and-clients/nodes-as-a-service/index.md | 2 +-
src/content/translations/fr/glossary/index.md | 2 +-
.../docs/nodes-and-clients/nodes-as-a-service/index.md | 2 +-
src/content/translations/hu/glossary/index.md | 2 +-
.../docs/nodes-and-clients/nodes-as-a-service/index.md | 2 +-
src/content/translations/id/glossary/index.md | 2 +-
.../docs/nodes-and-clients/nodes-as-a-service/index.md | 2 +-
src/content/translations/it/glossary/index.md | 2 +-
.../docs/nodes-and-clients/nodes-as-a-service/index.md | 2 +-
src/content/translations/pl/glossary/index.md | 2 +-
.../docs/nodes-and-clients/nodes-as-a-service/index.md | 2 +-
.../docs/nodes-and-clients/nodes-as-a-service/index.md | 2 +-
src/content/translations/ro/glossary/index.md | 2 +-
.../docs/nodes-and-clients/nodes-as-a-service/index.md | 2 +-
src/content/translations/tr/glossary/index.md | 2 +-
src/content/translations/zh/glossary/index.md | 2 +-
21 files changed, 26 insertions(+), 28 deletions(-)
diff --git a/src/content/glossary/index.md b/src/content/glossary/index.md
index d1c134d5f9e..3269ef4230f 100644
--- a/src/content/glossary/index.md
+++ b/src/content/glossary/index.md
@@ -510,7 +510,6 @@ A [wallet](#wallet) using the hierarchical deterministic (HD) key creation and t
A value used to generate the master [private key](#private-key) and master chain code for an HD [wallet](#wallet). The wallet seed can be represented by mnemonic words, making it easier for humans to copy, back up, and restore private keys.
-
### homestead {#homestead}
The second development stage of Ethereum, launched in March 2016 at block 1,150,000.
@@ -575,7 +574,6 @@ Every account’s private key/address pair exists as a single keyfile in an Ethe
Cryptographic [hash](#hash) function used in Ethereum. Keccak-256 was standardized as [SHA](#sha)-3.
-
## L {#section-l}
@@ -749,7 +747,7 @@ A secret number that allows Ethereum users to prove ownership of an account or c
### private chain {#private-chain}
-A fully private blockchain is one with permissioned access, not publicly available for use.
+A fully private blockchain is one with permissioned access, not publicly available for use.
### proof-of-stake (PoS) {#pos}
@@ -955,7 +953,7 @@ A [hard fork](#hard-fork) of the Ethereum blockchain, which occurred at block 2,
Short for "test network," a network used to simulate the behavior of the main Ethereum network (see [Mainnet](#mainnet)).
-
+
Testnets
diff --git a/src/content/translations/de/glossary/index.md b/src/content/translations/de/glossary/index.md
index fdc6038cb6a..b999891f374 100644
--- a/src/content/translations/de/glossary/index.md
+++ b/src/content/translations/de/glossary/index.md
@@ -130,11 +130,11 @@ Wenn zahlreiche Nodes (meist die Mehrzahl der Nodes im Netzwerk) alle die gleich
Konsens-Clients (wie Prysm, Teku, Nimbus, Lighthouse, Lodestar) führen Ethereums [Proof-of-Stake](#pos)-Konsensalgorithmus aus, der es dem Netzwerk ermöglicht, sich bezüglich des Kopfs der Beacon Chain zu einigen. Konsens-Clients beteiligen sich nicht an der Validierung/am Broadcasting von Transaktionen oder der Ausführung von Zustandsübergängen. Dies geschieht durch [Ausführungsclients](#execution-client).
-### Consensus Layer (Konsensschicht) {#consensus-layer}
+### Consensus Layer (Konsensschicht) {#consensus-layer}
Die Konsensschicht von Ethereum ist das Netzwerk der [Konsens-Clients](#consensus-client).
-### Consensus Rules (Konsensregeln) {#consensus-rules}
+### Consensus Rules (Konsensregeln) {#consensus-rules}
Die Block-Validierungsregeln, denen Full-Nodes folgen, um im Konsens mit anderen Nodes zu bleiben. Nicht zu verwechseln mit [Konsens](#consensus).
@@ -146,7 +146,7 @@ Der zweite Teil der [Metropolis](#metropolis)-Ausbaustufe, ursprünglich geplant
Ein Konto, das Code enthält, welcher ausgeführt wird, wenn es eine [Transaktion](#transaction) von einem anderen [Konto](#account) ([EOA](#eoa) oder [Smart Contract](#contract-account)) erhält.
-### Contract Creation Transaction (Vertragserstellungs-Transaktion) {#contract-creation-transaction}
+### Contract Creation Transaction (Vertragserstellungs-Transaktion) {#contract-creation-transaction}
Eine spezielle [Transaktion](#transaction) mit der [Null-Adresse](#zero-address) als Empfänger, die verwendet wird, um einen [Vertrag](#contract-account) zu registrieren und ihn in der Ethereum-Blockchain aufzuzeichnen.
@@ -186,7 +186,7 @@ Eine Art [dApp](#dapp), mit der du Token mit anderen im Netzwerk austauschen kan
Dezentralisierte Börsen
-### Deed (Beglaubigung) {#deed}
+### Deed (Beglaubigung) {#deed}
Siehe [non-fungible token (NFT)](#nft)
@@ -808,7 +808,7 @@ Eine [Hard-Fork](#hard-fork) der Ethereum-Blockchain, die in Block 2.463.000 auf
Kurz für "Testnetzwerk", ein Netzwerk, das dazu dient, das Verhalten des Hauptnetzwerks von Ethereum zu simulieren (siehe [Hauptnetzwerk](#mainnet)).
-
+
Testnetze
diff --git a/src/content/translations/es/developers/docs/nodes-and-clients/nodes-as-a-service/index.md b/src/content/translations/es/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
index 943c88e0b52..f85d72c7ad7 100644
--- a/src/content/translations/es/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
+++ b/src/content/translations/es/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
@@ -18,7 +18,7 @@ Si aún no entiendes qué son los nodos y los clientes, consulta [Nodos y client
Los proveedores de servicios de nodos ejecutan clientes de nodos distribuidos para ti, así que tú no tienes que hacerlo.
-Estos servicios suelen proporcionar una clave de API, que puedes usar para escribir y leer desde la blockchain. Además, suelen incluir acceso a [redes de pruebas de Ethereum](/developers/docs/networks/#testnets), además de a la red principal.
+Estos servicios suelen proporcionar una clave de API, que puedes usar para escribir y leer desde la blockchain. Además, suelen incluir acceso a [redes de pruebas de Ethereum](/developers/docs/networks/#ethereum-testnets), además de a la red principal.
Algunos servicios te ofrecen tu propio nodo que ellos gestionan para ti, mientras que otros usan equilibradores de carga para distribuir la actividad a través de los nodos.
diff --git a/src/content/translations/es/glossary/index.md b/src/content/translations/es/glossary/index.md
index 61b2a4a4ef5..2f01d517b78 100644
--- a/src/content/translations/es/glossary/index.md
+++ b/src/content/translations/es/glossary/index.md
@@ -704,7 +704,7 @@ Una [bifurcación dura](#hard-fork) de la blockchain de Ethereum, que se produjo
Una red que se utiliza para simular el comportamiento de la red principal de Ethereum (consulta [red principal](#mainnet)).
-
+
Redes de pruebas
diff --git a/src/content/translations/fa/developers/docs/nodes-and-clients/nodes-as-a-service/index.md b/src/content/translations/fa/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
index c3f057e7ac3..6b5a913facf 100644
--- a/src/content/translations/fa/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
+++ b/src/content/translations/fa/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
@@ -18,7 +18,7 @@ sidebarDepth: 2
ارائهدهندگان خدمات گره، کلاینتهای گرهی توزیع شده را در پشتصحنه برای شما اجرا میکنند، بنابراین نیازی ندارید که خودتان آنها را انجام دهید.
-این سرویسها معمولاً یک کلید API ارائه میکنند که میتوانید از آن برای نوشتن و خواندن از زنجیرهی بلوکی استفاده کنید. آنها اغلب علاوه بر شبکهی اصلی به [شبکههای تست اتریوم](/developers/docs/networks/#testnets) نیز دسترسی دارند.
+این سرویسها معمولاً یک کلید API ارائه میکنند که میتوانید از آن برای نوشتن و خواندن از زنجیرهی بلوکی استفاده کنید. آنها اغلب علاوه بر شبکهی اصلی به [شبکههای تست اتریوم](/developers/docs/networks/#ethereum-testnets) نیز دسترسی دارند.
برخی از سرویسها گرهی اختصاصی خودشان را به شما ارائه میدهند و آنها را برای شما مدیریت میکنند، در حالی که برخی دیگر از متعادلکنندههای بار برای توزیع فعالیت در گرهها استفاده میکنند.
diff --git a/src/content/translations/fr/developers/docs/nodes-and-clients/nodes-as-a-service/index.md b/src/content/translations/fr/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
index b673f4d10a1..63eb67bb70b 100644
--- a/src/content/translations/fr/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
+++ b/src/content/translations/fr/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
@@ -18,7 +18,7 @@ Si vous ne savez pas encore ce que sont les nœuds et les clients, consultez la
Les fournisseurs de services de nœuds exécutent les clients de nœuds distribués en arrière-plan pour vous, afin que vous n'ayez pas à le faire.
-Ces services fournissent généralement une clé API que vous pouvez utiliser pour écrire sur la blockchain et pour la lire. Ils incluent souvent un accès aux [réseaux de test Ethereum](/developers/docs/networks/#testnets) en plus du réseau principal.
+Ces services fournissent généralement une clé API que vous pouvez utiliser pour écrire sur la blockchain et pour la lire. Ils incluent souvent un accès aux [réseaux de test Ethereum](/developers/docs/networks/#ethereum-testnets) en plus du réseau principal.
Certains services vous offrent votre propre nœud dédié qu'ils gèrent pour vous, tandis que d'autres utilisent des équilibreurs de charge pour répartir l'activité entre les nœuds.
diff --git a/src/content/translations/fr/glossary/index.md b/src/content/translations/fr/glossary/index.md
index 258bf72357c..087b66f85c1 100644
--- a/src/content/translations/fr/glossary/index.md
+++ b/src/content/translations/fr/glossary/index.md
@@ -808,7 +808,7 @@ Unité de l'[ether](#ether). 1 szabo = 1012 [wei](#wei), 106
+
Réseaux de test
diff --git a/src/content/translations/hu/developers/docs/nodes-and-clients/nodes-as-a-service/index.md b/src/content/translations/hu/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
index d5df8eadad1..f9bdf449441 100644
--- a/src/content/translations/hu/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
+++ b/src/content/translations/hu/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
@@ -19,7 +19,7 @@ Ha nem tudod, hogy mik azok a csomópontok és kliensek, akkor nézd meg a [Csom
A csomópontszolgáltatók elosztott csomópont klienseket futtatnak a színfalak mögött, így neked nem kell.
-Ezek a szolgáltatások általában egy API kulcsot adnak, amivel írhatsz és olvashatsz a blokkláncról. Gyakran biztosítanak hozzáférést az [Ethereum tesztnetekhez](/developers/docs/networks/#testnets) a főhálózat mellett.
+Ezek a szolgáltatások általában egy API kulcsot adnak, amivel írhatsz és olvashatsz a blokkláncról. Gyakran biztosítanak hozzáférést az [Ethereum tesztnetekhez](/developers/docs/networks/#ethereum-testnets) a főhálózat mellett.
Egyes szolgáltatások saját dedikált csomópontot kínálnak, amelyet a te számodra tartanak fenn, míg mások terheléselosztókkal oszlatják el a tevékenységet a csomópontok között.
diff --git a/src/content/translations/hu/glossary/index.md b/src/content/translations/hu/glossary/index.md
index a09b895c6e2..ead6e97148a 100644
--- a/src/content/translations/hu/glossary/index.md
+++ b/src/content/translations/hu/glossary/index.md
@@ -704,7 +704,7 @@ Az Ethereum blokklánc egyik[hard-forkja](#hard-fork), mely az 2,463,000 számú
A "test network", (vagyis "teszthálózat") rövidítése. A fő Ethereum hálózat (lásd: [főhálózat](#mainnet)) viselkedésének szimulálására használt hálózat.
-
+
Tesztnetek
diff --git a/src/content/translations/id/developers/docs/nodes-and-clients/nodes-as-a-service/index.md b/src/content/translations/id/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
index c1d4821df31..68e7bcb4b57 100644
--- a/src/content/translations/id/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
+++ b/src/content/translations/id/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
@@ -18,7 +18,7 @@ Jika Anda belum memahami apa itu node dan klien, bacalah tentang [Node dan klien
Penyedia layanan node menjalankan klien node terdistribusi di belakang layar untuk Anda, sehingga Anda tidak perlu melakukannya sendiri.
-Layanan ini umumnya menyediakan kunci API yang bisa Anda gunakan untuk menulis pada dan membaca dari blockchain. Layanan ini sering mencakup akses ke [testnet Ethereum](/developers/docs/networks/#testnets) sebagai tambahan pada Jaringan Utama.
+Layanan ini umumnya menyediakan kunci API yang bisa Anda gunakan untuk menulis pada dan membaca dari blockchain. Layanan ini sering mencakup akses ke [testnet Ethereum](/developers/docs/networks/#ethereum-testnets) sebagai tambahan pada Jaringan Utama.
Beberapa layanan menawarkan node yang didedikasikan sebagai milik Anda sendiri yang dikelola mereka untuk Anda, sementara yang lainnya menggunakan penyeimbang muatan untuk mendistribusikan aktivitas di seluruh node.
diff --git a/src/content/translations/id/glossary/index.md b/src/content/translations/id/glossary/index.md
index b8620169608..94fb93ee399 100644
--- a/src/content/translations/id/glossary/index.md
+++ b/src/content/translations/id/glossary/index.md
@@ -808,7 +808,7 @@ Denominasi [ether](#ether). 1 szabo = 1012 [wei](#wei), 106
+
Jaringan percobaan
diff --git a/src/content/translations/it/developers/docs/nodes-and-clients/nodes-as-a-service/index.md b/src/content/translations/it/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
index 52049396974..801ab9bada2 100644
--- a/src/content/translations/it/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
+++ b/src/content/translations/it/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
@@ -18,7 +18,7 @@ Se non hai ancora chiaro cosa siano nodi e client, consulta [Nodi e client](/dev
I fornitori di servizi di nodo eseguono client di nodo distribuiti, quindi non è necessario farlo.
-Questi servizi in genere forniscono una chiave API utilizzabile per scrivere e leggere sulla blockchain. Spesso includono l'accesso a [reti di test Ethereum](/developers/docs/networks/#testnets) in aggiunta alla rete principale.
+Questi servizi in genere forniscono una chiave API utilizzabile per scrivere e leggere sulla blockchain. Spesso includono l'accesso a [reti di test Ethereum](/developers/docs/networks/#ethereum-testnets) in aggiunta alla rete principale.
Alcuni servizi offrono un nodo personale dedicato e lo gestiscono, mentre altri usano bilanciatori del carico per distribuire l'attività tra i nodi.
diff --git a/src/content/translations/it/glossary/index.md b/src/content/translations/it/glossary/index.md
index 51e18034582..77d6d3320c5 100644
--- a/src/content/translations/it/glossary/index.md
+++ b/src/content/translations/it/glossary/index.md
@@ -736,7 +736,7 @@ Una [diramazione permanente](#hard-fork) della blockchain Ethereum, che si è ve
Abbreviazione di "rete di prova", una rete usata per simulare il comportamento della rete principale di Ethereum (vedi [Rete principale](#mainnet)).
-
+
Reti di prova
diff --git a/src/content/translations/pl/developers/docs/nodes-and-clients/nodes-as-a-service/index.md b/src/content/translations/pl/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
index 3ec340bdbe2..36537302239 100644
--- a/src/content/translations/pl/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
+++ b/src/content/translations/pl/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
@@ -19,7 +19,7 @@ Jeśli nie wiesz jeszcze, czym są węzły i klienci, sprawdź [Węzły i klienc
Dostawcy usług węzłów obsługują dla Ciebie klientów węzłów rozproszonych, więc nie musisz tego robić.
-Te usługi zazwyczaj zapewniają klucz API, którego możesz użyć do pisania i odczytywania z blockchainu. Często obejmują one dostęp do [sieci testowych Ethereum](/developers/docs/networks/#testnets) oprócz sieci głównej.
+Te usługi zazwyczaj zapewniają klucz API, którego możesz użyć do pisania i odczytywania z blockchainu. Często obejmują one dostęp do [sieci testowych Ethereum](/developers/docs/networks/#ethereum-testnets) oprócz sieci głównej.
Niektóre usługi oferują własny dedykowany węzeł, którym zarządzają za Ciebie, podczas gdy inne używają systemów równoważenia obciążenia do dystrybucji aktywności między węzłami.
diff --git a/src/content/translations/pl/glossary/index.md b/src/content/translations/pl/glossary/index.md
index a5af33b3857..614b8bb7166 100644
--- a/src/content/translations/pl/glossary/index.md
+++ b/src/content/translations/pl/glossary/index.md
@@ -718,7 +718,7 @@ Nazwa [etheru](#ether). 1 szabo = 1012 [wei](#wei), 106 sz
Skrót od nazwy „sieć testowa”, służy do symulowania zachowania głównej sieci Ethereum (patrz [sieć główna](#mainnet)).
-
+
Sieci testowe
diff --git a/src/content/translations/pt-br/developers/docs/nodes-and-clients/nodes-as-a-service/index.md b/src/content/translations/pt-br/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
index ba88eafb15a..cbe9456bdc2 100644
--- a/src/content/translations/pt-br/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
+++ b/src/content/translations/pt-br/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
@@ -18,7 +18,7 @@ Se você ainda não sabe o que são os nós e os clientes e como eles funcinam,
Os provedores de nós disponibilizam sua infraestrutura para você não precisar de uma.
-Esses serviços são tipicamente disponibilizados via uma chave API que você pode usar para escrever e ler as informações dentro da cadeia de blocos. Muitas vezes, incluindo acesso a [redes de testes Ethereum](/developers/docs/networks/#testnets) além da rede principal.
+Esses serviços são tipicamente disponibilizados via uma chave API que você pode usar para escrever e ler as informações dentro da cadeia de blocos. Muitas vezes, incluindo acesso a [redes de testes Ethereum](/developers/docs/networks/#ethereum-testnets) além da rede principal.
Alguns serviços oferecem a você o seu próprio nó dedicado que eles gerenciam para você, enquanto outros usam os balanceadores de carga para distribuir atividade entre nós.
diff --git a/src/content/translations/ro/developers/docs/nodes-and-clients/nodes-as-a-service/index.md b/src/content/translations/ro/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
index acb0c122f8f..e6058f91c42 100644
--- a/src/content/translations/ro/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
+++ b/src/content/translations/ro/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
@@ -18,7 +18,7 @@ Dacă nu aţi înțeles încă ce sunt nodurile și clienții, consultaţi secţ
Furnizorii de servicii de noduri rulează în culise clienți de noduri distribuite pentru dvs., ca să nu fiţi nevoit să o faceţi dvs.
-Aceste servicii oferă de obicei o cheie API pe care o puteţi utiliza pentru a scrie și a citi din blockchain. Acestea includ adesea și accesul la [testnet-ul Ethereum](/developers/docs/networks/#testnets), în plus față de Mainnet.
+Aceste servicii oferă de obicei o cheie API pe care o puteţi utiliza pentru a scrie și a citi din blockchain. Acestea includ adesea și accesul la [testnet-ul Ethereum](/developers/docs/networks/#ethereum-testnets), în plus față de Mainnet.
Unele servicii vă oferă propriul nod dedicat, pe care îl gestionează pentru dvs., în timp ce altele folosesc echilibratori de încărcare pentru a distribui activitatea între noduri.
diff --git a/src/content/translations/ro/glossary/index.md b/src/content/translations/ro/glossary/index.md
index 9d018fe39cd..c54d79c3b7f 100644
--- a/src/content/translations/ro/glossary/index.md
+++ b/src/content/translations/ro/glossary/index.md
@@ -808,7 +808,7 @@ O [furculiță tare](#hard-fork) a blockchain-ului Ethereum, care a avut loc la
Prescurtare de la "rețea de testare", o rețea utilizată pentru a simula comportamentul rețelei principale Ethereum (a se vedea [Rețelei principale](#mainnet)).
-
+
Rețele de testare
diff --git a/src/content/translations/tr/developers/docs/nodes-and-clients/nodes-as-a-service/index.md b/src/content/translations/tr/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
index e7e53710855..b9ee7bdb06f 100644
--- a/src/content/translations/tr/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
+++ b/src/content/translations/tr/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
@@ -18,7 +18,7 @@ Düğümlerin ve istemcilerin ne olduğu konusunda henüz bir fikriniz yoksa, [D
Düğüm hizmeti sağlayıcıları, siz uğraşmayın diye sahne arkasında sizin için dağıtılmış düğüm istemcileri çalıştırır.
-Bu hizmetler tipik olarak blok zincirine yazmak ve blok zincirinden okumak için kullanabileceğiniz bir API anahtarı sağlar. Bunlar genellikle Mainnet'e ek olarak [Ethereum test ağlarına](/developers/docs/networks/#testnets) erişim içerir.
+Bu hizmetler tipik olarak blok zincirine yazmak ve blok zincirinden okumak için kullanabileceğiniz bir API anahtarı sağlar. Bunlar genellikle Mainnet'e ek olarak [Ethereum test ağlarına](/developers/docs/networks/#ethereum-testnets) erişim içerir.
Bazı hizmetler, sizin için yönettikleri kendi özel düğümünüzü sunarken, diğerleri etkinliği düğümler arasında dağıtmak için yük dengeleyicileri kullanır.
diff --git a/src/content/translations/tr/glossary/index.md b/src/content/translations/tr/glossary/index.md
index 94750823269..16e19c388ae 100644
--- a/src/content/translations/tr/glossary/index.md
+++ b/src/content/translations/tr/glossary/index.md
@@ -808,7 +808,7 @@ Belirli G/Ç (Girdi/Çıktı) yoğun işlemler için [gaz](#gas) hesaplamasını
"Test network"ün (Test ağı) kısaltması, ana Ethereum ağının (bkz. [Mainnet](#mainnet)). davranışını simüle etmek için kullanılan bir ağ.
-
+
Test Ağları
diff --git a/src/content/translations/zh/glossary/index.md b/src/content/translations/zh/glossary/index.md
index 77ca83f5e57..cf4e74812d8 100644
--- a/src/content/translations/zh/glossary/index.md
+++ b/src/content/translations/zh/glossary/index.md
@@ -722,7 +722,7 @@ Gigawei 的缩写,[ether](#ether) 的一个货币单位,通常用于计算 [
"测试网络"的简称,用于模拟以太坊主网行为的网络(参阅 [mainnet 主网](#mainnet))。
-
+
测试网
From 3dc9a2aec94cae5fb5f9a8895771c8da9d58b739 Mon Sep 17 00:00:00 2001
From: MonsieurDMA
Date: Tue, 24 May 2022 13:38:07 +0200
Subject: [PATCH 043/298] Allowance has to be degressive [Fixes #6443]
---
.../index.md | 4 ++--
.../index.md | 4 ++--
.../index.md | 4 ++--
.../index.md | 4 ++--
.../index.md | 4 ++--
.../index.md | 4 ++--
6 files changed, 12 insertions(+), 12 deletions(-)
diff --git a/src/content/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md b/src/content/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
index de9a7ccd9b3..ecc30b94800 100644
--- a/src/content/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
+++ b/src/content/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
@@ -91,7 +91,7 @@ contract ERC20Basic is IERC20 {
require(numTokens <= allowed[owner][msg.sender]);
balances[owner] = balances[owner]-numTokens;
- allowed[owner][msg.sender] = allowed[owner][msg.sender]+numTokens;
+ allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
balances[buyer] = balances[buyer]+numTokens;
emit Transfer(owner, buyer, numTokens);
return true;
@@ -273,7 +273,7 @@ contract ERC20Basic is IERC20 {
require(numTokens <= allowed[owner][msg.sender]);
balances[owner] = balances[owner]-numTokens;
- allowed[owner][msg.sender] = allowed[owner][msg.sender]+numTokens;
+ allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
balances[buyer] = balances[buyer]+numTokens;
emit Transfer(owner, buyer, numTokens);
return true;
diff --git a/src/content/translations/fr/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md b/src/content/translations/fr/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
index 1ac8358fceb..2b285420298 100644
--- a/src/content/translations/fr/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
+++ b/src/content/translations/fr/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
@@ -96,7 +96,7 @@ contract ERC20Basic is IERC20 {
require(numTokens <= allowed[owner][msg.sender]);
balances[owner] = balances[owner]-numTokens;
- allowed[owner][msg.sender] = allowed[owner][msg.sender]+numTokens;
+ allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
balances[buyer] = balances[buyer]+numTokens;
emit Transfer(owner, buyer, numTokens);
return true;
@@ -278,7 +278,7 @@ contract ERC20Basic is IERC20 {
require(numTokens <= allowed[owner][msg.sender]);
balances[owner] = balances[owner]-numTokens;
- allowed[owner][msg.sender] = allowed[owner][msg.sender]+numTokens;
+ allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
balances[buyer] = balances[buyer]+numTokens;
emit Transfer(owner, buyer, numTokens);
return true;
diff --git a/src/content/translations/id/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md b/src/content/translations/id/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
index ea7833605e3..3b70a03a490 100644
--- a/src/content/translations/id/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
+++ b/src/content/translations/id/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
@@ -96,7 +96,7 @@ contract ERC20Basic is IERC20 {
require(numTokens <= allowed[owner][msg.sender]);
balances[owner] = balances[owner]-numTokens;
- allowed[owner][msg.sender] = allowed[owner][msg.sender]+numTokens;
+ allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
balances[buyer] = balances[buyer]+numTokens;
emit Transfer(owner, buyer, numTokens);
return true;
@@ -278,7 +278,7 @@ contract ERC20Basic is IERC20 {
require(numTokens <= allowed[owner][msg.sender]);
balances[owner] = balances[owner]-numTokens;
- allowed[owner][msg.sender] = allowed[owner][msg.sender]+numTokens;
+ allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
balances[buyer] = balances[buyer]+numTokens;
emit Transfer(owner, buyer, numTokens);
return true;
diff --git a/src/content/translations/pt-br/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md b/src/content/translations/pt-br/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
index c584ceade9d..99db3b51e56 100644
--- a/src/content/translations/pt-br/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
+++ b/src/content/translations/pt-br/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
@@ -96,7 +96,7 @@ contract ERC20Basic is IERC20 {
require(numTokens <= allowed[owner][msg.sender]);
balances[owner] = balances[owner]-numTokens;
- allowed[owner][msg.sender] = allowed[owner][msg.sender]+numTokens;
+ allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
balances[buyer] = balances[buyer]+numTokens;
emit Transfer(owner, buyer, numTokens);
return true;
@@ -278,7 +278,7 @@ contract ERC20Basic is IERC20 {
require(numTokens <= allowed[owner][msg.sender]);
balances[owner] = balances[owner]-numTokens;
- allowed[owner][msg.sender] = allowed[owner][msg.sender]+numTokens;
+ allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
balances[buyer] = balances[buyer]+numTokens;
emit Transfer(owner, buyer, numTokens);
return true;
diff --git a/src/content/translations/tr/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md b/src/content/translations/tr/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
index 1422cd47b31..4716a935257 100644
--- a/src/content/translations/tr/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
+++ b/src/content/translations/tr/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
@@ -96,7 +96,7 @@ contract ERC20Basic is IERC20 {
require(numTokens <= allowed[owner][msg.sender]);
balances[owner] = balances[owner]-numTokens;
- allowed[owner][msg.sender] = allowed[owner][msg.sender]+numTokens;
+ allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
balances[buyer] = balances[buyer]+numTokens;
emit Transfer(owner, buyer, numTokens);
return true;
@@ -278,7 +278,7 @@ contract ERC20Basic is IERC20 {
require(numTokens <= allowed[owner][msg.sender]);
balances[owner] = balances[owner]-numTokens;
- allowed[owner][msg.sender] = allowed[owner][msg.sender]+numTokens;
+ allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
balances[buyer] = balances[buyer]+numTokens;
emit Transfer(owner, buyer, numTokens);
return true;
diff --git a/src/content/translations/zh/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md b/src/content/translations/zh/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
index 5d14eb36436..b29fc98cf18 100644
--- a/src/content/translations/zh/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
+++ b/src/content/translations/zh/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
@@ -96,7 +96,7 @@ contract ERC20Basic is IERC20 {
require(numTokens <= allowed[owner][msg.sender]);
balances[owner] = balances[owner]-numTokens;
- allowed[owner][msg.sender] = allowed[owner][msg.sender]+numTokens;
+ allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
balances[buyer] = balances[buyer]+numTokens;
emit Transfer(owner, buyer, numTokens);
return true;
@@ -282,7 +282,7 @@ contract ERC20Basic is IERC20 {
require(numTokens <= allowed[owner][msg.sender]);
balances[owner] = balances[owner]-numTokens;
- allowed[owner][msg.sender] = allowed[owner][msg.sender]+numTokens;
+ allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
balances[buyer] = balances[buyer]+numTokens;
emit Transfer(owner, buyer, numTokens);
return true;
From b5e77913a778027b3c2babf08b1385c5e2f03031 Mon Sep 17 00:00:00 2001
From: zjiekai
Date: Tue, 24 May 2022 23:31:01 +0800
Subject: [PATCH 044/298] update uniswap doc link
---
.../developers/tutorials/uniswap-v2-annotated-code/index.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/content/developers/tutorials/uniswap-v2-annotated-code/index.md b/src/content/developers/tutorials/uniswap-v2-annotated-code/index.md
index 8d6b9a5dc16..9bfe9a032ac 100644
--- a/src/content/developers/tutorials/uniswap-v2-annotated-code/index.md
+++ b/src/content/developers/tutorials/uniswap-v2-annotated-code/index.md
@@ -23,7 +23,7 @@ _Traders_ send one type of token to the pool and receive the other (for example,
When liquidity providers want their assets back they can burn the pool tokens and receive back their tokens, including their share of the rewards.
-[Click here for a fuller description](https://uniswap.org/docs/v2/core-concepts/swaps/).
+[Click here for a fuller description](https://docs.uniswap.org/protocol/V2/concepts/core-concepts/swaps).
### Why v2? Why not v3? {#why-v2}
From e94d0274aaa271bc318ceadc76a6c2f92d7b5fec Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 10:54:08 -0600
Subject: [PATCH 045/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Sam Richards
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 9d73ccc85a4..f38d90faaec 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -18,7 +18,7 @@ If the wallet does meet our list policy, please complete the following informati
**Wallet description**
-
+
**Wallet logo**
From a03d908efa1686acff6fd599a05356466ee93d63 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 10:55:11 -0600
Subject: [PATCH 046/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index f38d90faaec..b3c583ebbf0 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -92,7 +92,7 @@ If the wallet does meet our list policy, please complete the following informati
-**What license was the wallet software released under?**
+**What license is the wallet software released under?**
From 82826e12dd8911d50b1f63ecd482f0dbf77ff93b Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 10:56:09 -0600
Subject: [PATCH 047/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index b3c583ebbf0..667a928c076 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -36,7 +36,7 @@ If the wallet does meet our list policy, please complete the following informati
-**Is your wallet security tested? Please explain security measures i.e. security audit, internal security team, or some other method.**
+**Is the wallet security tested? Please explain security measures i.e. security audit, internal security team, or some other method.**
From ab182e2b0473b7cbdf773ae24476ac98625f331d Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 10:56:58 -0600
Subject: [PATCH 048/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Sam Richards
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 667a928c076..df347b4e5e7 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -98,7 +98,7 @@ If the wallet does meet our list policy, please complete the following informati
**Is your wallet custodial, or non-custodial?**
-
+
**Please describe the measures taken to ensure the wallet's security and provide documentation wherever possible**
From a3b2fc10499d8b23889dd8df2c2f74a3165ffad7 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 20:32:34 -0600
Subject: [PATCH 049/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 1 -
1 file changed, 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index df347b4e5e7..da8d135d698 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -8,7 +8,6 @@ assignees: ""
Before suggesting a wallet, make sure you've read [our listing policy](https://www.ethereum.org/en/contributing/adding-products/). Only continue with the issue if your wallet meets the criteria listed there.
-If the wallet does meet our list policy, please complete the following information which we need to accurately list the wallet.
### Project info
From ac47cc7f82467b815ab987b3606b1985e6255d58 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 20:32:59 -0600
Subject: [PATCH 050/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Paul Wackerow <54227730+wackerow@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index da8d135d698..9c08c43060f 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -21,7 +21,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
**Wallet logo**
-
+
**Background color for brand logo**
From 39ddd6ee34692a72fda9d65d2ee39ec998a193d5 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 20:42:00 -0600
Subject: [PATCH 051/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Sam Richards
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 1 +
1 file changed, 1 insertion(+)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 9c08c43060f..5e571fe216b 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -189,6 +189,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
**What educational resources/documentation do you provide to users?**
+
### Extra
**Does the wallet have any integrated tools not mentioned above?**
From 7e053e9ef183abfffb87c891b9336d25d85a64e3 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 20:42:50 -0600
Subject: [PATCH 052/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 5e571fe216b..99f143eac79 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -189,7 +189,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
**What educational resources/documentation do you provide to users?**
-
+
### Extra
**Does the wallet have any integrated tools not mentioned above?**
From 6c37a98d11025811528e5f6ebf274679fd11cbb0 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 20:56:21 -0600
Subject: [PATCH 053/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Sam Richards
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 99f143eac79..45b18b3d22b 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -41,7 +41,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
**When did your wallet go live to users?**
-
+
**Does your wallet have an active development team?**
From a5f11e0ea67389db36bb5bb683c68195db75401d Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 20:56:40 -0600
Subject: [PATCH 054/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 45b18b3d22b..37470afbf59 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -51,7 +51,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
-**Is there internationalization support for your wallet?**
+**Is the wallet available in multiple languages?**
From c9f471a906d068a4fdcaa2bfdd5547e7340d3fc6 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 21:00:43 -0600
Subject: [PATCH 055/298] Update suggest_wallet.md
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 4 ----
1 file changed, 4 deletions(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 37470afbf59..0bbabeb0ec7 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -55,10 +55,6 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
-**What is the repository for your codebase?**
-
-
-
**What social links are there for the project?**
From 3b6145a023bbb4945b32361afd0ad9e4e725051a Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 21:01:42 -0600
Subject: [PATCH 056/298] Update suggest_wallet.md
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 4 ----
1 file changed, 4 deletions(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 0bbabeb0ec7..ee125b3d2e3 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -59,10 +59,6 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
-**What is your wallet's onboarding experience?**
-
-
-
### Device
**Does the wallet have a mobile app? If yes, which operating systems are supported (iOS, Android)?**
From 722f04f9bd54860ee53191bcfb0f4079b819646b Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 21:04:19 -0600
Subject: [PATCH 057/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Sam Richards
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index ee125b3d2e3..2dd3351bc0f 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -63,7 +63,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
**Does the wallet have a mobile app? If yes, which operating systems are supported (iOS, Android)?**
-
+
**Does the wallet have a desktop app? If yes, which operating systems are supported (Windows, Mac, Linux)?**
From 4994d77966be0a7a7a4c5e33cc58c5489c4bc0bf Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 21:04:32 -0600
Subject: [PATCH 058/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Sam Richards
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 2dd3351bc0f..d0e5924771c 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -67,7 +67,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
**Does the wallet have a desktop app? If yes, which operating systems are supported (Windows, Mac, Linux)?**
-
+
**Does the wallet have a browser extension? If yes, which browsers are supported (Chromium, Firefox, Safari)?**
From 569fc8534664d3c90df34710fb0e4f79ce201854 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 21:04:40 -0600
Subject: [PATCH 059/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Sam Richards
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index d0e5924771c..966f02c21f9 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -71,7 +71,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
**Does the wallet have a browser extension? If yes, which browsers are supported (Chromium, Firefox, Safari)?**
-
+
**Is it a hardware wallet?**
From 09e63fdc0b53c991baa03fe672e4c723cb246a78 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 21:04:51 -0600
Subject: [PATCH 060/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Sam Richards
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 966f02c21f9..7fa118a9bd2 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -75,7 +75,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
**Is it a hardware wallet?**
-
+
### Security
From 293634c9b42c049eaeb2018f8e856fec0fa526d1 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 21:07:31 -0600
Subject: [PATCH 061/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 7fa118a9bd2..89f143361e7 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -75,7 +75,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
**Is it a hardware wallet?**
-
+
### Security
From 11f73429deae2ea504941fde008d04d17799e6d7 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 21:08:09 -0600
Subject: [PATCH 062/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 89f143361e7..efb969b4c54 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -79,7 +79,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
### Security
-**Is the wallet code open-sourced?**
+**Is the source code for the wallet fully open-source?**
From 0b340cdd8f9723dfc46bd4c95e989ac53637e8e3 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 21:09:39 -0600
Subject: [PATCH 063/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Sam Richards
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index efb969b4c54..555cba07d7a 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -93,7 +93,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
**Please describe the measures taken to ensure the wallet's security and provide documentation wherever possible**
-
+
**Spam protection?**
From fa2779cff73fdc06959e72edc192bae810a7ffd3 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 21:10:42 -0600
Subject: [PATCH 064/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Sam Richards
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 555cba07d7a..a2d180613c1 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -87,7 +87,9 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
-**Is your wallet custodial, or non-custodial?**
+**Who holds the private keys?**
+
+
From abf92f87add7cbc64a4396b6e30d7501c02c6d76 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 21:10:59 -0600
Subject: [PATCH 065/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index a2d180613c1..680e56553c6 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -103,7 +103,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
### Features
-**Does the wallet have hardware wallet support?**
+**Does the wallet support connecting to a hardware wallet?**
From c2a8183f32e30b90d3df60163453bde41e621e23 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 21:13:27 -0600
Subject: [PATCH 066/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 680e56553c6..245439ff8f1 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -109,7 +109,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
**Does the wallet support WalletConnect?**
-
+
**Does the wallet support importing Ethereum RPC endpoints?**
From 7494f9f8ce9d6a65eb787900a16d2e583d8eea93 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 21:18:23 -0600
Subject: [PATCH 067/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 245439ff8f1..cea586fdec1 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -139,7 +139,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
-**Does the wallet support ENS?**
+**Does the wallet support sending transactions to ENS addresses?**
From 49c6e0a22351b5f6a05e9827df054577a4dabbfd Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 21:18:33 -0600
Subject: [PATCH 068/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index cea586fdec1..9d89c8ff234 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -147,7 +147,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
-**Does the wallet support EIP-1559 style transactions?**
+**Does the wallet support EIP-1559 (type 2) transactions?**
From 2814fd41f768bfb07def0defe8bde4d3c4d53459 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 21:18:43 -0600
Subject: [PATCH 069/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Sam Richards
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 9d89c8ff234..216270122b7 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -153,7 +153,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
### Finance
-**Does the wallet have fiat on-ramps through credit/debit cards or wire transfers, or Bank transfers (ACH)?**
+**Does the wallet have fiat on-ramps through credit/debit cards, wire transfers, or bank transfers (ACH)?**
From 887c27daa7d9bbe548493a15ded173d6ceb32267 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 21:19:36 -0600
Subject: [PATCH 070/298] Update suggest_wallet.md
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 3 ---
1 file changed, 3 deletions(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 216270122b7..05dc0aa5827 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -156,9 +156,6 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
**Does the wallet have fiat on-ramps through credit/debit cards, wire transfers, or bank transfers (ACH)?**
-
-
-
**Does the wallet support withdrawals to fiat?**
From 79f0b218095f5483db8d481f1eff55cb6e6929d0 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 21:19:53 -0600
Subject: [PATCH 071/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 05dc0aa5827..92783d062fa 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -161,7 +161,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
-### Smart Contract
+### Smart contract
**Is the wallet a multi-signature wallet?**
From 4acb0592bb8760978748f26122fe5a203fb85e8c Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Tue, 24 May 2022 21:20:15 -0600
Subject: [PATCH 072/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 5 +++++
1 file changed, 5 insertions(+)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 92783d062fa..5eef3340fb2 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -173,6 +173,11 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
### Support
+**Does the wallet have a person the ethereum.org team can contact regarding the wallet in future?**
+
+
+
+
**Does your wallet have a dedicated support team?**
From 3a344ed49d0fd053a70935613fad44e665ea0fe8 Mon Sep 17 00:00:00 2001
From: Joseph Cook <33655003+jmcook1186@users.noreply.github.com>
Date: Wed, 25 May 2022 15:15:08 +0100
Subject: [PATCH 073/298] Update
src/content/community/get-involved/open-research/index.md
Co-authored-by: Sam Richards
---
src/content/community/get-involved/open-research/index.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
index 4da49245966..1333a6a33f0 100644
--- a/src/content/community/get-involved/open-research/index.md
+++ b/src/content/community/get-involved/open-research/index.md
@@ -23,7 +23,7 @@ There are now several Layer 2 protocols that scale Ethereum using different tech
#### Links
-[Our Layer-2 page](https://ethereum.org/en/layer-2/)
+[Introduction to layer 2](/layer-2/)
[EthHub Layer-2](https://docs.ethhub.io/ethereum-roadmap/layer-2-scaling/zk-rollups/)
From 06be659d1f91fd4a61dca11258519baecd6d5b46 Mon Sep 17 00:00:00 2001
From: Joseph Cook <33655003+jmcook1186@users.noreply.github.com>
Date: Wed, 25 May 2022 15:19:32 +0100
Subject: [PATCH 074/298] Apply suggestions from code review
Co-authored-by: Sam Richards
---
src/content/community/get-involved/open-research/index.md | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
index 1333a6a33f0..a54b3dafe02 100644
--- a/src/content/community/get-involved/open-research/index.md
+++ b/src/content/community/get-involved/open-research/index.md
@@ -32,11 +32,11 @@ There are now several Layer 2 protocols that scale Ethereum using different tech
### Bridges
-One particular area of Layer-2 that requires more research and development is safe and performant bridges. This includes bridges between various Layer-2s and bridges between Layer 1 and Layer 2. This is a particularly important area of researchg because bridges are commonly targeted by hackers.
+One particular area of layer 2 that requires more research and development is safe and performant bridges. This includes bridges between various Layer-2s and bridges between Layer 1 and Layer 2. This is a particularly important area of researchg because bridges are commonly targeted by hackers.
#### Links
-[Our Bridges page](https://ethereum.org/en/developers/docs/bridges)
+[Introduction to blockchain bridges](/bridges/)
[Vitalik on bridges](https://old.reddit.com/r/ethereum/comments/rwojtk/ama_we_are_the_efs_research_team_pt_7_07_january/hrngyk8/)
@@ -47,7 +47,7 @@ Sharding Ethereum's blockchain has long been part of the development roadmap. Ho
#### Links
-[Our Sharding page](/upgrades/shard-chains/)
+[Introduction to Ethereum sharding](/upgrades/shard-chains/)
[Proto-Danksharding notes](https://notes.ethereum.org/@vbuterin/proto_danksharding_faq)
From 3aaf4dd35fd21ec43dea28cb888303eb4271b7d1 Mon Sep 17 00:00:00 2001
From: Joseph Cook <33655003+jmcook1186@users.noreply.github.com>
Date: Wed, 25 May 2022 15:46:47 +0100
Subject: [PATCH 075/298] split links into b/g and recent research, + links
---
.../get-involved/open-research/index.md | 112 ++++++++++++++----
1 file changed, 90 insertions(+), 22 deletions(-)
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
index a54b3dafe02..fc24fb223a1 100644
--- a/src/content/community/get-involved/open-research/index.md
+++ b/src/content/community/get-involved/open-research/index.md
@@ -21,12 +21,14 @@ There are ongoing efforts to scale Ethereum using a variety of techniques includ
There are now several Layer 2 protocols that scale Ethereum using different techniques for batching transactions and securing them on Ethereum layer 1. This is a very rapidly growing topic with a lot of research and development potential.
-#### Links
+#### Background Reading
[Introduction to layer 2](/layer-2/)
[EthHub Layer-2](https://docs.ethhub.io/ethereum-roadmap/layer-2-scaling/zk-rollups/)
+#### Recent Research
+
[ethresear.ch Layer 2](https://ethresear.ch/c/layer-2/32)
@@ -34,18 +36,24 @@ There are now several Layer 2 protocols that scale Ethereum using different tech
One particular area of layer 2 that requires more research and development is safe and performant bridges. This includes bridges between various Layer-2s and bridges between Layer 1 and Layer 2. This is a particularly important area of researchg because bridges are commonly targeted by hackers.
-#### Links
+#### Background Reading
[Introduction to blockchain bridges](/bridges/)
[Vitalik on bridges](https://old.reddit.com/r/ethereum/comments/rwojtk/ama_we_are_the_efs_research_team_pt_7_07_january/hrngyk8/)
+[Blockchain Bridges article](https://medium.com/1kxnetwork/blockchain-bridges-5db6afac44f8)
+
+#### Recent Research
+
+[Validating bridges](https://stonecoldpat.github.io/images/validatingbridges.pdf)
+
### Sharding
Sharding Ethereum's blockchain has long been part of the development roadmap. However, new scaling solutions such as "Danksharding" are currently taking center stage.
-#### Links
+#### Background Reading
[Introduction to Ethereum sharding](/upgrades/shard-chains/)
@@ -57,15 +65,21 @@ Sharding Ethereum's blockchain has long been part of the development roadmap. Ho
[Danksharding (Polynya)](https://polynya.medium.com/danksharding-36dc0c8067fe)
+#### Recent Research
+
+
### Hardware
[Running nodes](/developers/docs/nodes-and-clients/run-a-node/) on modest hardware is fundamental to keeping Ethereum decentralized. Therefore, active research into minimizing the hardware requirements to run nodes is an important area of research.
-#### Links
+#### Background Reading
[Ethereum on ARM](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/)
+#### Recent Research
+
+
## Security
Security is a broad topic that might include spam/scam prevention, wallet security, hardware security, crypto-economic security, bug hunting and testing of applications and client software and key-management. Contributing to knowledge in these areas will help stimulate mainstream adoption.
@@ -74,22 +88,26 @@ Security is a broad topic that might include spam/scam prevention, wallet securi
Zero-knowledge proofs (ZKP) and cryptography are critical for building privacy and security into Ethereum and its applications. Zero-knowledge is a relatively young but fast-moving space with many open research and development opportunities.
-#### Links
+#### Background Reading
[0xparc blog](https://0xparc.org/blog)
-[Ethresear.ch ZK](https://ethresear.ch/c/zk-s-nt-arks/13)
-
[zkp.science](https://zkp.science/)
[Zero Knowledge podcast](https://zeroknowledge.fm/)
+#### Recent Research
+
+
+[Ethresear.ch ZK](https://ethresear.ch/c/zk-s-nt-arks/13)
+
+
### Wallets
User-wallets can be browser extensions, desktop and mobile apps or smart contracts on Ethereum. There is active research into social recovery wallets that reduce some of the risk associated with individual-user key management. Associated with dveelopment of wallets is research into alternative forms of account abstraction, which is an important area of nascent research.
-#### Links
+#### Background Reading
[Our Security page](https://ethereum.org/en/security/)
@@ -100,6 +118,8 @@ User-wallets can be browser extensions, desktop and mobile apps or smart contrac
[EIP 4337 Account Abstraction](https://eips.ethereum.org/EIPS/eip-4337)
+#### Recent Research
+
## Community, Education and Outreach
@@ -109,61 +129,92 @@ Onboarding new users onto Ethereum requires new educational resources and approa
For Ethereum to onboard more people the UX/UI must be improved. This requires designers and UI and product experts to re-examine the design of wallets and apps.
-#### Links
+#### Background Reading
[Ethresear.ch UX/UI](https://ethresear.ch/c/ui-ux/24)
[Ethereum.org community page](https://ethereum.org/en/learn/)
+#### Recent Research
+
+
## Economics
There are complex crypto-economic factors relating to Ethereum's native asset (ether) and the tokens built on top of it (for example NFTs and ERC20 tokens).
-#### Links
+#### Background Reading
+
+[Rollup economics from first principles](https://barnabe.substack.com/p/understanding-rollup-economics-from?utm_source=url)
[Robust Incentives Group](https://ethereum.github.io/rig/)
+
+#### Recent Research
+
+[Empirical analysis of EIP1559]([https://arxiv.org/abs/2110.04753)
+
+[MEV auctions](https://ethresear.ch/t/mev-auction-auctioning-transaction-ordering-rights-as-a-solution-to-miner-extractable-value/6788)
+
+[Circulating supply equilibrium](https://ethresear.ch/t/circulating-supply-equilibrium-for-ethereum-and-minimum-viable-issuance-during-the-proof-of-stake-era/10954#6-enforcing-minimum-viable-issuance-with-a-variable-base-reward-factor-19)
+
+[Quantifying MEV: How dark is the forest?](https://arxiv.org/abs/2101.05511)
+
+[EIP 1559: One month later](https://arxiv.org/abs/2110.04753)
+
### PoS incentives
When Ethereum transitions to proof of stake, its native asset (ether) will be used as collateral by validators. The cryptoeconomics of this
-#### Links
+#### Background Reading
[Robist Incentives Group: PoS incentives](https://ethereum.github.io/beaconrunner/)
+#### Recent Research
+
+
### Liquid staking and derivatives
Liquid staking allows users with less than 32 ETH to receive staking yields by swapping ether for a token representing staked ether that can be used in DeFi. However, the incentives and market dynamics associated with liquid staking as well as its effect on Ethereum's security (e.g. centralization risks, )
-#### Links
+#### Background Reading
[Ethresear.ch liquid staking](https://ethresear.ch/search?q=liquid%20staking)
+
+#### Recent Research
+
+
### DeFi
Decentralized finance (DeFi) is one of the primary classes of application built on top of Ethereum. DeFi aims to create composable "money legos" that allow users to store, transfer, lend, borrow and and invest crypto-assets using smart contracts. This is a fast-moving space that is constantly updating. Research into secure, efficient and accessible protocols is constantly needed.
-#### Links
+#### Background Reading
[DeFi](https://ethereum.org/en/defi/)
[Coinbase: What is DeFi?](https://www.coinbase.com/learn/crypto-basics/what-is-defi)
+
+#### Recent Research
+
### Fee markets
Ethereum transaction fees protect the network from spam, denial-of-service attacks and bad smart-contract code. However, it also affects the end-user by influencing the cost of interacting with Ethereum. Balancing network security with end-user user-experience is an ongoing challenge that requires further research and development.
-#### Links
+#### Background Reading
[EIP 1559 (Robust Incentives Group)](https://ethereum.github.io/abm1559/notebooks/eip1559.html)
+#### Recent Research
+
### Taxation and accounting
Crypto taxation is a complicated issue that likely requires a software solution. There are some nascent crypto accounting project but this area requires much more attention.
+#### Background Reading
-#### Links
+#### Recent Research
[Example of taxation and accounting research: Cumming et al. 2019](https://www.mdpi.com/1911-8074/12/3/126)
@@ -175,7 +226,7 @@ Crypto taxation is a complicated issue that likely requires a software solution.
The consensus layer is concerned with the proof-of-stake mechanism securing Ethereum from the merge onwards. There is abundant ongoing research and development relating to PoS concepts and implementation, for example identifying and patching vulnerabilities, quantifying cryptoeconomic security, increasing the security or performance of client implementations, building light clients and developing staking apps.
-#### Links
+#### Background Reading
[Prysm client](https://docs.prylabs.network/docs/how-prysm-works/beacon-node/)
@@ -189,11 +240,14 @@ The consensus layer is concerned with the proof-of-stake mechanism securing Ethe
[Ethresear.ch Consensus](https://ethresear.ch/c/consensus/29)
+#### Recent Research
### Execution Clients
The execution layer is concerned with executing transactions, running the EVM and generating execution payloads to pass to the consensus layer. There are many active areas of research, especially as execution clients are updated ready for the merge. This includes building out light client support, research into gas limits and incorporating new data structures (e.g. Verkle Tries).
+#### Background Reading
+
[Geth client](geth.ethereum.org)
[Nethermind client](nethermind.io)
@@ -202,44 +256,53 @@ The execution layer is concerned with executing transactions, running the EVM an
[Erigon client](https://github.com/ledgerwatch/erigon)
+#### Recent Research
### Data Science and Analytics
There is a need for more data analysis tools and dashboards that give detailed information about activity on Ethereum and the health of the network.
-### Links
+### Background Reading
[Dune Analytics](https://dune.com/browse/dashboards)
[Client diversity dashboard](https://clientdiversity.org/)
+#### Recent Research
+
## Apps and Tooling
### DAOs
DAOs are one of the key classes of application being built on top of Ethereum. There is a lot of very active research into how they may develop to replace corporations and other traditional organizations.
-#### Links
+#### Background Reading
[Dao Collective](https://daocollective.xyz/)
+#### Recent Research
+
### Developer tools
Tools for Ethereum developers are rapidly improving. There is lots of active research and development to do in this general area.
-#### Links
+#### Background Reading
[Developer Frameworks](https://ethereum.org/en/developers/docs/frameworks/)
[Consensus developer tools list](https://github.com/ConsenSys/ethereum-developer-tools-list)
+#### Recent Research
+
### App security
Hacks on Ethereum nearly always exploit vulnerabilities in individual applications rather than the base protocol. Hackers and app developers are locked in an arms race to develop new attacks and defenses. This means there is always important research and development required to keep apps safe from hacks.
-#### Links
+#### Background Reading
+
+#### Recent Research
[ethresear.ch Applications](https://ethresear.ch/c/applications/18)
@@ -248,14 +311,19 @@ Hacks on Ethereum nearly always exploit vulnerabilities in individual applicatio
Apps on Ethereum are rarely fully decentralized because they rely on some centralized tooling or infrastructure. Decentralizing the full tech stack is an important research area.
-#### Links
+#### Background Reading
[Coinbase: Intro to Web3 Stack](https://blog.coinbase.com/a-simple-guide-to-the-web3-stack-785240e557f0)
+#### Recent Research
+
+
### Composability
Composability is the ability for different apps to work in parallel or on top of one another so that users are not locked-in to specific protocols. This is something that requires best-practices in interoperability and data standards. This is an area that would benefit from more ongoing research and development.
-#### Links
+#### Background Reading
[Smart contract composability](https://ethereum.org/en/developers/docs/smart-contracts/composability/)
+
+#### Recent Research
From 1fa4b4f5bd871ccb7aa4ad5660757ac4629d654d Mon Sep 17 00:00:00 2001
From: Joseph Cook <33655003+jmcook1186@users.noreply.github.com>
Date: Wed, 25 May 2022 16:22:47 +0100
Subject: [PATCH 076/298] add info on zkp and formal verification
---
.../get-involved/open-research/index.md | 138 +++++++++++-------
1 file changed, 87 insertions(+), 51 deletions(-)
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
index fc24fb223a1..8b8ba09987f 100644
--- a/src/content/community/get-involved/open-research/index.md
+++ b/src/content/community/get-involved/open-research/index.md
@@ -13,7 +13,7 @@ One of the primary strengths of Ethereum is that it is constantly being improved
Regardless of the specific topic, there is a wealth of information on Ethereum research to be found at [ethresear.ch](https://ethresear.ch) and the [Eth R&D Discord channel](https://discord.gg/n7JxAeRu). These are the primary places where Ethereum researchers discuss the latest ideas and development opportunities.
-## Scaling and Performance
+## Scaling and performance
There are ongoing efforts to scale Ethereum using a variety of techniques including sharding the blockchain, danksharding and using rollups. Introductory information on scaling Ethereum is available on our [scaling page](/developers/docs/scaling).
@@ -21,13 +21,13 @@ There are ongoing efforts to scale Ethereum using a variety of techniques includ
There are now several Layer 2 protocols that scale Ethereum using different techniques for batching transactions and securing them on Ethereum layer 1. This is a very rapidly growing topic with a lot of research and development potential.
-#### Background Reading
+#### Background reading
[Introduction to layer 2](/layer-2/)
[EthHub Layer-2](https://docs.ethhub.io/ethereum-roadmap/layer-2-scaling/zk-rollups/)
-#### Recent Research
+#### Recent research
[ethresear.ch Layer 2](https://ethresear.ch/c/layer-2/32)
@@ -36,7 +36,7 @@ There are now several Layer 2 protocols that scale Ethereum using different tech
One particular area of layer 2 that requires more research and development is safe and performant bridges. This includes bridges between various Layer-2s and bridges between Layer 1 and Layer 2. This is a particularly important area of researchg because bridges are commonly targeted by hackers.
-#### Background Reading
+#### Background reading
[Introduction to blockchain bridges](/bridges/)
@@ -44,7 +44,7 @@ One particular area of layer 2 that requires more research and development is sa
[Blockchain Bridges article](https://medium.com/1kxnetwork/blockchain-bridges-5db6afac44f8)
-#### Recent Research
+#### Recent research
[Validating bridges](https://stonecoldpat.github.io/images/validatingbridges.pdf)
@@ -53,7 +53,7 @@ One particular area of layer 2 that requires more research and development is sa
Sharding Ethereum's blockchain has long been part of the development roadmap. However, new scaling solutions such as "Danksharding" are currently taking center stage.
-#### Background Reading
+#### Background reading
[Introduction to Ethereum sharding](/upgrades/shard-chains/)
@@ -65,19 +65,19 @@ Sharding Ethereum's blockchain has long been part of the development roadmap. Ho
[Danksharding (Polynya)](https://polynya.medium.com/danksharding-36dc0c8067fe)
-#### Recent Research
+#### Recent research
### Hardware
[Running nodes](/developers/docs/nodes-and-clients/run-a-node/) on modest hardware is fundamental to keeping Ethereum decentralized. Therefore, active research into minimizing the hardware requirements to run nodes is an important area of research.
-#### Background Reading
+#### Background reading
[Ethereum on ARM](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/)
-#### Recent Research
+#### Recent research
## Security
@@ -86,9 +86,9 @@ Security is a broad topic that might include spam/scam prevention, wallet securi
### Cryptography & ZKP
-Zero-knowledge proofs (ZKP) and cryptography are critical for building privacy and security into Ethereum and its applications. Zero-knowledge is a relatively young but fast-moving space with many open research and development opportunities.
+Zero-knowledge proofs (ZKP) and cryptography are critical for building privacy and security into Ethereum and its applications. Zero-knowledge is a relatively young but fast-moving space with many open research and development opportunities. Some possibilities include developing more efficient implementations of the [Keccak hashing algorithm](https://hackmd.io/sK7v0lr8Txi1bgION1rRpw?view#Overview), finding better polynomial commitments than currently exist or reducing the cost of ecdsa public key generation and signature verification circuits.
-#### Background Reading
+#### Background reading
[0xparc blog](https://0xparc.org/blog)
@@ -97,8 +97,9 @@ Zero-knowledge proofs (ZKP) and cryptography are critical for building privacy a
[Zero Knowledge podcast](https://zeroknowledge.fm/)
-#### Recent Research
+#### Recent research
+[Recent advance in elliptic curve cryptography](https://ethresear.ch/t/the-ec-fft-algorithm-without-elliptic-curve-and-isogenies/11346)
[Ethresear.ch ZK](https://ethresear.ch/c/zk-s-nt-arks/13)
@@ -107,7 +108,7 @@ Zero-knowledge proofs (ZKP) and cryptography are critical for building privacy a
User-wallets can be browser extensions, desktop and mobile apps or smart contracts on Ethereum. There is active research into social recovery wallets that reduce some of the risk associated with individual-user key management. Associated with dveelopment of wallets is research into alternative forms of account abstraction, which is an important area of nascent research.
-#### Background Reading
+#### Background reading
[Our Security page](https://ethereum.org/en/security/)
@@ -118,10 +119,10 @@ User-wallets can be browser extensions, desktop and mobile apps or smart contrac
[EIP 4337 Account Abstraction](https://eips.ethereum.org/EIPS/eip-4337)
-#### Recent Research
+#### Recent research
-## Community, Education and Outreach
+## Community, education and outreach
Onboarding new users onto Ethereum requires new educational resources and approaches to outreach. This might include blog posts and articles, books, podcasts, memes, teaching resources events and anything else that builds communities, welcomes new starters and educates people about Ethereum.
@@ -129,27 +130,27 @@ Onboarding new users onto Ethereum requires new educational resources and approa
For Ethereum to onboard more people the UX/UI must be improved. This requires designers and UI and product experts to re-examine the design of wallets and apps.
-#### Background Reading
+#### Background reading
[Ethresear.ch UX/UI](https://ethresear.ch/c/ui-ux/24)
[Ethereum.org community page](https://ethereum.org/en/learn/)
-#### Recent Research
+#### Recent research
## Economics
There are complex crypto-economic factors relating to Ethereum's native asset (ether) and the tokens built on top of it (for example NFTs and ERC20 tokens).
-#### Background Reading
+#### Background reading
[Rollup economics from first principles](https://barnabe.substack.com/p/understanding-rollup-economics-from?utm_source=url)
[Robust Incentives Group](https://ethereum.github.io/rig/)
-#### Recent Research
+#### Recent research
[Empirical analysis of EIP1559]([https://arxiv.org/abs/2110.04753)
@@ -165,68 +166,77 @@ There are complex crypto-economic factors relating to Ethereum's native asset (e
When Ethereum transitions to proof of stake, its native asset (ether) will be used as collateral by validators. The cryptoeconomics of this
-#### Background Reading
+#### Background reading
[Robist Incentives Group: PoS incentives](https://ethereum.github.io/beaconrunner/)
-#### Recent Research
+#### Recent research
### Liquid staking and derivatives
Liquid staking allows users with less than 32 ETH to receive staking yields by swapping ether for a token representing staked ether that can be used in DeFi. However, the incentives and market dynamics associated with liquid staking as well as its effect on Ethereum's security (e.g. centralization risks, )
-#### Background Reading
+#### Background reading
[Ethresear.ch liquid staking](https://ethresear.ch/search?q=liquid%20staking)
-#### Recent Research
+#### Recent research
### DeFi
Decentralized finance (DeFi) is one of the primary classes of application built on top of Ethereum. DeFi aims to create composable "money legos" that allow users to store, transfer, lend, borrow and and invest crypto-assets using smart contracts. This is a fast-moving space that is constantly updating. Research into secure, efficient and accessible protocols is constantly needed.
-#### Background Reading
+#### Background reading
[DeFi](https://ethereum.org/en/defi/)
[Coinbase: What is DeFi?](https://www.coinbase.com/learn/crypto-basics/what-is-defi)
-#### Recent Research
+#### Recent research
### Fee markets
Ethereum transaction fees protect the network from spam, denial-of-service attacks and bad smart-contract code. However, it also affects the end-user by influencing the cost of interacting with Ethereum. Balancing network security with end-user user-experience is an ongoing challenge that requires further research and development.
-#### Background Reading
+#### Background reading
[EIP 1559 (Robust Incentives Group)](https://ethereum.github.io/abm1559/notebooks/eip1559.html)
-#### Recent Research
+#### Recent research
### Taxation and accounting
Crypto taxation is a complicated issue that likely requires a software solution. There are some nascent crypto accounting project but this area requires much more attention.
-#### Background Reading
+#### Background reading
-#### Recent Research
+#### Recent research
[Example of taxation and accounting research: Cumming et al. 2019](https://www.mdpi.com/1911-8074/12/3/126)
-## Clients and Protocol Development
+## Clients and protocol research
-### Consensus Clients
+### Consensus clients
-The consensus layer is concerned with the proof-of-stake mechanism securing Ethereum from the merge onwards. There is abundant ongoing research and development relating to PoS concepts and implementation, for example identifying and patching vulnerabilities, quantifying cryptoeconomic security, increasing the security or performance of client implementations, building light clients and developing staking apps.
+The consensus layer is concerned with the proof-of-stake mechanism securing Ethereum from the merge onwards. There is abundant ongoing research and development relating to PoS concepts and implementation, for example identifying and patching vulnerabilities, quantifying cryptoeconomic security, increasing the security or performance of client implementations, building light clients and developing staking apps. Some fundamental redesigns of the protocol to confer large improvements to Ethereum are also being researched, for example single slot finality.
-#### Background Reading
+#### Background reading
+
+[Casper-FFG paper](https://arxiv.org/abs/1710.09437)
+
+[Casper-FFG Explainer](https://arxiv.org/abs/1710.09437)
+
+[Gasper paper](https://arxiv.org/abs/2003.03052)
+
+
+##### Client implementations
[Prysm client](https://docs.prylabs.network/docs/how-prysm-works/beacon-node/)
@@ -238,15 +248,27 @@ The consensus layer is concerned with the proof-of-stake mechanism securing Ethe
[Nimbus client](https://nimbus.team/)
+
+#### Recent research
+
[Ethresear.ch Consensus](https://ethresear.ch/c/consensus/29)
-#### Recent Research
+[Three Attacks on PoS Ethereum](https://arxiv.org/abs/2110.10086)
+
+[Low-cost attacks on Ethereum 2.0 by sub 1/3 stakeholders](https://arxiv.org/abs/2102.02247)
+
+[Availability/Finality dilemma](https://arxiv.org/abs/2009.04987)
+
+[Single slot finality](https://ethresear.ch/t/a-model-for-cumulative-committee-based-finality/10259)
-### Execution Clients
+
+### Execution clients
The execution layer is concerned with executing transactions, running the EVM and generating execution payloads to pass to the consensus layer. There are many active areas of research, especially as execution clients are updated ready for the merge. This includes building out light client support, research into gas limits and incorporating new data structures (e.g. Verkle Tries).
-#### Background Reading
+#### Background reading
+
+#### Client implementations
[Geth client](geth.ethereum.org)
@@ -256,53 +278,67 @@ The execution layer is concerned with executing transactions, running the EVM an
[Erigon client](https://github.com/ledgerwatch/erigon)
-#### Recent Research
+#### Recent research
+
+### Formal verification
+
+Formal verification is writing code to verify that Ethereum's consensus specifications are correct and bug-free. There is an executable version of the specification written in Python that requires maintenance and development. Further research can help to improve the Python implementation of the specification and add tools that can more robustly verify correctness and identify issues.
+
+#### Background reading
+
+#### Recent research
+
+[Formal verification of the deposit contract](https://github.com/runtimeverification/deposit-contract-verification)
+
+[Formal verification of the Beacon Chain specification](https://github.com/runtimeverification/deposit-contract-verification)
+
+
-### Data Science and Analytics
+### Data science and analytics
There is a need for more data analysis tools and dashboards that give detailed information about activity on Ethereum and the health of the network.
-### Background Reading
+### Background reading
[Dune Analytics](https://dune.com/browse/dashboards)
[Client diversity dashboard](https://clientdiversity.org/)
-#### Recent Research
+#### Recent research
-## Apps and Tooling
+## Apps and tooling
### DAOs
DAOs are one of the key classes of application being built on top of Ethereum. There is a lot of very active research into how they may develop to replace corporations and other traditional organizations.
-#### Background Reading
+#### Background reading
[Dao Collective](https://daocollective.xyz/)
-#### Recent Research
+#### Recent research
### Developer tools
Tools for Ethereum developers are rapidly improving. There is lots of active research and development to do in this general area.
-#### Background Reading
+#### Background reading
[Developer Frameworks](https://ethereum.org/en/developers/docs/frameworks/)
[Consensus developer tools list](https://github.com/ConsenSys/ethereum-developer-tools-list)
-#### Recent Research
+#### Recent research
### App security
Hacks on Ethereum nearly always exploit vulnerabilities in individual applications rather than the base protocol. Hackers and app developers are locked in an arms race to develop new attacks and defenses. This means there is always important research and development required to keep apps safe from hacks.
-#### Background Reading
+#### Background reading
-#### Recent Research
+#### Recent research
[ethresear.ch Applications](https://ethresear.ch/c/applications/18)
@@ -311,19 +347,19 @@ Hacks on Ethereum nearly always exploit vulnerabilities in individual applicatio
Apps on Ethereum are rarely fully decentralized because they rely on some centralized tooling or infrastructure. Decentralizing the full tech stack is an important research area.
-#### Background Reading
+#### Background reading
[Coinbase: Intro to Web3 Stack](https://blog.coinbase.com/a-simple-guide-to-the-web3-stack-785240e557f0)
-#### Recent Research
+#### Recent research
### Composability
Composability is the ability for different apps to work in parallel or on top of one another so that users are not locked-in to specific protocols. This is something that requires best-practices in interoperability and data standards. This is an area that would benefit from more ongoing research and development.
-#### Background Reading
+#### Background reading
[Smart contract composability](https://ethereum.org/en/developers/docs/smart-contracts/composability/)
-#### Recent Research
+#### Recent research
From c895a2f5d594e52d219d9aad906a36688d83bd54 Mon Sep 17 00:00:00 2001
From: Pablo Pettinari
Date: Wed, 25 May 2022 14:34:38 -0300
Subject: [PATCH 077/298] add typescript doc
---
docs/typescript.md | 92 ++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 92 insertions(+)
create mode 100644 docs/typescript.md
diff --git a/docs/typescript.md b/docs/typescript.md
new file mode 100644
index 00000000000..26fe1c46d64
--- /dev/null
+++ b/docs/typescript.md
@@ -0,0 +1,92 @@
+# Typescript
+
+## General considerations
+
+As we are progressively migrating the entire codebase to TS, we will have a mix of `.js` and `.ts` files in the process. For this reason and to make the migration easier for beginners, we have disabled the [`noImplicitAny`](https://www.typescriptlang.org/tsconfig#noImplicitAny) option from our `tsconfig.json` which means that you can use the `any` type and you will not get an error from that.
+When we reach the moment where the entire codebase is in TS, we will enable `noImplicitAny` and increase the checker’s strictness.
+
+This is just starting, any suggestion is always welcomed and appreciated.
+
+## Migration guide & contribution opportunity 🎉
+
+1. Run `yarn start` to generate the `src/gatsby-types.d.ts` file. More on this in the "GraphQL Typegen" section.
+2. Convert the js file into a `.ts` or `.tsx` file in case the file includes some jsx in it.
+3. Try to follow one already migrated file similar to the one you are migrating.
+
+ - For `pages`,
+
+ - Run again `yarn start` in order to update the `src/gatsby-types.d.ts` file with the page's query type.
+ - Use the Gatsby type `PageProps`, passing the generated GraphQL query type + the context type args.
+
+ ```tsx
+ import { graphql, PageProps } from "gatsby"
+ import type { Context } from "src/types"
+
+ const HomePage = ({}: PageProps) => {
+ ...
+ }
+ export const query = graphql`
+ query HomePage {
+ ...
+ }
+ `
+ ```
+
+ - Always name your queries.
+
+ ```tsx
+ // BAD
+ query {
+ ...
+ }
+
+ // GOOD
+ query MyQuery {
+ ...
+ }
+ ```
+
+ - For `components`,
+
+ - Use `React.FC` prop on function components.
+ - As a convention, define the component's props types as an interface with the name `IProps`.
+ - As a convention, export `IProps`.
+
+ ```tsx
+ import React from "react"
+
+ export interface IProps {
+ coolProp: string
+ }
+
+ const Component: React.FC = ({ coolProp }) => {
+ ...
+ }
+ ```
+
+ - In case you need to extend your component with some other component's interface, import the latter with the following naming convention `I{NameOfTheComponent}Props`.
+
+ ```tsx
+ import Link, { IProps as ILinkProps } from "./Link"
+
+ export interface IProps extends ILinkProps {
+ newCoolProp: string
+ }
+ ```
+
+4. Try to avoid as much as possible the usage of `any` :)
+
+## GraphQL Typegen
+
+With the release of Gatsby v4.15.0, [the config option `graphqlTypegen` has been added](https://www.gatsbyjs.com/docs/reference/release-notes/v4.15/#graphql-typegen).
+
+- This will generate automatically a `src/gatsby-types.d.ts` file which will contain all the GraphQL query types on the codebase.
+- This will happen in build time. In other words, when you call `yarn start` or `yarn build`.
+- Once you have that file created, a global `Queries` variable will be available which will contain all the query types.
+- More information about how this works https://www.gatsbyjs.com/docs/how-to/local-development/graphql-typegen/
+
+## Other resources
+
+- [Official Gatsby Typescript guide](https://www.gatsbyjs.com/docs/how-to/custom-configuration/typescript/)
+- [Official Typescript website](https://www.typescriptlang.org/)
+- [GraphQL Typegen](https://www.gatsbyjs.com/docs/how-to/local-development/graphql-typegen/)
From 362719d6a16da18ceda560f5def98d592e827a9c Mon Sep 17 00:00:00 2001
From: Pablo Pettinari
Date: Wed, 25 May 2022 22:25:06 -0300
Subject: [PATCH 078/298] add more resources
---
docs/typescript.md | 1 +
1 file changed, 1 insertion(+)
diff --git a/docs/typescript.md b/docs/typescript.md
index 26fe1c46d64..6ba6ffc5c41 100644
--- a/docs/typescript.md
+++ b/docs/typescript.md
@@ -90,3 +90,4 @@ With the release of Gatsby v4.15.0, [the config option `graphqlTypegen` has been
- [Official Gatsby Typescript guide](https://www.gatsbyjs.com/docs/how-to/custom-configuration/typescript/)
- [Official Typescript website](https://www.typescriptlang.org/)
- [GraphQL Typegen](https://www.gatsbyjs.com/docs/how-to/local-development/graphql-typegen/)
+- [Typescript Challenges](https://github.com/type-challenges/type-challenges)
From 69840b1ddbaa75da5f26f3dffa05103161f46ffc Mon Sep 17 00:00:00 2001
From: Joseph Cook <33655003+jmcook1186@users.noreply.github.com>
Date: Thu, 26 May 2022 10:45:32 +0100
Subject: [PATCH 079/298] add links to execution layer
---
.../get-involved/open-research/index.md | 23 ++++++++++++++++---
1 file changed, 20 insertions(+), 3 deletions(-)
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
index 8b8ba09987f..7562ce3d931 100644
--- a/src/content/community/get-involved/open-research/index.md
+++ b/src/content/community/get-involved/open-research/index.md
@@ -114,13 +114,21 @@ User-wallets can be browser extensions, desktop and mobile apps or smart contrac
[ethresear.ch Security](https://ethresear.ch/tag/security)
-[EIP 2938 Account Abstraction](https://eips.ethereum.org/EIPS/eip-2938)
+[EIP-2938 Account Abstraction](https://eips.ethereum.org/EIPS/eip-2938)
-[EIP 4337 Account Abstraction](https://eips.ethereum.org/EIPS/eip-4337)
+[EIP-4337 Account Abstraction](https://eips.ethereum.org/EIPS/eip-4337)
#### Recent research
+[Validation focussed smart contract wallets](https://ethereum-magicians.org/t/validation-focused-smart-contract-wallets/6603)
+
+[The future of accounts](https://ethereum-magicians.org/t/validation-focused-smart-contract-wallets/6603)
+
+[EIP-3074](https://eips.ethereum.org/EIPS/eip-3074)
+
+[Publishing code code at EOA addresses](https://github.com/ethereum/EIPs/pull/5003)
+
## Community, education and outreach
@@ -204,7 +212,7 @@ Ethereum transaction fees protect the network from spam, denial-of-service attac
#### Background reading
-[EIP 1559 (Robust Incentives Group)](https://ethereum.github.io/abm1559/notebooks/eip1559.html)
+[EIP-1559 (Robust Incentives Group)](https://ethereum.github.io/abm1559/notebooks/eip1559.html)
#### Recent research
@@ -280,6 +288,13 @@ The execution layer is concerned with executing transactions, running the EVM an
#### Recent research
+[Database optimizations](https://github.com/ledgerwatch/erigon/blob/devel/docs/programmers_guide/db_faq.md)
+
+[State expiry](https://notes.ethereum.org/@vbuterin/state_expiry_eip)
+
+[History management](https://eips.ethereum.org/EIPS/eip-4444)
+
+
### Formal verification
Formal verification is writing code to verify that Ethereum's consensus specifications are correct and bug-free. There is an executable version of the specification written in Python that requires maintenance and development. Further research can help to improve the Python implementation of the specification and add tools that can more robustly verify correctness and identify issues.
@@ -319,6 +334,8 @@ DAOs are one of the key classes of application being built on top of Ethereum. T
#### Recent research
+[Mapping the DAO ecosystem](https://www.researchgate.net/publication/358694594_Mapping_out_the_DAO_Ecosystem_and_Assessing_DAO_Autonomy)
+
### Developer tools
Tools for Ethereum developers are rapidly improving. There is lots of active research and development to do in this general area.
From 5048bd41bdf23bd9b4d23671443774c3b8f1cb03 Mon Sep 17 00:00:00 2001
From: Joseph Cook <33655003+jmcook1186@users.noreply.github.com>
Date: Thu, 26 May 2022 12:09:27 +0100
Subject: [PATCH 080/298] add CL p2p info & links to formal verif. reading
---
.../community/get-involved/open-research/index.md | 11 +++++++++--
1 file changed, 9 insertions(+), 2 deletions(-)
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
index 7562ce3d931..62daa3b1ec4 100644
--- a/src/content/community/get-involved/open-research/index.md
+++ b/src/content/community/get-involved/open-research/index.md
@@ -233,7 +233,7 @@ Crypto taxation is a complicated issue that likely requires a software solution.
### Consensus clients
-The consensus layer is concerned with the proof-of-stake mechanism securing Ethereum from the merge onwards. There is abundant ongoing research and development relating to PoS concepts and implementation, for example identifying and patching vulnerabilities, quantifying cryptoeconomic security, increasing the security or performance of client implementations, building light clients and developing staking apps. Some fundamental redesigns of the protocol to confer large improvements to Ethereum are also being researched, for example single slot finality.
+The consensus layer is concerned with the proof-of-stake mechanism securing Ethereum from the merge onwards. There is abundant ongoing research and development relating to PoS concepts and implementation, for example identifying and patching vulnerabilities, quantifying cryptoeconomic security, increasing the security or performance of client implementations, building light clients and developing staking apps. Some fundamental redesigns of the protocol to confer large improvements to Ethereum are also being researched, for example single slot finality. Furthermore, the efficiency and safety and monitoring of the peer-to-peer networking between consensus clients are also important research topics.
#### Background reading
@@ -272,10 +272,12 @@ The consensus layer is concerned with the proof-of-stake mechanism securing Ethe
### Execution clients
-The execution layer is concerned with executing transactions, running the EVM and generating execution payloads to pass to the consensus layer. There are many active areas of research, especially as execution clients are updated ready for the merge. This includes building out light client support, research into gas limits and incorporating new data structures (e.g. Verkle Tries).
+The execution layer is concerned with executing transactions, running the EVM and generating execution payloads to pass to the consensus layer. There are many active areas of research, especially as execution clients are updated ready for the merge. This includes building out light client support, research into gas limits and incorporating new data structures (e.g. Verkle Tries).
#### Background reading
+[Nodes and Clients](https://ethereum.org/developers/docs/nodes-and-clients)
+
#### Client implementations
[Geth client](geth.ethereum.org)
@@ -301,6 +303,11 @@ Formal verification is writing code to verify that Ethereum's consensus specific
#### Background reading
+[Introduction to formal verification](https://ptolemy.berkeley.edu/projects/embedded/research/vis/doc/VisUser/vis_user/node4.html)
+
+[Formal Verification (Intel)](https://www.cl.cam.ac.uk/~jrh13/papers/mark10.pdf)
+
+
#### Recent research
[Formal verification of the deposit contract](https://github.com/runtimeverification/deposit-contract-verification)
From 9a0ac4c17e31fd18b7be7d1c660c5b1938398259 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 09:29:29 -0600
Subject: [PATCH 081/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 5eef3340fb2..fb9c25195b8 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -173,7 +173,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
### Support
-**Does the wallet have a person the ethereum.org team can contact regarding the wallet in future?**
+**Who can the ethereum.org team can contact regarding the wallet in future?**
From d26024eaf2224337132c9f3bc5debbf5245e3bf0 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 09:29:36 -0600
Subject: [PATCH 082/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index fb9c25195b8..f0b19c328d9 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -178,7 +178,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
-**Does your wallet have a dedicated support team?**
+**Does the wallet have a dedicated support team?**
From b2069603b38d6052517ea974a3883de0efea54cd Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 09:29:46 -0600
Subject: [PATCH 083/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index f0b19c328d9..fc7e6556107 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -181,7 +181,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
**Does the wallet have a dedicated support team?**
-
+
**What educational resources/documentation do you provide to users?**
From 23bfea0b2d3caf562af741923c574b09f1323c44 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 09:29:53 -0600
Subject: [PATCH 084/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index fc7e6556107..a4e633e74bf 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -95,7 +95,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
**Please describe the measures taken to ensure the wallet's security and provide documentation wherever possible**
-
+
**Spam protection?**
From cba7469fd62080c902878d2a06137fa55f39096a Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 09:30:02 -0600
Subject: [PATCH 085/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index a4e633e74bf..114a80c331e 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -91,7 +91,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
-
+
**Please describe the measures taken to ensure the wallet's security and provide documentation wherever possible**
From fdf119dc81f1339b1a4fd6d5c90701f99cdb92dd Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 09:41:28 -0600
Subject: [PATCH 086/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 114a80c331e..0533dc11d3a 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -47,7 +47,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
-**Is your wallet globally accessible?**
+**Is the wallet globally accessible?**
From c1f887637647e0696519b49aa38ea3f76e5faa11 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 09:41:37 -0600
Subject: [PATCH 087/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 0533dc11d3a..6dab3a51b6f 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -49,7 +49,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
**Is the wallet globally accessible?**
-
+
**Is the wallet available in multiple languages?**
From 0c0b6a32a4a5d4de573eb9850831537741b0da3c Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 09:41:50 -0600
Subject: [PATCH 088/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 6dab3a51b6f..342768c5dc8 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -43,7 +43,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
-**Does your wallet have an active development team?**
+**Does the wallet have an active development team?**
From a557f4272ae0026c06213fa2085f78b00bc4640e Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 09:42:00 -0600
Subject: [PATCH 089/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 342768c5dc8..09377c3cc64 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -39,7 +39,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
-**When did your wallet go live to users?**
+**When did the wallet go live to users?**
From b4b5654fc3486acd713f5e8fa1c8f05c1222a02a Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 09:42:14 -0600
Subject: [PATCH 090/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 09377c3cc64..f14fee53e6c 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -6,7 +6,7 @@ labels: "wallet :purse:,"
assignees: ""
---
-Before suggesting a wallet, make sure you've read [our listing policy](https://www.ethereum.org/en/contributing/adding-products/). Only continue with the issue if your wallet meets the criteria listed there.
+Before suggesting a wallet, make sure you've read [our listing policy](https://www.ethereum.org/en/contributing/adding-products/). Only continue with the issue if the wallet meets the criteria listed there.
### Project info
From c1de7a780a0e2f6a3c8ad582fc5e7ac40f51a4cf Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 09:42:21 -0600
Subject: [PATCH 091/298] Update .github/ISSUE_TEMPLATE/suggest_wallet.md
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index f14fee53e6c..6275a36f884 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -37,7 +37,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
**Is the wallet security tested? Please explain security measures i.e. security audit, internal security team, or some other method.**
-
+
**When did the wallet go live to users?**
From 5f0bb73d2705de92215ea00c517a2a40e67c4982 Mon Sep 17 00:00:00 2001
From: Pablo Pettinari
Date: Thu, 26 May 2022 16:43:14 -0300
Subject: [PATCH 092/298] templates migration to ts
---
gatsby-node.ts | 4 +-
package.json | 2 +
src/templates/{docs.js => docs.tsx} | 31 ++++++++-----
src/templates/{job.js => job.tsx} | 29 ++++++------
src/templates/{staking.js => staking.tsx} | 39 +++++++---------
src/templates/{static.js => static.tsx} | 44 +++++++++++++------
src/templates/{tutorial.js => tutorial.tsx} | 43 +++++++++++-------
src/templates/{upgrade.js => upgrade.tsx} | 41 +++++++++++------
src/templates/{use-cases.js => use-cases.tsx} | 36 ++++++++-------
src/utils/getSummaryPoints.js | 11 -----
src/utils/getSummaryPoints.ts | 20 +++++++++
src/utils/{time.js => time.ts} | 3 +-
yarn.lock | 12 +++++
13 files changed, 192 insertions(+), 123 deletions(-)
rename src/templates/{docs.js => docs.tsx} (91%)
rename src/templates/{job.js => job.tsx} (95%)
rename src/templates/{staking.js => staking.tsx} (94%)
rename src/templates/{static.js => static.tsx} (84%)
rename src/templates/{tutorial.js => tutorial.tsx} (83%)
rename src/templates/{upgrade.js => upgrade.tsx} (92%)
rename src/templates/{use-cases.js => use-cases.tsx} (95%)
delete mode 100644 src/utils/getSummaryPoints.js
create mode 100644 src/utils/getSummaryPoints.ts
rename src/utils/{time.js => time.ts} (79%)
diff --git a/gatsby-node.ts b/gatsby-node.ts
index 7f465a03eed..fcf458cdd28 100644
--- a/gatsby-node.ts
+++ b/gatsby-node.ts
@@ -271,7 +271,7 @@ export const createPages: GatsbyNode["createPages"] = async ({
const langSlug = splitSlug.join("/")
createPage({
path: langSlug,
- component: path.resolve(`src/templates/${template}.js`),
+ component: path.resolve(`src/templates/${template}.tsx`),
context: {
slug: langSlug,
ignoreTranslationBanner: isLegal,
@@ -298,7 +298,7 @@ export const createPages: GatsbyNode["createPages"] = async ({
createPage({
path: slug,
- component: path.resolve(`src/templates/${template}.js`),
+ component: path.resolve(`src/templates/${template}.tsx`),
context: {
language,
slug,
diff --git a/package.json b/package.json
index 5d097fe1843..ad354a6c80c 100644
--- a/package.json
+++ b/package.json
@@ -67,6 +67,8 @@
},
"devDependencies": {
"@netlify/functions": "^1.0.0",
+ "@types/luxon": "^2.3.2",
+ "@types/mdx-js__react": "^1.5.5",
"@types/node": "^17.0.23",
"@types/react": "^17.0.39",
"@types/react-dom": "^17.0.11",
diff --git a/src/templates/docs.js b/src/templates/docs.tsx
similarity index 91%
rename from src/templates/docs.js
rename to src/templates/docs.tsx
index 05c40fd534b..a8de7f4f260 100644
--- a/src/templates/docs.js
+++ b/src/templates/docs.tsx
@@ -1,6 +1,5 @@
import React, { useContext } from "react"
-import { graphql } from "gatsby"
-import { useIntl } from "gatsby-plugin-intl"
+import { graphql, PageProps } from "gatsby"
import { MDXProvider } from "@mdx-js/react"
import { MDXRenderer } from "gatsby-plugin-mdx"
import styled from "styled-components"
@@ -25,10 +24,6 @@ import DocsNav from "../components/DocsNav"
import DeveloperDocsLinks from "../components/DeveloperDocsLinks"
import RollupProductDevDoc from "../components/RollupProductDevDoc"
import YouTube from "../components/YouTube"
-
-import { ZenModeContext } from "../contexts/ZenModeContext.js"
-
-import { isLangRightToLeft } from "../utils/translations"
import {
Divider,
Paragraph,
@@ -39,6 +34,11 @@ import {
ListItem,
} from "../components/SharedStyledComponents"
+import { ZenModeContext } from "../contexts/ZenModeContext.js"
+import { isLangRightToLeft } from "../utils/translations"
+import { Lang } from "../utils/languages"
+import { Context } from "../types"
+
const Page = styled.div`
display: flex;
flex-direction: column;
@@ -46,7 +46,7 @@ const Page = styled.div`
border-bottom: 1px solid ${(props) => props.theme.colors.border};
`
-const ContentContainer = styled.div`
+const ContentContainer = styled.div<{ isZenMode: boolean }>`
display: flex;
justify-content: ${(props) => (props.isZenMode ? "center" : "space-between")};
width: 100%;
@@ -165,15 +165,22 @@ const Contributors = styled(FileContributors)`
}
`
-const DocsPage = ({ data, pageContext }) => {
+const DocsPage = ({
+ data: { siteData, pageData: mdx },
+ pageContext,
+}: PageProps) => {
const { isZenMode } = useContext(ZenModeContext)
- const mdx = data.pageData
- const isRightToLeft = isLangRightToLeft(mdx.frontmatter.lang)
- const tocItems = mdx.tableOfContents.items
+ if (!siteData || !mdx?.frontmatter) {
+ throw new Error("Docs page template query does not return expected values")
+ }
+
+ const isRightToLeft = isLangRightToLeft(mdx.frontmatter.lang as Lang)
+
+ const tocItems = mdx.tableOfContents?.items
const isPageIncomplete = mdx.frontmatter.incomplete
- const { editContentUrl } = data.siteData.siteMetadata
+ const { editContentUrl } = siteData.siteMetadata || {}
const { relativePath, slug } = pageContext
const absoluteEditPath = `${editContentUrl}${relativePath}`
diff --git a/src/templates/job.js b/src/templates/job.tsx
similarity index 95%
rename from src/templates/job.js
rename to src/templates/job.tsx
index 5ae84c3ea37..a42a4a53522 100644
--- a/src/templates/job.js
+++ b/src/templates/job.tsx
@@ -1,9 +1,10 @@
import React from "react"
-import { graphql } from "gatsby"
+import { graphql, PageProps } from "gatsby"
import { MDXProvider } from "@mdx-js/react"
import { MDXRenderer } from "gatsby-plugin-mdx"
import styled from "styled-components"
import { GatsbyImage, getImage } from "gatsby-plugin-image"
+
import ButtonLink from "../components/ButtonLink"
import Link from "../components/Link"
import PageMetadata from "../components/PageMetadata"
@@ -15,6 +16,8 @@ import {
ListItem,
} from "../components/SharedStyledComponents"
+import { Context } from "../types"
+
const Page = styled.div`
display: flex;
justify-content: space-between;
@@ -307,7 +310,13 @@ const StyledLink = styled(Link)`
}
`
-const JobPage = ({ data: { mdx } }) => {
+const JobPage = ({
+ data: { mdx },
+}: PageProps) => {
+ if (!mdx?.frontmatter) {
+ throw new Error("Job page template query does not return expected values")
+ }
+
return (
@@ -369,7 +378,7 @@ const JobPage = ({ data: { mdx } }) => {
Back to jobs
-
+
Apply for job
@@ -378,7 +387,7 @@ const JobPage = ({ data: { mdx } }) => {
Back to jobs
- Apply for job
+ Apply for job
@@ -388,9 +397,6 @@ const JobPage = ({ data: { mdx } }) => {
export const JobQuery = graphql`
query JobPage($relativePath: String) {
mdx(fields: { relativePath: { eq: $relativePath } }) {
- fields {
- slug
- }
frontmatter {
title
description
@@ -408,15 +414,6 @@ export const JobQuery = graphql`
}
}
body
- tableOfContents
- parent {
- ... on File {
- mtime
- fields {
- gitLogLatestDate
- }
- }
- }
}
}
`
diff --git a/src/templates/staking.js b/src/templates/staking.tsx
similarity index 94%
rename from src/templates/staking.js
rename to src/templates/staking.tsx
index f66645e2f85..18a5d4866df 100644
--- a/src/templates/staking.js
+++ b/src/templates/staking.tsx
@@ -1,5 +1,5 @@
import React from "react"
-import { graphql } from "gatsby"
+import { graphql, PageProps } from "gatsby"
import { MDXRenderer } from "gatsby-plugin-mdx"
import { GatsbyImage, getImage } from "gatsby-plugin-image"
import { MDXProvider } from "@mdx-js/react"
@@ -45,6 +45,8 @@ import StakingCommunityCallout from "../components/Staking/StakingCommunityCallo
import StakingGuides from "../components/Staking/StakingGuides"
import { isLangRightToLeft } from "../utils/translations"
+import { Context } from "../types"
+import { Lang } from "../utils/languages"
const Page = styled.div`
display: flex;
@@ -338,15 +340,19 @@ const components = {
StakingGuides,
}
-const StakingPage = ({ data, pageContext, location }) => {
- const mdx = data.pageData
- const isRightToLeft = isLangRightToLeft(mdx.frontmatter.lang)
- const tocItems = mdx.tableOfContents.items
- const { summaryPoints } = mdx.frontmatter
+const StakingPage = ({
+ data: { pageData: mdx },
+ location,
+}: PageProps) => {
+ if (!mdx?.frontmatter) {
+ throw new Error(
+ "Staking page template query does not return expected values"
+ )
+ }
- // const { editContentUrl } = data.siteData.siteMetadata
- // const { relativePath } = pageContext
- // const absoluteEditPath = `${editContentUrl}${relativePath}`
+ const isRightToLeft = isLangRightToLeft(mdx.frontmatter.lang as Lang)
+ const tocItems = mdx.tableOfContents?.items
+ const { summaryPoints } = mdx.frontmatter
const dropdownLinks = {
text: "Staking Options",
@@ -398,7 +404,7 @@ const StakingPage = ({ data, pageContext, location }) => {
{mdx.frontmatter.title}
:{" "}
- {getLocaleTimestamp(intl.locale, lastUpdatedDate)}
+ {getLocaleTimestamp(intl.locale as Lang, lastUpdatedDate)}
diff --git a/src/templates/use-cases.js b/src/templates/use-cases.tsx
similarity index 95%
rename from src/templates/use-cases.js
rename to src/templates/use-cases.tsx
index 4fdc6f66c53..94acd16abe7 100644
--- a/src/templates/use-cases.js
+++ b/src/templates/use-cases.tsx
@@ -1,9 +1,10 @@
import React from "react"
-import { graphql } from "gatsby"
+import { graphql, PageProps } from "gatsby"
import { MDXProvider } from "@mdx-js/react"
import { MDXRenderer } from "gatsby-plugin-mdx"
import styled from "styled-components"
import { GatsbyImage, getImage } from "gatsby-plugin-image"
+
import ButtonLink from "../components/ButtonLink"
import ButtonDropdown from "../components/ButtonDropdown"
import BannerNotification from "../components/BannerNotification"
@@ -27,8 +28,6 @@ import TableOfContents from "../components/TableOfContents"
import TranslationsInProgress from "../components/TranslationsInProgress"
import Translation from "../components/Translation"
import SectionNav from "../components/SectionNav"
-import { isLangRightToLeft } from "../utils/translations"
-import { getSummaryPoints } from "../utils/getSummaryPoints"
import {
Divider,
Paragraph,
@@ -38,6 +37,11 @@ import {
import Emoji from "../components/Emoji"
import YouTube from "../components/YouTube"
+import { isLangRightToLeft } from "../utils/translations"
+import { getSummaryPoints } from "../utils/getSummaryPoints"
+import { Lang } from "../utils/languages"
+import { Context } from "../types"
+
const Page = styled.div`
display: flex;
justify-content: space-between;
@@ -291,13 +295,21 @@ const TitleCard = styled.div`
}
`
-const UseCasePage = ({ data, pageContext }) => {
- const mdx = data.pageData
- const isRightToLeft = isLangRightToLeft(mdx.frontmatter.lang)
- const tocItems = mdx.tableOfContents.items
+const UseCasePage = ({
+ data: { siteData, pageData: mdx },
+ pageContext,
+}: PageProps) => {
+ if (!siteData || !mdx?.frontmatter) {
+ throw new Error(
+ "UseCases page template query does not return expected values"
+ )
+ }
+
+ const isRightToLeft = isLangRightToLeft(mdx.frontmatter.lang as Lang)
+ const tocItems = mdx.tableOfContents?.items
const summaryPoints = getSummaryPoints(mdx.frontmatter)
- const { editContentUrl } = data.siteData.siteMetadata
+ const { editContentUrl } = siteData.siteMetadata || {}
const { relativePath } = pageContext
const absoluteEditPath = `${editContentUrl}${relativePath}`
@@ -429,14 +441,6 @@ export const useCasePageQuery = graphql`
}
body
tableOfContents
- parent {
- ... on File {
- mtime
- fields {
- gitLogLatestDate
- }
- }
- }
}
}
`
diff --git a/src/utils/getSummaryPoints.js b/src/utils/getSummaryPoints.js
deleted file mode 100644
index c19f9671bb6..00000000000
--- a/src/utils/getSummaryPoints.js
+++ /dev/null
@@ -1,11 +0,0 @@
-export const getSummaryPoints = (frontmatter, count = 4) => {
- // Place summary points into an array, guarding for `undefined` values
- let summaryPoints = []
- for (let i = 1; i <= count; i++) {
- const summaryPoint = frontmatter[`summaryPoint${i}`]
- if (summaryPoint) {
- summaryPoints.push(summaryPoint)
- }
- }
- return summaryPoints
-}
diff --git a/src/utils/getSummaryPoints.ts b/src/utils/getSummaryPoints.ts
new file mode 100644
index 00000000000..fc48514313e
--- /dev/null
+++ b/src/utils/getSummaryPoints.ts
@@ -0,0 +1,20 @@
+export const getSummaryPoints = (
+ frontmatter: Partial<
+ Pick<
+ Queries.Frontmatter,
+ "summaryPoint1" | "summaryPoint2" | "summaryPoint3" | "summaryPoint4"
+ >
+ >,
+ count = 4
+): Array => {
+ // Place summary points into an array, guarding for `undefined` values
+ let summaryPoints: Array = []
+ for (let i = 1; i <= count; i++) {
+ // @ts-ignore
+ const summaryPoint = frontmatter[`summaryPoint${i}`] as string
+ if (summaryPoint) {
+ summaryPoints.push(summaryPoint)
+ }
+ }
+ return summaryPoints
+}
diff --git a/src/utils/time.js b/src/utils/time.ts
similarity index 79%
rename from src/utils/time.js
rename to src/utils/time.ts
index e08422b047f..13a77fe71a9 100644
--- a/src/utils/time.js
+++ b/src/utils/time.ts
@@ -1,8 +1,9 @@
import { DateTime } from "luxon"
+import { Lang } from "./languages"
export const INVALID_DATETIME = "Invalid DateTime"
-export const getLocaleTimestamp = (locale, timestamp) => {
+export const getLocaleTimestamp = (locale: Lang, timestamp: string) => {
let localeTimestamp = DateTime.fromSQL(timestamp)
.setLocale(locale)
.toLocaleString(DateTime.DATE_FULL)
diff --git a/yarn.lock b/yarn.lock
index 5395915ba78..9372ca15c89 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -3769,6 +3769,11 @@
resolved "https://registry.yarnpkg.com/@types/lodash/-/lodash-4.14.178.tgz#341f6d2247db528d4a13ddbb374bcdc80406f4f8"
integrity sha512-0d5Wd09ItQWH1qFbEyQ7oTQ3GZrMfth5JkbN3EvTKLXcHLRDSXeLnlvlOn0wvxVIwK5o2M8JzP/OWz7T3NRsbw==
+"@types/luxon@^2.3.2":
+ version "2.3.2"
+ resolved "https://registry.yarnpkg.com/@types/luxon/-/luxon-2.3.2.tgz#8a3f2cdd4858ce698b56cd8597d9243b8e9d3c65"
+ integrity sha512-WOehptuhKIXukSUUkRgGbj2c997Uv/iUgYgII8U7XLJqq9W2oF0kQ6frEznRQbdurioz+L/cdaIm4GutTQfgmA==
+
"@types/mdast@^3.0.0", "@types/mdast@^3.0.3":
version "3.0.10"
resolved "https://registry.yarnpkg.com/@types/mdast/-/mdast-3.0.10.tgz#4724244a82a4598884cbbe9bcfd73dff927ee8af"
@@ -3776,6 +3781,13 @@
dependencies:
"@types/unist" "*"
+"@types/mdx-js__react@^1.5.5":
+ version "1.5.5"
+ resolved "https://registry.yarnpkg.com/@types/mdx-js__react/-/mdx-js__react-1.5.5.tgz#fa6daa1a28336d77b6cf071aacc7e497600de9ee"
+ integrity sha512-k8pnaP6JXVlQh18HgL5X6sYFNC/qZnzO7R2+HsmwrwUd+JnnsU0d9lyyT0RQrHg1anxDU36S98TI/fsGtmYqqg==
+ dependencies:
+ "@types/react" "*"
+
"@types/minimatch@*", "@types/minimatch@^3.0.3":
version "3.0.5"
resolved "https://registry.yarnpkg.com/@types/minimatch/-/minimatch-3.0.5.tgz#1001cc5e6a3704b83c236027e77f2f58ea010f40"
From 50db3ad7566a2e58cbc53e6831f30f6e717db81f Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 14:44:13 -0600
Subject: [PATCH 093/298] update tools titles
---
src/intl/en/page-layer-2.json | 6 ------
src/pages/layer-2.js | 12 ++++++------
2 files changed, 6 insertions(+), 12 deletions(-)
diff --git a/src/intl/en/page-layer-2.json b/src/intl/en/page-layer-2.json
index a1941acc5a8..a44b89949c1 100644
--- a/src/intl/en/page-layer-2.json
+++ b/src/intl/en/page-layer-2.json
@@ -83,17 +83,11 @@
"layer-2-withdrawals": "Withdrawals",
"layer-2-go-to": "Go to",
"layer-2-tools-title": "Tools to be effective on layer 2",
- "layer-2-tools-l2beat-title": "L2BEAT",
"layer-2-tools-l2beat-description": "L2BEAT is a great resource for looking at technical risk assessments of layer 2 projects. We recommend checking out their resources when researching specific layer 2 projects.",
- "layer-2-tools-l2fees-title": "L2 Fees",
"layer-2-tools-l2fees-description": "L2 Fees lets you see the current cost (denominated in USD) for doing transactions on different layer 2s.",
- "layer-2-tools-chainlist-title": "Chainlist",
"layer-2-tools-chainlist-description": "Chainlist is a great resource for importing network RPC's into supporting wallets. You will find RPC's for layer 2 projects here to help get you connected.",
- "layer-2-tools-zapper-title": "Zapper",
"layer-2-tools-zapper-description": "Manage your entire web3 portfolio from DeFi to NFTs and whatever comes next. Invest in the latest opportunities from one convenient place.",
- "layer-2-tools-zerion-title": "Zerion",
"layer-2-tools-zerion-description": "Build and manage your entire DeFi portfolio from one place. Discover the world of decentralized finance today.",
- "layer-2-tools-debank-title": "DeBank",
"layer-2-tools-debank-description": "Keep up with all the important happenings in the web3 world",
"layer-2-faq-title": "FAQ",
"layer-2-faq-question-1-title": "Why is there no 'official' Ethereum L2?",
diff --git a/src/pages/layer-2.js b/src/pages/layer-2.js
index a8e4b56f609..d229800a6b5 100644
--- a/src/pages/layer-2.js
+++ b/src/pages/layer-2.js
@@ -334,7 +334,7 @@ const Layer2Page = ({ data }) => {
const toolsData = {
information: [
{
- title: translateMessageId("layer-2-tools-l2beat-title", intl),
+ title: "L2BEAT",
description: translateMessageId(
"layer-2-tools-l2beat-description",
intl
@@ -344,7 +344,7 @@ const Layer2Page = ({ data }) => {
alt: "L2BEAT",
},
{
- title: translateMessageId("layer-2-tools-l2fees-title", intl),
+ title: "L2 Fees",
description: translateMessageId(
"layer-2-tools-l2fees-description",
intl
@@ -354,7 +354,7 @@ const Layer2Page = ({ data }) => {
alt: "L2 Fees",
},
{
- title: translateMessageId("layer-2-tools-chainlist-title", intl),
+ title: "Chainlist",
description: translateMessageId(
"layer-2-tools-chainlist-description",
intl
@@ -366,7 +366,7 @@ const Layer2Page = ({ data }) => {
],
walletManagers: [
{
- title: translateMessageId("layer-2-tools-zapper-title", intl),
+ title: "Zapper",
description: translateMessageId(
"layer-2-tools-zapper-description",
intl
@@ -376,7 +376,7 @@ const Layer2Page = ({ data }) => {
alt: "Zapper",
},
{
- title: translateMessageId("layer-2-tools-zerion-title", intl),
+ title: "Zerion",
description: translateMessageId(
"layer-2-tools-zerion-description",
intl
@@ -386,7 +386,7 @@ const Layer2Page = ({ data }) => {
alt: "Zerion",
},
{
- title: translateMessageId("layer-2-tools-debank-title", intl),
+ title: "DeBank",
description: translateMessageId(
"layer-2-tools-debank-description",
intl
From 2002de2e490ee43ebe05030858f19ed8036563bc Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 14:47:20 -0600
Subject: [PATCH 094/298] change requests
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 20 ++++++++++++++------
1 file changed, 14 insertions(+), 6 deletions(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
index 6275a36f884..0f3ec96532a 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.md
@@ -8,7 +8,6 @@ assignees: ""
Before suggesting a wallet, make sure you've read [our listing policy](https://www.ethereum.org/en/contributing/adding-products/). Only continue with the issue if the wallet meets the criteria listed there.
-
### Project info
**Wallet name**
@@ -35,10 +34,6 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
-**Is the wallet security tested? Please explain security measures i.e. security audit, internal security team, or some other method.**
-
-
-
**When did the wallet go live to users?**
@@ -97,6 +92,18 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
+**Has the wallet's smart contract code been audited?**
+
+
+
+**Does the wallet have an internal security team?**
+
+
+
+**Any other security testing that should be noted?**
+
+
+
**Spam protection?**
@@ -176,7 +183,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
**Who can the ethereum.org team can contact regarding the wallet in future?**
-
+
**Does the wallet have a dedicated support team?**
@@ -186,6 +193,7 @@ Before suggesting a wallet, make sure you've read [our listing policy](https://w
**What educational resources/documentation do you provide to users?**
+
### Extra
**Does the wallet have any integrated tools not mentioned above?**
From bec25f3a4ae74ce00959f40c2dda88a1c5e266e5 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 15:02:33 -0600
Subject: [PATCH 095/298] setup yaml
---
.github/ISSUE_TEMPLATE/suggest_wallet.yaml | 9 +++++++++
1 file changed, 9 insertions(+)
create mode 100644 .github/ISSUE_TEMPLATE/suggest_wallet.yaml
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
new file mode 100644
index 00000000000..9226a34df61
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
@@ -0,0 +1,9 @@
+name: Suggest a wallet
+about: Suggest a new wallet to list on ethereum.org
+title: ""
+labels: ["wallet :purse:,"]
+assignees: ""
+body:
+ - type: markdown
+ attributes:
+ value: Before suggesting a wallet, make sure you've read [our listing policy](https://www.ethereum.org/en/contributing/adding-products/). Only continue with the issue if the wallet meets the criteria listed there.
From f52c997d063ef869f21afb101c2f85b7266fcb31 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 15:09:51 -0600
Subject: [PATCH 096/298] test commit
---
.github/ISSUE_TEMPLATE/suggest_wallet.yaml | 16 ++++++++++++----
1 file changed, 12 insertions(+), 4 deletions(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
index 9226a34df61..b67f2af1515 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
@@ -1,9 +1,17 @@
name: Suggest a wallet
-about: Suggest a new wallet to list on ethereum.org
-title: ""
+description: Suggest a new wallet to list on ethereum.org
+title: Suggest a wallet
labels: ["wallet :purse:,"]
-assignees: ""
body:
- type: markdown
attributes:
- value: Before suggesting a wallet, make sure you've read [our listing policy](https://www.ethereum.org/en/contributing/adding-products/). Only continue with the issue if the wallet meets the criteria listed there.
+ value: |
+ Before suggesting a wallet, make sure you've read [our listing policy](https://www.ethereum.org/en/contributing/adding-products/). Only continue with the issue if the wallet meets the criteria listed there.
+ - type: input
+ id: contact
+ attributes:
+ label: Contact Details
+ description: How can we get in touch with you if we need more info?
+ placeholder: ex. email@example.com
+ validations:
+ required: false
From 778982dd6d351962dea79e86a8a01645a163a1d4 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 15:13:43 -0600
Subject: [PATCH 097/298] test
---
.github/ISSUE_TEMPLATE/suggest_wallet.yaml | 13 ++++++++-----
1 file changed, 8 insertions(+), 5 deletions(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
index b67f2af1515..a53e3a1586c 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
@@ -7,11 +7,14 @@ body:
attributes:
value: |
Before suggesting a wallet, make sure you've read [our listing policy](https://www.ethereum.org/en/contributing/adding-products/). Only continue with the issue if the wallet meets the criteria listed there.
- - type: input
+ - type: markdown
id: contact
attributes:
- label: Contact Details
- description: How can we get in touch with you if we need more info?
- placeholder: ex. email@example.com
+ value: "## Project info"
+ - type: input
+ id: wallet_name
+ attributes:
+ label: Wallet name
+ placeholder: Please provide the official name of the wallet
validations:
- required: false
+ required: true
From b615e9bb645332ec268b700aebaa6693816153ae Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 15:27:57 -0600
Subject: [PATCH 098/298] project info form
---
.github/ISSUE_TEMPLATE/suggest_wallet.yaml | 67 +++++++++++++++++++++-
1 file changed, 65 insertions(+), 2 deletions(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
index a53e3a1586c..ef620be96bb 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
@@ -1,7 +1,7 @@
name: Suggest a wallet
description: Suggest a new wallet to list on ethereum.org
title: Suggest a wallet
-labels: ["wallet :purse:,"]
+labels: ["wallet :purse:"]
body:
- type: markdown
attributes:
@@ -15,6 +15,69 @@ body:
id: wallet_name
attributes:
label: Wallet name
- placeholder: Please provide the official name of the wallet
+ description: Please provide the official name of the wallet.
+ validations:
+ required: true
+ - type: textarea
+ id: wallet_description
+ attributes:
+ label: Wallet description
+ description: Please provide a short 1-2 sentence description of the wallet. Avoid unsubstantiated marketing claims like “the best Ethereum wallet”.
+ validations:
+ required: true
+ - type: textarea
+ id: wallet_logo
+ attributes:
+ label: Wallet logo
+ description: |
+ Please provide an SVG or hi-res transparent PNG
+ Tip: You can attach images by clicking this area to highlight it and then dragging files in.
+ validations:
+ required: true
+ - type: input
+ id: wallet_background
+ attributes:
+ label: Background color for brand logo
+ description: Please provide a hex code for the brand color. This will be added to the background of the wallet card.
+ validations:
+ required: true
+ - type: input
+ id: wallet_url
+ attributes:
+ label: URL to the project
+ description: Please provide a URL (e.g. to the website of the wallet).
+ validations:
+ required: true
+ - type: input
+ id: wallet_live_date
+ attributes:
+ label: When did the wallet go live to users?
+ description: Please provide a date when the wallet was usable by the public
+ validations:
+ required: true
+ - type: input
+ id: wallet_active_development_team
+ attributes:
+ label: Does the wallet have an active development team?
+ description: Are developers actively working on the wallet? Provide proof that the wallet is actively being worked on (ex. GitHub repo link).
+ validations:
+ required: true
+ - type: input
+ id: wallet_globally_accessible
+ attributes:
+ label: Is the wallet globally accessible?
+ description: Please list any KYC requirements or geographic limitations of the wallet, if any exist.
+ validations:
+ required: true
+ - type: input
+ id: wallet_languages
+ attributes:
+ label: Is the wallet available in multiple languages?
+ description: Please list languages that the wallet actively supports.
+ - type: textarea
+ id: wallet_socials
+ attributes:
+ label: What social links are there for the project?
+ description: Please provide social links for the wallet (Discord, Twitter, etc.)
validations:
required: true
From 39d4a75f48d00d8bc04d9404a27d5f03c804ac68 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 15:38:20 -0600
Subject: [PATCH 099/298] device form
---
.github/ISSUE_TEMPLATE/suggest_wallet.yaml | 26 +++++++++++++++++++++-
1 file changed, 25 insertions(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
index ef620be96bb..b5d9cd310d3 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
@@ -8,7 +8,7 @@ body:
value: |
Before suggesting a wallet, make sure you've read [our listing policy](https://www.ethereum.org/en/contributing/adding-products/). Only continue with the issue if the wallet meets the criteria listed there.
- type: markdown
- id: contact
+ id: project_info
attributes:
value: "## Project info"
- type: input
@@ -81,3 +81,27 @@ body:
description: Please provide social links for the wallet (Discord, Twitter, etc.)
validations:
required: true
+ - type: markdown
+ id: device
+ attributes:
+ value: "## Device"
+ - type: textarea
+ id: wallet_mobile
+ attributes:
+ label: Does the wallet have a mobile app? If yes, which operating systems are supported (iOS, Android)?
+ description: Please provide app store links for the operating systems supported.
+ - type: textarea
+ id: wallets_desktop
+ attributes:
+ label: Does the wallet have a desktop app? If yes, which operating systems are supported (Windows, Mac, Linux)?
+ description: Please provide links and information for the desktop operating systems supported.
+ - type: textarea
+ id: wallets_browser
+ attributes:
+ label: Does the wallet have a browser extension? If yes, which browsers are supported (Chromium, Firefox, Safari)?
+ description: Please provide links and information for the browsers that are supported.
+ - type: textarea
+ id: wallets_hardware
+ attributes:
+ label: Is it a hardware wallet?
+ description: How does it broadcast signed transactions (e.g. USB, Bluetooth, QR code)?
From 0e3f0892cf2564d0f4663eeadb4570061f213dfc Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 16:11:46 -0600
Subject: [PATCH 100/298] security form
---
.github/ISSUE_TEMPLATE/suggest_wallet.yaml | 48 ++++++++++++++++++++++
1 file changed, 48 insertions(+)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
index b5d9cd310d3..7ce1e24c6ee 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
@@ -105,3 +105,51 @@ body:
attributes:
label: Is it a hardware wallet?
description: How does it broadcast signed transactions (e.g. USB, Bluetooth, QR code)?
+ - type: markdown
+ id: security
+ attributes:
+ value: "## Security"
+ - type: input
+ id: wallet_source_code
+ attributes:
+ label: Is the source code for the wallet fully open-source?
+ description: If yes, please provide a direct link to the repository.
+ - type: input
+ id: wallet_license
+ attributes:
+ label: What license is the wallet software released under?
+ description: Please provide information on the software license used for the wallet.
+ - type: textarea
+ id: wallet_custodial
+ attributes:
+ label: Who holds the private keys?
+ description: |
+ Users must have access to private keys without reliance on a company remaining in business to be listed as a wallet.
+ Do users have access to their public and private keys? Does anyone else? If the company/project were to disappear, would users still be able to access their funds?
+ validations:
+ required: true
+ - type: textarea
+ id: wallet_security_documentation
+ attributes:
+ label: Please describe the measures taken to ensure the wallet's security and provide documentation wherever possible
+ description: Please provide a link to any security audits, code reports, and bug bounties. If you haven't been audited but think the wallet should be listed anyway, explain here.
+ - type: input
+ id: wallet_smart_contract_audit
+ attributes:
+ label: Has the wallet's smart contract code been audited?
+ description: If yes, provide a link to any audits.
+ - type: input
+ id: wallet_security_team
+ attributes:
+ label: Does the wallet have an internal security team?
+ description: If yes, please provide details.
+ - type: textarea
+ id: wallet_security_testing
+ attributes:
+ label: Any other security testing that should be noted?
+ description: Please note any other security precautions taken.
+ - type: textarea
+ id: wallet_spam_protection
+ attributes:
+ label: Spam protection?
+ description: Does the wallet employ any practices to warn users against potential spam (e.g. when interacting with suspicious accounts/contracts)?
From 60a5bffa4030e21b1e13c61ea5c01b9e7562d159 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 16:23:49 -0600
Subject: [PATCH 101/298] features form
---
.github/ISSUE_TEMPLATE/suggest_wallet.yaml | 76 ++++++++++++++++++++++
1 file changed, 76 insertions(+)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
index 7ce1e24c6ee..e7f88ea78ef 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
@@ -153,3 +153,79 @@ body:
attributes:
label: Spam protection?
description: Does the wallet employ any practices to warn users against potential spam (e.g. when interacting with suspicious accounts/contracts)?
+ - type: markdown
+ id: features
+ attributes:
+ value: "## Features"
+ - type: dropdown
+ id: wallet_hardware_support
+ attributes:
+ label: Does the wallet support connecting to a hardware wallet?
+ options:
+ - Yes
+ - No
+ validations:
+ required: true
+ - type: dropdown
+ id: wallet_walletconnect
+ attributes:
+ label: Does the wallet support WalletConnect?
+ options:
+ - Yes
+ - No
+ validations:
+ required: true
+ - type: input
+ id: wallet_rpc_importing
+ attributes:
+ label: Does the wallet support importing Ethereum RPC endpoints?
+ description: Please provide documentation on how a user can import an Ethereum RPC into the wallet.
+ - type: dropdown
+ id: wallet_nft_viewing
+ attributes:
+ label: Does the wallet support viewing and interacting with NFTs?
+ options:
+ - Yes
+ - No
+ validations:
+ required: true
+ - type: input
+ id: wallet_dapp_support
+ attributes:
+ label: Does the wallet support connecting to Ethereum applications?
+ description: Please provide documentation for how users connect to applications. List examples (ie. connect wallet to dapp, in wallet browser, etc.)
+ - type: input
+ id: wallet_direct_staking
+ attributes:
+ label: Does the wallet support staking directly?
+ description: Please provide documentation on direct staking this wallet supports.
+ - type: input
+ id: wallet_swaps
+ attributes:
+ label: Does the wallet support swaps directly?
+ description: Please provide documentation on swaps.
+ - type: input
+ id: wallet_multi_chain_support
+ attributes:
+ label: Does the wallet support multi-chain networks?
+ description: Please provide documentation on multi-chain networks this wallet supports.
+ - type: input
+ id: wallet_customize_gas_fees
+ attributes:
+ label: Does the wallet allow the user to customize gas fees?
+ description: Please provide documentation on how users can customize gas fees for transactions.
+ - type: input
+ id: wallet_ens_support
+ attributes:
+ label: Does the wallet support sending transactions to ENS addresses?
+ description: Please provide information on ENS support.
+ - type: input
+ id: wallet_erc_20_support
+ attributes:
+ label: Does the wallet support importing or automatically querying and displaying ERC-20 tokens?
+ description: Please provide documentation on how to import tokens into the wallet.
+ - type: input
+ id: wallet_eip_1559_support
+ attributes:
+ label: Does the wallet support EIP-1559 (type 2) transactions?
+ description: Please provide information on how the type of transactions this wallet supports.
From ee947558c6e041ade69790b19004bda67240136a Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 16:24:56 -0600
Subject: [PATCH 102/298] fix features bugs
---
.github/ISSUE_TEMPLATE/suggest_wallet.yaml | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
index e7f88ea78ef..e01a2f7a414 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
@@ -162,8 +162,8 @@ body:
attributes:
label: Does the wallet support connecting to a hardware wallet?
options:
- - Yes
- - No
+ - "Yes"
+ - "No"
validations:
required: true
- type: dropdown
@@ -171,8 +171,8 @@ body:
attributes:
label: Does the wallet support WalletConnect?
options:
- - Yes
- - No
+ - "Yes"
+ - "No"
validations:
required: true
- type: input
@@ -185,8 +185,8 @@ body:
attributes:
label: Does the wallet support viewing and interacting with NFTs?
options:
- - Yes
- - No
+ - "Yes"
+ - "No"
validations:
required: true
- type: input
From f358eaa6d75560b9994539ce2360634f07ed8b26 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 16:28:23 -0600
Subject: [PATCH 103/298] finance form
---
.github/ISSUE_TEMPLATE/suggest_wallet.yaml | 16 +++++++++++++++-
1 file changed, 15 insertions(+), 1 deletion(-)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
index e01a2f7a414..0c0595296ec 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
@@ -228,4 +228,18 @@ body:
id: wallet_eip_1559_support
attributes:
label: Does the wallet support EIP-1559 (type 2) transactions?
- description: Please provide information on how the type of transactions this wallet supports.
+ description: Please provide information on the type of transactions this wallet supports.
+ - type: markdown
+ id: finance
+ attributes:
+ value: "## Finance"
+ - type: input
+ id: wallet_fiat_onramp
+ attributes:
+ label: Does the wallet have fiat on-ramps through credit/debit cards, wire transfers, or bank transfers (ACH)?
+ description: Please provide documentation on how a user is able to onboard and purchase crypto in the wallet.
+ - type: input
+ id: wallet_fiat_withdrawals
+ attributes:
+ label: Does the wallet support withdrawals to fiat?
+ description: an a user cash out their crypto assets directly to a card or bank account? Please provide documentation.
From 1246f99157abc30b27e9e05386e0a893d08bc648 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 16:34:14 -0600
Subject: [PATCH 104/298] smart contract form
---
.github/ISSUE_TEMPLATE/suggest_wallet.yaml | 14 ++++++++++++++
1 file changed, 14 insertions(+)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
index 0c0595296ec..636b210bb29 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
@@ -243,3 +243,17 @@ body:
attributes:
label: Does the wallet support withdrawals to fiat?
description: an a user cash out their crypto assets directly to a card or bank account? Please provide documentation.
+ - type: markdown
+ id: smart_contract
+ attributes:
+ value: "## Smart contract"
+ - type: input
+ id: wallet_multi_signature
+ attributes:
+ label: Is the wallet a multi-signature wallet?
+ description: Please provide documentation on how users set up and use the multisig functionality for the wallet.
+ - type: input
+ id: wallet_social_recovery
+ attributes:
+ label: Does the wallet support social recovery?
+ description: Please provide documentation on how users set up guardians and use social recovery for the wallet.
From 1a52f3985938e89c81165fb319b917c46a418759 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 16:37:28 -0600
Subject: [PATCH 105/298] support form
---
.github/ISSUE_TEMPLATE/suggest_wallet.yaml | 23 ++++++++++++++++++++++
1 file changed, 23 insertions(+)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
index 636b210bb29..46cf0296836 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
@@ -257,3 +257,26 @@ body:
attributes:
label: Does the wallet support social recovery?
description: Please provide documentation on how users set up guardians and use social recovery for the wallet.
+ - type: markdown
+ id: support
+ attributes:
+ value: "## Support"
+ - type: textarea
+ id: wallet_contact
+ attributes:
+ label: Who can the ethereum.org team can contact regarding the wallet in future?
+ description: |
+ If possible, provide a Telegram, Discord, or Twitter username.
+ Please note that as a result of any future dispute the wallet may be temporarily removed from ethereum.org. Having a contact person allows lets us avoid this situation and resolve issues more quickly.
+ - type: textarea
+ id: wallet_support_team
+ attributes:
+ label: Does the wallet have a dedicated support team?
+ description: |
+ Where should we send users that are having issues?
+ How fast is the support?
+ - type: textarea
+ id: wallet_educational_resources
+ attributes:
+ label: What educational resources/documentation do you provide to users?
+ description: Please provide links to developer documentation, user documentation, and/or educational resources.
From 08de2bc8c545217cb771f313581e089891155de4 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Thu, 26 May 2022 16:38:40 -0600
Subject: [PATCH 106/298] extra form
---
.github/ISSUE_TEMPLATE/suggest_wallet.yaml | 9 +++++++++
1 file changed, 9 insertions(+)
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
index 46cf0296836..ed051c406c4 100644
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
+++ b/.github/ISSUE_TEMPLATE/suggest_wallet.yaml
@@ -280,3 +280,12 @@ body:
attributes:
label: What educational resources/documentation do you provide to users?
description: Please provide links to developer documentation, user documentation, and/or educational resources.
+ - type: markdown
+ id: extra
+ attributes:
+ value: "## Extra"
+ - type: textarea
+ id: wallet_extra
+ attributes:
+ label: Does the wallet have any integrated tools not mentioned above?
+ description: Please provide any information about extra features this wallet has that we may have missed in the above criteria. (e.g. privacy features, transaction batching, etc).
From b170e51f6803c8048a8776ff12b4531d8a253cc3 Mon Sep 17 00:00:00 2001
From: Joseph Cook <33655003+jmcook1186@users.noreply.github.com>
Date: Fri, 27 May 2022 12:16:17 +0100
Subject: [PATCH 107/298] add more links
---
.../get-involved/open-research/index.md | 56 +++++++++++--------
1 file changed, 32 insertions(+), 24 deletions(-)
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
index 62daa3b1ec4..72da1a9421b 100644
--- a/src/content/community/get-involved/open-research/index.md
+++ b/src/content/community/get-involved/open-research/index.md
@@ -27,8 +27,12 @@ There are now several Layer 2 protocols that scale Ethereum using different tech
[EthHub Layer-2](https://docs.ethhub.io/ethereum-roadmap/layer-2-scaling/zk-rollups/)
+[Polynya: Rollups, DA and modular chains](https://polynya.medium.com/rollups-data-availability-layers-modular-blockchains-introductory-meta-post-5a1e7a60119d)
+
#### Recent research
+[Arbitrum's fair-ordering for sequencers](https://eprint.iacr.org/2020/269.pdf)
+
[ethresear.ch Layer 2](https://ethresear.ch/c/layer-2/32)
@@ -44,6 +48,8 @@ One particular area of layer 2 that requires more research and development is sa
[Blockchain Bridges article](https://medium.com/1kxnetwork/blockchain-bridges-5db6afac44f8)
+[L2Beat](https://l2beat.com/)
+
#### Recent research
[Validating bridges](https://stonecoldpat.github.io/images/validatingbridges.pdf)
@@ -67,6 +73,10 @@ Sharding Ethereum's blockchain has long been part of the development roadmap. Ho
#### Recent research
+[EIP-4844](https://github.com/ethereum/EIPs/pull/5088)
+
+[Vitalik on sharding and data availability sampling](https://hackmd.io/@vbuterin/sharding_proposal)
+
### Hardware
@@ -79,6 +89,7 @@ Sharding Ethereum's blockchain has long been part of the development roadmap. Ho
#### Recent research
+[ecdsa on FGPAs](https://ethresear.ch/t/does-ecdsa-on-fpga-solve-the-scaling-problem/6738)
## Security
@@ -172,7 +183,7 @@ There are complex crypto-economic factors relating to Ethereum's native asset (e
### PoS incentives
-When Ethereum transitions to proof of stake, its native asset (ether) will be used as collateral by validators. The cryptoeconomics of this
+When Ethereum transitions to proof of stake, its native asset (ether) will be used as collateral by validators. The cryptoeconomics of this determines the security of the network. Sophisticated validators may be able to exploit the nuances of the incentive layer to theior own advantage by extracting MEV or launching explicit attacks.
#### Background reading
@@ -180,10 +191,16 @@ When Ethereum transitions to proof of stake, its native asset (ether) will be us
#### Recent research
+[Vitalik on PBS](https://notes.ethereum.org/s3JToeApTx6CKLJt8AbhFQ#Hybrid-PBS-can-we-use-proposers-only-for-inclusion-of-last-resort)
+
+[Three Attacks on PoS Ethereum](https://arxiv.org/abs/2110.10086)
+
+[Low-cost attacks on Ethereum 2.0 by sub 1/3 stakeholders](https://arxiv.org/abs/2102.02247)
+
### Liquid staking and derivatives
-Liquid staking allows users with less than 32 ETH to receive staking yields by swapping ether for a token representing staked ether that can be used in DeFi. However, the incentives and market dynamics associated with liquid staking as well as its effect on Ethereum's security (e.g. centralization risks, )
+Liquid staking allows users with less than 32 ETH to receive staking yields by swapping ether for a token representing staked ether that can be used in DeFi. However, the incentives and market dynamics associated with liquid staking as well as its effect on Ethereum's security (e.g. centralization risks).
#### Background reading
@@ -192,6 +209,9 @@ Liquid staking allows users with less than 32 ETH to receive staking yields by s
#### Recent research
+[Handling withdrawals from Lido](https://ethresear.ch/t/handling-withdrawals-in-lidos-eth-liquid-staking-protocol/8873)
+
+[Withdrawal credentials](https://ethresear.ch/t/withdrawal-credential-rotation-from-bls-to-eth1/8722)
### DeFi
@@ -206,6 +226,10 @@ Decentralized finance (DeFi) is one of the primary classes of application built
#### Recent research
+[Decentralized finance, centralized ownership?](https://arxiv.org/pdf/2012.09306.pdf)
+
+[Optimism: The road to sub-dollar transactions](https://medium.com/ethereum-optimism/the-road-to-sub-dollar-transactions-part-2-compression-edition-6bb2890e3e92)
+
### Fee markets
Ethereum transaction fees protect the network from spam, denial-of-service attacks and bad smart-contract code. However, it also affects the end-user by influencing the cost of interacting with Ethereum. Balancing network security with end-user user-experience is an ongoing challenge that requires further research and development.
@@ -216,17 +240,11 @@ Ethereum transaction fees protect the network from spam, denial-of-service attac
#### Recent research
+[EIP-4396](https://eips.ethereum.org/EIPS/eip-4396)
-### Taxation and accounting
-
-Crypto taxation is a complicated issue that likely requires a software solution. There are some nascent crypto accounting project but this area requires much more attention.
-
-#### Background reading
-
-#### Recent research
-
-[Example of taxation and accounting research: Cumming et al. 2019](https://www.mdpi.com/1911-8074/12/3/126)
+[Multidimensional EIP-1559](https://ethresear.ch/t/multidimensional-eip-1559/11651)
+[Making EIP-1559 more like an AMM curve](https://ethresear.ch/t/make-eip-1559-more-like-an-amm-curve/9082)
## Clients and protocol research
@@ -261,10 +279,6 @@ The consensus layer is concerned with the proof-of-stake mechanism securing Ethe
[Ethresear.ch Consensus](https://ethresear.ch/c/consensus/29)
-[Three Attacks on PoS Ethereum](https://arxiv.org/abs/2110.10086)
-
-[Low-cost attacks on Ethereum 2.0 by sub 1/3 stakeholders](https://arxiv.org/abs/2102.02247)
-
[Availability/Finality dilemma](https://arxiv.org/abs/2009.04987)
[Single slot finality](https://ethresear.ch/t/a-model-for-cumulative-committee-based-finality/10259)
@@ -328,6 +342,8 @@ There is a need for more data analysis tools and dashboards that give detailed i
#### Recent research
+
+
## Apps and tooling
### DAOs
@@ -355,6 +371,7 @@ Tools for Ethereum developers are rapidly improving. There is lots of active res
#### Recent research
+[Eth R&D Discord Consensus Tooling channel](https://discordapp.com/channels/595666850260713488/746343380900118528)
### App security
@@ -377,13 +394,4 @@ Apps on Ethereum are rarely fully decentralized because they rely on some centra
#### Recent research
-
-### Composability
-
-Composability is the ability for different apps to work in parallel or on top of one another so that users are not locked-in to specific protocols. This is something that requires best-practices in interoperability and data standards. This is an area that would benefit from more ongoing research and development.
-
-#### Background reading
-
[Smart contract composability](https://ethereum.org/en/developers/docs/smart-contracts/composability/)
-
-#### Recent research
From 2d60db55ae34d791c68f395972fd8720e27d7e5b Mon Sep 17 00:00:00 2001
From: Joseph Cook <33655003+jmcook1186@users.noreply.github.com>
Date: Fri, 27 May 2022 12:23:27 +0100
Subject: [PATCH 108/298] add links to app security section
---
src/content/community/get-involved/open-research/index.md | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
index 72da1a9421b..b55dd44156c 100644
--- a/src/content/community/get-involved/open-research/index.md
+++ b/src/content/community/get-involved/open-research/index.md
@@ -379,6 +379,12 @@ Hacks on Ethereum nearly always exploit vulnerabilities in individual applicatio
#### Background reading
+[Wormhole exploit report](https://blog.chainalysis.com/reports/wormhole-hack-february-2022/)
+
+[List of Ethereum contract hack post-mortems](https://forum.openzeppelin.com/t/list-of-ethereum-smart-contracts-post-mortems/1191)
+
+[Rekt News](https://twitter.com/RektHQ?s=20&t=3otjYQdM9Bqk8k3n1a1Adg)
+
#### Recent research
[ethresear.ch Applications](https://ethresear.ch/c/applications/18)
From fee2a8248ae671b0315bbda1a8c84d5787b5907c Mon Sep 17 00:00:00 2001
From: PatrickAlphac <54278053+PatrickAlphaC@users.noreply.github.com>
Date: Fri, 27 May 2022 08:03:55 -0400
Subject: [PATCH 109/298] added patrick mega course & a few others
---
src/data/externalTutorials.json | 144 ++++++++++++++++++++++++++++++++
1 file changed, 144 insertions(+)
diff --git a/src/data/externalTutorials.json b/src/data/externalTutorials.json
index f08fa90770e..82d3d3ad250 100644
--- a/src/data/externalTutorials.json
+++ b/src/data/externalTutorials.json
@@ -1,4 +1,46 @@
[
+ {
+ "url": "https://www.youtube.com/watch?v=gyMwXuJrbJQ",
+ "title": "Learn Blockchain, Solidity, and Full Stack Web3 Development with JavaScript ",
+ "description": "This course will give you a full introduction into all of the core concepts related to blockchain, smart contracts, Solidity, ERC20s, full-stack Web3 dapps, decentralized finance (DeFi), JavaScript, TypeScript, Chainlink, Ethereum, upgradable smart contracts, DAOs, the graph, moralis, aave, IPFS, and more. Follow along with the videos and you'll be a blockchain wizard in no time! ",
+ "author": "Patrick Collins",
+ "authorGithub": "https://github.com/PatrickAlphaC",
+ "tags": [
+ "solidity",
+ "hardhat",
+ "ethersjs",
+ "smart contracts",
+ "react",
+ "nextjs",
+ "blockchain",
+ "video",
+ "IPFS",
+ "oracles",
+ "NFT",
+ "ERC-20",
+ "upgrades",
+ "javascript",
+ "mocking",
+ "testing",
+ "Aave",
+ "chainlink",
+ "openzeppelin",
+ "slither",
+ "echidna",
+ "filecoin",
+ "web3uikit",
+ "moralis",
+ "alchemy",
+ "the graph",
+ "pinata",
+ "metamask",
+ "etherscan"
+ ],
+ "skillLevel": "beginner",
+ "timeToRead": "1920",
+ "lang": "en",
+ "publishDate": "05/26/2022"
+ },
{
"url": "https://www.youtube.com/watch?v=M576WGiDBdQ",
"title": "Solidity, Blockchain, and Smart Contract Course",
@@ -30,6 +72,108 @@
"lang": "en",
"publishDate": "09/09/2021"
},
+ {
+ "url": "https://www.youtube.com/watch?v=fNMfMxGxeag",
+ "title": "Introduction to Foundry",
+ "description": "We build a minimal foundry project using a staking application. Showing you how to work with foundry. ",
+ "author": "Patrick Collins",
+ "authorGithub": "https://github.com/PatrickAlphaC",
+ "tags": ["solidity", "foundry", "bash", "video"],
+ "skillLevel": "beginner",
+ "timeToRead": "19",
+ "lang": "en",
+ "publishDate": "03/28/2022"
+ },
+ {
+ "url": "https://www.youtube.com/watch?v=pdsYCkUWrgQ",
+ "title": "How to Connect your Smart Contracts to Metamask | Full Stack Web3",
+ "description": "We learn exactly how web3 / blockchain / smart contract applications work in the front end using HTML and Javascript. We then go through 6 different ways you can connect your Metamask, Phantom, or other blockchain wallet address to your front end. We’ll look at popular Nextjs / React packages to make your development lifecycle 100 times easier. ",
+ "author": "Patrick Collins",
+ "authorGithub": "https://github.com/PatrickAlphaC",
+ "tags": [
+ "solidity",
+ "javascript",
+ "hardhat",
+ "metamask",
+ "html",
+ "nextjs",
+ "reactjs",
+ "moralis",
+ "web3modal",
+ "web3-react",
+ "ethersjs",
+ "usedapp",
+ "video"
+ ],
+ "skillLevel": "beginner",
+ "timeToRead": "70",
+ "lang": "en",
+ "publishDate": "02/11/2022"
+ },
+ {
+ "url": "https://www.youtube.com/watch?v=pdsYCkUWrgQ",
+ "title": "How to build an on-chain DAO",
+ "description": "Using Compound and Openzeppelin as a basis, we build a 100% on-chain DAO using an ERC20 governance token for votes. ",
+ "author": "Patrick Collins",
+ "authorGithub": "https://github.com/PatrickAlphaC",
+ "tags": [
+ "solidity",
+ "typescript",
+ "hardhat",
+ "compound",
+ "dao",
+ "governance",
+ "video"
+ ],
+ "skillLevel": "beginner",
+ "timeToRead": "86",
+ "lang": "en",
+ "publishDate": "03/04/2022"
+ },
+ {
+ "url": "https://betterprogramming.pub/how-to-code-an-on-chain-dao-e525e13a57be",
+ "title": "How to build an on-chain DAO",
+ "description": "Using Compound and Openzeppelin as a basis, we build a 100% on-chain DAO using an ERC20 governance token for votes. ",
+ "author": "Patrick Collins",
+ "authorGithub": "https://github.com/PatrickAlphaC",
+ "tags": [
+ "solidity",
+ "typescript",
+ "hardhat",
+ "compound",
+ "dao",
+ "governance"
+ ],
+ "skillLevel": "beginner",
+ "timeToRead": "6",
+ "lang": "en",
+ "publishDate": "02/24/2022"
+ },
+ {
+ "url": "https://betterprogramming.pub/everything-you-need-to-know-about-fullstack-web3-94c0f1b18019",
+ "title": "Full Stack Web3 — Everything You Need to Know",
+ "description": "We learn exactly how web3 / blockchain / smart contract applications work in the front end using HTML and Javascript. We then go through 6 different ways you can connect your Metamask, Phantom, or other blockchain wallet address to your front end. We’ll look at popular Nextjs / React packages to make your development lifecycle 100 times easier. ",
+ "author": "Patrick Collins",
+ "authorGithub": "https://github.com/PatrickAlphaC",
+ "tags": [
+ "solidity",
+ "javascript",
+ "hardhat",
+ "metamask",
+ "html",
+ "nextjs",
+ "reactjs",
+ "moralis",
+ "web3modal",
+ "web3-react",
+ "ethersjs",
+ "usedapp"
+ ],
+ "skillLevel": "beginner",
+ "timeToRead": "14",
+ "lang": "en",
+ "publishDate": "02/07/2022"
+ },
{
"url": "https://www.youtube.com/watch?v=e1N4aWIJMN0",
"title": "How to become a blockchain engineer",
From 3a7a2b0092553141cbae0b2e38df8d5346731e95 Mon Sep 17 00:00:00 2001
From: Paul Cowgill
Date: Fri, 27 May 2022 09:56:15 -0500
Subject: [PATCH 110/298] Add Chicago
---
src/data/community-meetups.json | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/src/data/community-meetups.json b/src/data/community-meetups.json
index 1405c618b38..7d494b72d56 100644
--- a/src/data/community-meetups.json
+++ b/src/data/community-meetups.json
@@ -274,5 +274,11 @@
"emoji": ":poland:",
"location": "Warsaw",
"link": "https://www.meetup.com/ethwarsaw-meetup/"
+ },
+ {
+ "title": "Chicago Ethereum Meetup",
+ "emoji": ":us:",
+ "location": "Chicago",
+ "link": "https://www.meetup.com/Chicago-Ethereum-Meetup/"
}
]
From 02e79d481db9e154e3fdfbb776ab5bdecf9128be Mon Sep 17 00:00:00 2001
From: Pablo Pettinari
Date: Fri, 27 May 2022 14:01:24 -0300
Subject: [PATCH 111/298] Update docs/typescript.md
Co-authored-by: Sam Richards
---
docs/typescript.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/typescript.md b/docs/typescript.md
index 6ba6ffc5c41..0fb0feda6ee 100644
--- a/docs/typescript.md
+++ b/docs/typescript.md
@@ -85,7 +85,7 @@ With the release of Gatsby v4.15.0, [the config option `graphqlTypegen` has been
- Once you have that file created, a global `Queries` variable will be available which will contain all the query types.
- More information about how this works https://www.gatsbyjs.com/docs/how-to/local-development/graphql-typegen/
-## Other resources
+## Learning resources
- [Official Gatsby Typescript guide](https://www.gatsbyjs.com/docs/how-to/custom-configuration/typescript/)
- [Official Typescript website](https://www.typescriptlang.org/)
From 5110f2946ca221e4c2bc41225b09b9d6b8347f1c Mon Sep 17 00:00:00 2001
From: Pablo Pettinari
Date: Fri, 27 May 2022 14:42:24 -0300
Subject: [PATCH 112/298] mention epic issue
---
docs/typescript.md | 13 +++++++++----
1 file changed, 9 insertions(+), 4 deletions(-)
diff --git a/docs/typescript.md b/docs/typescript.md
index 0fb0feda6ee..64b5c8c2bc0 100644
--- a/docs/typescript.md
+++ b/docs/typescript.md
@@ -1,5 +1,7 @@
# Typescript
+Our codebase is rapidly increasing in size and in contributors. This brings challenges to reliably keep the code organized, avoid code duplication, and review code. To help alleviate these challenges, we’re in the process of to TypeScript across our codebase. We believe having a strongly typed language will reduce bugs, improve code quality, increase productivity and allow us to scale (both our codebase and our developer community) better in the long term.
+
## General considerations
As we are progressively migrating the entire codebase to TS, we will have a mix of `.js` and `.ts` files in the process. For this reason and to make the migration easier for beginners, we have disabled the [`noImplicitAny`](https://www.typescriptlang.org/tsconfig#noImplicitAny) option from our `tsconfig.json` which means that you can use the `any` type and you will not get an error from that.
@@ -9,9 +11,12 @@ This is just starting, any suggestion is always welcomed and appreciated.
## Migration guide & contribution opportunity 🎉
-1. Run `yarn start` to generate the `src/gatsby-types.d.ts` file. More on this in the "GraphQL Typegen" section.
-2. Convert the js file into a `.ts` or `.tsx` file in case the file includes some jsx in it.
-3. Try to follow one already migrated file similar to the one you are migrating.
+We'd love your help in migrating our codebase!
+
+1. Visit the [Typescript Migration Issue](https://github.com/ethereum/ethereum-org-website/issues/6392) and make a comment to get assigned to a file from the complete list of pending files to be migrated.
+2. Run `yarn start` to generate the `src/gatsby-types.d.ts` file. More on this in the "GraphQL Typegen" section.
+3. Convert the js file into a `.ts` or `.tsx` file in case the file includes some jsx in it.
+4. Try to follow one already migrated file similar to the one you are migrating.
- For `pages`,
@@ -74,7 +79,7 @@ This is just starting, any suggestion is always welcomed and appreciated.
}
```
-4. Try to avoid as much as possible the usage of `any` :)
+5. Try to avoid as much as possible the usage of `any` :)
## GraphQL Typegen
From 4f32d857dad58bca03311f5d33256d614a03cdf6 Mon Sep 17 00:00:00 2001
From: Joshua <30259508@cityofglacol.ac.uk>
Date: Fri, 27 May 2022 18:54:20 +0100
Subject: [PATCH 113/298] Refactor Card component to TS
---
src/components/{Card.js => Card.tsx} | 15 ++++++++++++++-
1 file changed, 14 insertions(+), 1 deletion(-)
rename src/components/{Card.js => Card.tsx} (77%)
diff --git a/src/components/Card.js b/src/components/Card.tsx
similarity index 77%
rename from src/components/Card.js
rename to src/components/Card.tsx
index b43698cc8c0..9d7b325dd19 100644
--- a/src/components/Card.js
+++ b/src/components/Card.tsx
@@ -17,7 +17,20 @@ const Description = styled.p`
const TopContent = styled.div``
-const Card = ({ emoji, title, description, children, className }) => (
+interface IProps {
+ emoji?: string
+ title: string
+ description: string
+ className?: string
+}
+
+const Card: React.FC = ({
+ emoji,
+ title,
+ description,
+ children,
+ className,
+}) => (
{emoji && }
From 045c3ada3b7285283206dd76e68cf13b65d19e45 Mon Sep 17 00:00:00 2001
From: Pablo Pettinari
Date: Fri, 27 May 2022 15:09:40 -0300
Subject: [PATCH 114/298] add suggestion to use yarn type-check
---
docs/typescript.md | 1 +
1 file changed, 1 insertion(+)
diff --git a/docs/typescript.md b/docs/typescript.md
index 64b5c8c2bc0..474bbe3217b 100644
--- a/docs/typescript.md
+++ b/docs/typescript.md
@@ -80,6 +80,7 @@ We'd love your help in migrating our codebase!
```
5. Try to avoid as much as possible the usage of `any` :)
+6. Run `yarn type-check` to check if everything looks good and nothing else broke.
## GraphQL Typegen
From 3c1d3d8c42f8080c26b463507fd9595dd09f3a1b Mon Sep 17 00:00:00 2001
From: Joshua <62268199+minimalsm@users.noreply.github.com>
Date: Fri, 27 May 2022 19:17:24 +0100
Subject: [PATCH 115/298] export interface
Co-authored-by: Pablo Pettinari
---
src/components/Card.tsx | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/components/Card.tsx b/src/components/Card.tsx
index 9d7b325dd19..ed3336950e4 100644
--- a/src/components/Card.tsx
+++ b/src/components/Card.tsx
@@ -17,7 +17,7 @@ const Description = styled.p`
const TopContent = styled.div``
-interface IProps {
+export interface IProps {
emoji?: string
title: string
description: string
From 0ff95e48abb8bc7a5a9f980c8284b66ce5e3a06c Mon Sep 17 00:00:00 2001
From: beechainfullstack <79773128+beechainfullstack@users.noreply.github.com>
Date: Fri, 27 May 2022 13:54:58 -0700
Subject: [PATCH 116/298] Added/Edited Dystopia Labs Community Events
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
edited: ETH Seattle from hackathon to summit
added: ETH Seoul, HackSummit('SF'), DeFi Bogotá
---
src/data/community-events.json | 29 ++++++++++++++++++++++++++++-
1 file changed, 28 insertions(+), 1 deletion(-)
diff --git a/src/data/community-events.json b/src/data/community-events.json
index dfce4cf08ef..15ec68043ce 100644
--- a/src/data/community-events.json
+++ b/src/data/community-events.json
@@ -229,7 +229,7 @@
"to": "https://2022.ethseattle.org/",
"sponsor": null,
"location": "Seattle, USA",
- "description": "ETHSeattle is a hackathon in Seattle, USA.",
+ "description": "ETHSeattle is an Ethereum summit in Seattle, USA.",
"startDate": "2022-07-08",
"endDate": "2022-07-08"
},
@@ -269,6 +269,15 @@
"startDate": "2022-07-19",
"endDate": "2022-07-21"
},
+ {
+ "title": "ETHSeoul",
+ "to": "https://2022.ethseoul.org/",
+ "sponsor": null,
+ "location": "Seoul, South Korea",
+ "description": "Join Seoul's first Ethereum Hackathon & Summit hosted by KryptoSeoul & Dystopia Labs",
+ "startDate": "2022-08-05",
+ "endDate": "2022-08-13"
+ },
{
"title": "ETHLatam",
"to": "https://twitter.com/ethlatam",
@@ -296,6 +305,15 @@
"startDate": "2022-08-27",
"endDate": "2022-08-28"
},
+ {
+ "title": "Hack.Summit('SF')",
+ "to": "https://sf.hacksummit.org/",
+ "sponsor": null,
+ "location": "San Francisco, California",
+ "description": "Hack.Summit('SF') is a 2-day blockchain summit hosted by Hack.VC & Dystopia Labs",
+ "startDate": "2022-08-27",
+ "endDate": "2022-08-28"
+ },
{
"title": "Stanford SBC",
"to": "https://cbr.stanford.edu/sbc22/",
@@ -332,6 +350,15 @@
"startDate": "2022-10-07",
"endDate": "2022-10-09"
},
+ {
+ "title": "DeFi Bogotá",
+ "to": "https://2022.defibogota.org/",
+ "sponsor": null,
+ "location": "Bogotá, Colombia",
+ "description": "DeFi Bogotá is a DeFi-focused summit in Colombia.",
+ "startDate": "2022-10-10",
+ "endDate": "2022-10-10"
+ },
{
"title": "Devcon",
"to": "https://devcon.org/",
From 674f0318d5fc45f3feb802cf0b98ab32bab815ed Mon Sep 17 00:00:00 2001
From: Jhonny Vianello <62344609+jhonnyvianello@users.noreply.github.com>
Date: Sat, 28 May 2022 23:18:23 +0200
Subject: [PATCH 117/298] Fix a date and add a new event
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Fixed date of HackFS event and added ETHVenice event 🎆
I attach the links here of the official events sites.
HackFS : https://hackfs.ethglobal.com/
ETHVenice : https://ethvenice.com/
---
src/data/community-events.json | 13 +++++++++++--
1 file changed, 11 insertions(+), 2 deletions(-)
diff --git a/src/data/community-events.json b/src/data/community-events.json
index dfce4cf08ef..dc71a9559f9 100644
--- a/src/data/community-events.json
+++ b/src/data/community-events.json
@@ -239,8 +239,17 @@
"sponsor": null,
"location": "Remote",
"description": "ETHGlobal returns with their 3rd iteration of HackFS, a global celebration of storage, data, and building data-full decentralized applications.",
- "startDate": "2022-07-01",
- "endDate": "2022-07-31"
+ "startDate": "2022-07-08",
+ "endDate": "2022-07-29"
+ },
+ {
+ "title": "ETHVenice",
+ "to": "https://ethvenice.com/",
+ "sponsor": null,
+ "location": "Venice, Italy",
+ "description": "ETHVenice is an Italian Ethereum Event and Hackathon, simultaneously with The Feast of the Redeemer in Venice.",
+ "startDate": "2022-07-11",
+ "endDate": "2022-07-17"
},
{
"title": "Metaverse Summit",
From 70e8ca0c60ccddff0fee4d0268f86c5dcba2bb6e Mon Sep 17 00:00:00 2001
From: avcdsld
Date: Sun, 29 May 2022 22:15:05 +0900
Subject: [PATCH 118/298] add `hyphens` settings to tables to prevent layout
corruption on small screens
---
src/styles/layout.css | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/src/styles/layout.css b/src/styles/layout.css
index bfb71166db9..40e131c7bfc 100644
--- a/src/styles/layout.css
+++ b/src/styles/layout.css
@@ -419,6 +419,10 @@ table {
border-collapse: collapse;
width: 100%;
}
+th,
+td {
+ hyphens: auto;
+}
fieldset {
margin-left: 0;
margin-right: 0;
From b4545fdf5793f796b996eedd32e49f9a21aea528 Mon Sep 17 00:00:00 2001
From: skaunov <65976143+skaunov@users.noreply.github.com>
Date: Sun, 29 May 2022 18:49:29 +0300
Subject: [PATCH 119/298] Update index.md
minor updates to smooth following along the example
---
src/content/developers/docs/apis/json-rpc/index.md | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/src/content/developers/docs/apis/json-rpc/index.md b/src/content/developers/docs/apis/json-rpc/index.md
index 336d9088904..22903da58db 100755
--- a/src/content/developers/docs/apis/json-rpc/index.md
+++ b/src/content/developers/docs/apis/json-rpc/index.md
@@ -117,7 +117,7 @@ web3.fromWei("0x1639e49bba16280000", "ether")
// "410"
```
-Now that there is some ether on our private development chain, we can deploy the contract. The first step is to compile the Multiply7 contract to byte code that can be sent to the EVM. To install solc, the Solidity compiler, follow the [Solidity documentation].
+Now that there is some ether on our private development chain, we can deploy the contract. The first step is to compile the Multiply7 contract to byte code that can be sent to the EVM. To install solc, the Solidity compiler, follow the [Solidity documentation](https://docs.soliditylang.org/en/latest/installing-solidity.html). (You might want to use an older `solc` release to match [the version of compiler used for our example](https://github.com/ethereum/solidity/releases/tag/v0.4.20).)
The next step is to compile the Multiply7 contract to byte code that can be send to the EVM.
@@ -163,8 +163,8 @@ In this example we will be sending a transaction using `eth_sendTransaction` to
The bytes of the payload defines which method in the contract is called. This is the first 4 bytes from the Keccak hash over the function name and its argument types, hex encoded. The multiply function accepts an uint which is an alias for uint256. This leaves us with:
```javascript
-web3.sha3("multiply(uint256)").substring(0, 8)
-// "c6888fa1"
+web3.sha3("multiply(uint256)").substring(0, 10)
+// "0xc6888fa1"
```
The next step is to encode the arguments. There is only one uint256, say, the value 6. The ABI has a section which specifies how to encode uint256 types.
@@ -178,7 +178,7 @@ Combining the function selector and the encoded argument our data will be `0xc68
This can now be sent to the node:
```bash
-curl --data '{"jsonrpc":"2.0","method": "eth_sendTransaction", "params": [{"from": "0xeb85a5557e5bdc18ee1934a89d8bb402398ee26a", "to": "0x6ff93b4b46b41c0c3c9baee01c255d3b4675963d", "data": "0xc6888fa10000000000000000000000000000000000000000000000000000000000000006"}], "id": 8}' localhost:8545
+curl --data '{"jsonrpc":"2.0","method": "eth_sendTransaction", "params": [{"from": "0xeb85a5557e5bdc18ee1934a89d8bb402398ee26a", "to": "0x6ff93b4b46b41c0c3c9baee01c255d3b4675963d", "data": "0xc6888fa10000000000000000000000000000000000000000000000000000000000000006"}], "id": 8}' -H "Content-Type: application/json" localhost:8545
{"id":8,"jsonrpc":"2.0","result":"0x759cf065cbc22e9d779748dc53763854e5376eea07409e590c990eafc0869d74"}
```
From 9c6fd2c1de597ffed2473d1ddac01266c3e0f27e Mon Sep 17 00:00:00 2001
From: Ikko Ashimine
Date: Mon, 30 May 2022 02:35:07 +0900
Subject: [PATCH 120/298] Fix typo in erc-4626/index.md
addres -> address
Github -> GitHub
---
.../developers/docs/standards/tokens/erc-4626/index.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/src/content/developers/docs/standards/tokens/erc-4626/index.md b/src/content/developers/docs/standards/tokens/erc-4626/index.md
index a7d06cf622f..0ddf2dc706a 100644
--- a/src/content/developers/docs/standards/tokens/erc-4626/index.md
+++ b/src/content/developers/docs/standards/tokens/erc-4626/index.md
@@ -110,7 +110,7 @@ The decimal scalar for vault shares and operations involving `exchangeRate()`.
**MUST** be emitted when tokens are deposited into the vault
```solidity
-event Deposit(address indexed _from, addres indexed _to, uint256 _value)
+event Deposit(address indexed _from, address indexed _to, uint256 _value)
```
Where `_from` is the user who triggered the deposit and approved `_value` underlying tokens to the vault, and `_to` is the user who can withdraw the deposited tokens.
@@ -128,4 +128,4 @@ _Note_: All batch functions, including the hook, are also available in non-batch
## Further reading {#further-reading}
- [EIP-4626: Tokenized vault Standard](https://eips.ethereum.org/EIPS/eip-4626)
-- [ERC-4626: Github Repo](https://github.com/Rari-Capital/solmate/blob/main/src/mixins/ERC4626.sol)
+- [ERC-4626: GitHub Repo](https://github.com/Rari-Capital/solmate/blob/main/src/mixins/ERC4626.sol)
From 9294e820f04e55c809e304fd6c7999e559ea2e20 Mon Sep 17 00:00:00 2001
From: Hursit Tarcan <75273616+hursittarcan@users.noreply.github.com>
Date: Sun, 29 May 2022 22:12:18 +0200
Subject: [PATCH 121/298] Update index.md
---
src/content/community/get-involved/index.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/content/community/get-involved/index.md b/src/content/community/get-involved/index.md
index 51e3a8e44ce..c92826fef6d 100644
--- a/src/content/community/get-involved/index.md
+++ b/src/content/community/get-involved/index.md
@@ -101,7 +101,7 @@ The Ethereum ecosystem is on a mission to fund public goods and impactful projec
"DAOs" are decentralized autonomous organizations. These groups leverage Ethereum technology to facilitate organization and collaboration. For instance, for controlling membership, voting on proposals, or managing pooled assets. While DAOs are still experimental, they offer opportunities for you to find groups that you identify with, find collaborators, and grow your impact on the Ethereum community. [More on DAOs](/dao/)
-- [DAOSquare](https://www.daosquare.io) [@DAOSquare](https://twitter.com/DAOSquare) - _Promote the DAO concept in non-tech field and help people create value through DAO._
+- [DAOSquare](https://www.daosquare.io) [@DAOSquare](https://twitter.com/DAOSquare) - _Promote the DAO concept in non-tech field and help people create value through DAO_
- [Developer DAO](https://www.developerdao.com/) [@developer_dao](https://twitter.com/developer_dao) - _Community of builders who believe in collective ownership of the internet_
- [dOrg](https://dOrg.tech) [@dOrg_tech](https://twitter.com/dOrg_tech) - _Freelancer Web3 development collective working as a DAO_
- [DXdao](https://DXdao.eth.link/) [@DXdao](https://twitter.com/DXdao_) - _Decentralized development & governance of dApps & protocols_
From ca41ec0e41999a8a400a2d6a7572198056f03943 Mon Sep 17 00:00:00 2001
From: Nico
Date: Mon, 30 May 2022 06:26:38 +0900
Subject: [PATCH 122/298] migrate YouTube component to Typescript
---
src/components/{YouTube.js => YouTube.tsx} | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
rename src/components/{YouTube.js => YouTube.tsx} (96%)
diff --git a/src/components/YouTube.js b/src/components/YouTube.tsx
similarity index 96%
rename from src/components/YouTube.js
rename to src/components/YouTube.tsx
index bd01d37901d..2ac3266b568 100644
--- a/src/components/YouTube.js
+++ b/src/components/YouTube.tsx
@@ -25,7 +25,7 @@ const YouTube = ({ id, start, title }) => {
width="100%"
height="315"
src={src}
- frameborder="0"
+ frameBorder="0"
title={title || "YouTube"}
allow="
accelerometer;
@@ -34,7 +34,7 @@ const YouTube = ({ id, start, title }) => {
encrypted-media;
gyroscope;
picture-in-picture"
- allowfullscreen
+ allowFullScreen
>
)
From 7c50c4f229cf68d67f4c2abdfce2cac67371c554 Mon Sep 17 00:00:00 2001
From: William
Date: Sun, 29 May 2022 19:43:53 -0400
Subject: [PATCH 123/298] Migrate src/data/addresses.js
---
src/data/{addresses.js => addresses.ts} | 0
src/pages/staking/deposit-contract.js | 2 +-
2 files changed, 1 insertion(+), 1 deletion(-)
rename src/data/{addresses.js => addresses.ts} (100%)
diff --git a/src/data/addresses.js b/src/data/addresses.ts
similarity index 100%
rename from src/data/addresses.js
rename to src/data/addresses.ts
diff --git a/src/pages/staking/deposit-contract.js b/src/pages/staking/deposit-contract.js
index 415c45f0847..25b4e322697 100644
--- a/src/pages/staking/deposit-contract.js
+++ b/src/pages/staking/deposit-contract.js
@@ -21,7 +21,7 @@ import {
ButtonSecondary,
FakeLink,
} from "../../components/SharedStyledComponents"
-import { DEPOSIT_CONTRACT_ADDRESS } from "../../data/addresses.js"
+import { DEPOSIT_CONTRACT_ADDRESS } from "../../data/addresses"
import { translateMessageId } from "../../utils/translations"
const Page = styled.div`
From 588ef0cf4d91c7bfa612cfc633067afe2dc88445 Mon Sep 17 00:00:00 2001
From: William
Date: Sun, 29 May 2022 19:46:36 -0400
Subject: [PATCH 124/298] Migrate src/data/eth-upgrade-articles.js
---
src/data/{eth-upgrade-articles.js => eth-upgrade-articles.ts} | 0
1 file changed, 0 insertions(+), 0 deletions(-)
rename src/data/{eth-upgrade-articles.js => eth-upgrade-articles.ts} (100%)
diff --git a/src/data/eth-upgrade-articles.js b/src/data/eth-upgrade-articles.ts
similarity index 100%
rename from src/data/eth-upgrade-articles.js
rename to src/data/eth-upgrade-articles.ts
From e5914c4bc430b7970bde47befd9fdfbd934886f4 Mon Sep 17 00:00:00 2001
From: William
Date: Sun, 29 May 2022 19:56:04 -0400
Subject: [PATCH 125/298] Migrate src/api js files to ts
---
src/api/{etherscan.js => etherscan.ts} | 7 ++++++-
src/api/{etherscanBlock.js => etherscanBlock.ts} | 7 ++++++-
src/api/{l2beat.js => l2beat.ts} | 7 ++++++-
src/api/{roadmap.js => roadmap.ts} | 7 ++++++-
src/api/{translations.js => translations.ts} | 7 ++++++-
src/api/{txs.js => txs.ts} | 7 ++++++-
6 files changed, 36 insertions(+), 6 deletions(-)
rename src/api/{etherscan.js => etherscan.ts} (65%)
rename src/api/{etherscanBlock.js => etherscanBlock.ts} (65%)
rename src/api/{l2beat.js => l2beat.ts} (63%)
rename src/api/{roadmap.js => roadmap.ts} (65%)
rename src/api/{translations.js => translations.ts} (65%)
rename src/api/{txs.js => txs.ts} (65%)
diff --git a/src/api/etherscan.js b/src/api/etherscan.ts
similarity index 65%
rename from src/api/etherscan.js
rename to src/api/etherscan.ts
index 4fd1f3ddaf9..9e9b5ee0a44 100644
--- a/src/api/etherscan.js
+++ b/src/api/etherscan.ts
@@ -1,6 +1,11 @@
+import { GatsbyFunctionRequest, GatsbyFunctionResponse } from "gatsby"
+
import { lambda } from "../lambda/etherscan"
-async function handler(__req, res) {
+async function handler(
+ __req: GatsbyFunctionRequest,
+ res: GatsbyFunctionResponse
+) {
// passing env vars as arguments due to a bug on GC functions where env vars
// can not be accessed by imported functions
const { statusCode, body } = await lambda(process.env.ETHERSCAN_API_KEY)
diff --git a/src/api/etherscanBlock.js b/src/api/etherscanBlock.ts
similarity index 65%
rename from src/api/etherscanBlock.js
rename to src/api/etherscanBlock.ts
index 5e7db9ef8cc..79fa3fb5295 100644
--- a/src/api/etherscanBlock.js
+++ b/src/api/etherscanBlock.ts
@@ -1,6 +1,11 @@
+import { GatsbyFunctionRequest, GatsbyFunctionResponse } from "gatsby"
+
import { lambda } from "../lambda/etherscanBlock"
-async function handler(__req, res) {
+async function handler(
+ __req: GatsbyFunctionRequest,
+ res: GatsbyFunctionResponse
+) {
// passing env vars as arguments due to a bug on GC functions where env vars
// can not be accessed by imported functions
const { statusCode, body } = await lambda(process.env.ETHERSCAN_API_KEY)
diff --git a/src/api/l2beat.js b/src/api/l2beat.ts
similarity index 63%
rename from src/api/l2beat.js
rename to src/api/l2beat.ts
index 0f345c32ea6..eaa78d58c3a 100644
--- a/src/api/l2beat.js
+++ b/src/api/l2beat.ts
@@ -1,6 +1,11 @@
+import { GatsbyFunctionRequest, GatsbyFunctionResponse } from "gatsby"
+
import { lambda } from "../lambda/l2beat"
-async function handler(__req, res) {
+async function handler(
+ __req: GatsbyFunctionRequest,
+ res: GatsbyFunctionResponse
+) {
// passing env vars as arguments due to a bug on GC functions where env vars
// can not be accessed by imported functions
const { statusCode, body } = await lambda()
diff --git a/src/api/roadmap.js b/src/api/roadmap.ts
similarity index 65%
rename from src/api/roadmap.js
rename to src/api/roadmap.ts
index 9e713827dcf..2180c4e29c7 100644
--- a/src/api/roadmap.js
+++ b/src/api/roadmap.ts
@@ -1,6 +1,11 @@
+import { GatsbyFunctionRequest, GatsbyFunctionResponse } from "gatsby"
+
import { lambda } from "../lambda/roadmap"
-async function handler(__req, res) {
+async function handler(
+ __req: GatsbyFunctionRequest,
+ res: GatsbyFunctionResponse
+) {
// passing env vars as arguments due to a bug on GC functions where env vars
// can not be accessed by imported functions
const { statusCode, body } = await lambda(process.env.GITHUB_TOKEN)
diff --git a/src/api/translations.js b/src/api/translations.ts
similarity index 65%
rename from src/api/translations.js
rename to src/api/translations.ts
index 2f38e363b0c..116f3e0ecc3 100644
--- a/src/api/translations.js
+++ b/src/api/translations.ts
@@ -1,6 +1,11 @@
+import { GatsbyFunctionRequest, GatsbyFunctionResponse } from "gatsby"
+
import { lambda } from "../lambda/translations"
-async function handler(__req, res) {
+async function handler(
+ __req: GatsbyFunctionRequest,
+ res: GatsbyFunctionResponse
+) {
// passing env vars as arguments due to a bug on GC functions where env vars
// can not be accessed by imported functions
const { statusCode, body } = await lambda(process.env.CROWDIN_API_KEY)
diff --git a/src/api/txs.js b/src/api/txs.ts
similarity index 65%
rename from src/api/txs.js
rename to src/api/txs.ts
index 085dd6e8320..49aa0224928 100644
--- a/src/api/txs.js
+++ b/src/api/txs.ts
@@ -1,6 +1,11 @@
+import { GatsbyFunctionRequest, GatsbyFunctionResponse } from "gatsby"
+
import { lambda } from "../lambda/txs"
-async function handler(__req, res) {
+async function handler(
+ __req: GatsbyFunctionRequest,
+ res: GatsbyFunctionResponse
+) {
// passing env vars as arguments due to a bug on GC functions where env vars
// can not be accessed by imported functions
const { statusCode, body } = await lambda(process.env.ETHERSCAN_API_KEY)
From e0ad89dede99665a114b1002639f8afc4a432acb Mon Sep 17 00:00:00 2001
From: William
Date: Sun, 29 May 2022 20:34:09 -0400
Subject: [PATCH 126/298] Migrate the rest of src/lambda
---
src/lambda/{etherscan.js => etherscan.ts} | 11 ++++++++---
.../{etherscanBlock.js => etherscanBlock.ts} | 11 ++++++++---
src/lambda/{l2beat.js => l2beat.ts} | 13 +++++++++----
src/lambda/{roadmap.js => roadmap.ts} | 16 ++++++++++------
...translation-build.js => translation-build.ts} | 0
src/lambda/{translations.js => translations.ts} | 14 ++++++++------
src/lambda/{txs.js => txs.ts} | 13 +++++++++----
7 files changed, 52 insertions(+), 26 deletions(-)
rename src/lambda/{etherscan.js => etherscan.ts} (75%)
rename src/lambda/{etherscanBlock.js => etherscanBlock.ts} (68%)
rename src/lambda/{l2beat.js => l2beat.ts} (60%)
rename src/lambda/{roadmap.js => roadmap.ts} (64%)
rename src/lambda/{translation-build.js => translation-build.ts} (100%)
rename src/lambda/{translations.js => translations.ts} (60%)
rename src/lambda/{txs.js => txs.ts} (73%)
diff --git a/src/lambda/etherscan.js b/src/lambda/etherscan.ts
similarity index 75%
rename from src/lambda/etherscan.js
rename to src/lambda/etherscan.ts
index 3002ac08226..b10d7dc9642 100644
--- a/src/lambda/etherscan.js
+++ b/src/lambda/etherscan.ts
@@ -1,6 +1,8 @@
-const axios = require("axios")
+import axios from "axios"
-const lambda = async (apiKey) => {
+import type { HandlerResponse } from "@netlify/functions"
+
+const lambda = async (apiKey: string | undefined): Promise => {
const daysToFetch = 90
const now = new Date()
const endDate = now.toISOString().split("T")[0] // YYYY-MM-DD
@@ -18,7 +20,10 @@ const lambda = async (apiKey) => {
return { statusCode: 200, body: JSON.stringify(data) }
} catch (error) {
console.error(error)
- return { statusCode: 500, body: JSON.stringify({ msg: error.message }) }
+ return {
+ statusCode: 500,
+ body: JSON.stringify({ msg: (error as Error).message }),
+ }
}
}
diff --git a/src/lambda/etherscanBlock.js b/src/lambda/etherscanBlock.ts
similarity index 68%
rename from src/lambda/etherscanBlock.js
rename to src/lambda/etherscanBlock.ts
index 7070be60d65..aeb15bbb3ea 100644
--- a/src/lambda/etherscanBlock.js
+++ b/src/lambda/etherscanBlock.ts
@@ -1,6 +1,8 @@
-const axios = require("axios")
+import axios from "axios"
-const lambda = async (apiKey) => {
+import type { HandlerResponse } from "@netlify/functions"
+
+const lambda = async (apiKey: string | undefined): Promise => {
try {
const response = await axios.get(
`https://api.etherscan.io/api?module=block&action=getblockcountdown&blockno=12965000&apikey=${apiKey}`
@@ -16,7 +18,10 @@ const lambda = async (apiKey) => {
}
} catch (error) {
console.error(error)
- return { statusCode: 500, body: JSON.stringify({ msg: error.message }) }
+ return {
+ statusCode: 500,
+ body: JSON.stringify({ msg: (error as Error).message }),
+ }
}
}
diff --git a/src/lambda/l2beat.js b/src/lambda/l2beat.ts
similarity index 60%
rename from src/lambda/l2beat.js
rename to src/lambda/l2beat.ts
index 631eb3bf802..8a144bc93d9 100644
--- a/src/lambda/l2beat.js
+++ b/src/lambda/l2beat.ts
@@ -1,6 +1,8 @@
-const axios = require("axios")
+import axios from "axios"
-const lambda = async () => {
+import type { HandlerResponse } from "@netlify/functions"
+
+const lambda = async (): Promise => {
try {
const response = await axios.get(`https://l2beat.com/api/tvl.json`)
if (response.status < 200 || response.status >= 300) {
@@ -14,7 +16,10 @@ const lambda = async () => {
}
} catch (error) {
console.error(error)
- return { statusCode: 500, body: JSON.stringify({ msg: error.message }) }
+ return {
+ statusCode: 500,
+ body: JSON.stringify({ msg: (error as Error).message }),
+ }
}
}
@@ -22,4 +27,4 @@ const handler = () => {
return lambda()
}
-module.exports = { handler, lambda }
+export { handler, lambda }
diff --git a/src/lambda/roadmap.js b/src/lambda/roadmap.ts
similarity index 64%
rename from src/lambda/roadmap.js
rename to src/lambda/roadmap.ts
index 0a782f46ac1..eb7865ec15c 100644
--- a/src/lambda/roadmap.js
+++ b/src/lambda/roadmap.ts
@@ -1,6 +1,10 @@
-const axios = require("axios")
+import axios from "axios"
-const lambda = async function (githubToken) {
+import type { HandlerResponse } from "@netlify/functions"
+
+const lambda = async (
+ githubToken: string | undefined
+): Promise => {
try {
const baseURL =
"https://api.github.com/repos/ethereum/ethereum-org-website/issues?per_page=100&state=all"
@@ -20,11 +24,11 @@ const lambda = async function (githubToken) {
statusCode: 200,
body: JSON.stringify({ data }),
}
- } catch (err) {
- console.log(err) // output to netlify function log
+ } catch (error) {
+ console.log(error) // output to netlify function log
return {
statusCode: 500,
- body: JSON.stringify({ msg: err.message }),
+ body: JSON.stringify({ msg: (error as Error).message }),
}
}
}
@@ -33,4 +37,4 @@ const handler = () => {
return lambda(process.env.GITHUB_TOKEN)
}
-module.exports = { handler, lambda }
+export { handler, lambda }
diff --git a/src/lambda/translation-build.js b/src/lambda/translation-build.ts
similarity index 100%
rename from src/lambda/translation-build.js
rename to src/lambda/translation-build.ts
diff --git a/src/lambda/translations.js b/src/lambda/translations.ts
similarity index 60%
rename from src/lambda/translations.js
rename to src/lambda/translations.ts
index a1fa4b3c44e..cd684d4ea32 100644
--- a/src/lambda/translations.js
+++ b/src/lambda/translations.ts
@@ -1,6 +1,8 @@
-const axios = require("axios")
+import axios from "axios"
-const lambda = async function (apiKey) {
+import type { HandlerResponse } from "@netlify/functions"
+
+const lambda = async (apiKey: string | undefined): Promise => {
try {
const baseURL = "https://api.crowdin.com/api/project/ethereum-org/status"
@@ -15,11 +17,11 @@ const lambda = async function (apiKey) {
statusCode: 200,
body: JSON.stringify({ data }),
}
- } catch (err) {
- console.log(err) // output to netlify function log
+ } catch (error) {
+ console.log(error) // output to netlify function log
return {
statusCode: 500,
- body: JSON.stringify({ msg: err.message }),
+ body: JSON.stringify({ msg: (error as Error).message }),
}
}
}
@@ -28,4 +30,4 @@ const handler = () => {
return lambda(process.env.CROWDIN_API_KEY)
}
-module.exports = { handler, lambda }
+export { handler, lambda }
diff --git a/src/lambda/txs.js b/src/lambda/txs.ts
similarity index 73%
rename from src/lambda/txs.js
rename to src/lambda/txs.ts
index 1710aab68fd..610cc250d38 100644
--- a/src/lambda/txs.js
+++ b/src/lambda/txs.ts
@@ -1,6 +1,8 @@
-const axios = require("axios")
+import axios from "axios"
-const lambda = async (apiKey) => {
+import type { HandlerResponse } from "@netlify/functions"
+
+const lambda = async (apiKey: string | undefined): Promise => {
try {
const daysToFetch = 90
const now = new Date()
@@ -21,7 +23,10 @@ const lambda = async (apiKey) => {
}
} catch (error) {
console.error(error)
- return { statusCode: 500, body: JSON.stringify({ msg: error.message }) }
+ return {
+ statusCode: 500,
+ body: JSON.stringify({ msg: (error as Error).message }),
+ }
}
}
@@ -29,4 +34,4 @@ const handler = () => {
return lambda(process.env.ETHERSCAN_API_KEY)
}
-module.exports = { handler, lambda }
+export { handler, lambda }
From 37612415e31d798ed4cb8091f1e1ce5525c3b559 Mon Sep 17 00:00:00 2001
From: William
Date: Sun, 29 May 2022 20:42:24 -0400
Subject: [PATCH 127/298] Migrate src/utils/calculateStakingRewards.js
---
.../{calculateStakingRewards.js => calculateStakingRewards.ts} | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
rename src/utils/{calculateStakingRewards.js => calculateStakingRewards.ts} (96%)
diff --git a/src/utils/calculateStakingRewards.js b/src/utils/calculateStakingRewards.ts
similarity index 96%
rename from src/utils/calculateStakingRewards.js
rename to src/utils/calculateStakingRewards.ts
index 479edab1e63..13af22b5e77 100644
--- a/src/utils/calculateStakingRewards.js
+++ b/src/utils/calculateStakingRewards.ts
@@ -1,4 +1,4 @@
-const calculateStakingRewards = (totalAtStake) => {
+const calculateStakingRewards = (totalAtStake: number) => {
const slotTimeInSec = 12
const slotsInEpoch = 32
const baseRewardFactor = 64
From 3e352857bed4750e9544e4fcf6bc680cac2acfa1 Mon Sep 17 00:00:00 2001
From: Joseph Cook <33655003+jmcook1186@users.noreply.github.com>
Date: Mon, 30 May 2022 10:35:39 +0100
Subject: [PATCH 128/298] add a couple of links
---
.../community/get-involved/open-research/index.md | 12 +++++++++++-
1 file changed, 11 insertions(+), 1 deletion(-)
diff --git a/src/content/community/get-involved/open-research/index.md b/src/content/community/get-involved/open-research/index.md
index b55dd44156c..f4f6fc9fe25 100644
--- a/src/content/community/get-involved/open-research/index.md
+++ b/src/content/community/get-involved/open-research/index.md
@@ -11,7 +11,7 @@ One of the primary strengths of Ethereum is that it is constantly being improved
## General research resources
-Regardless of the specific topic, there is a wealth of information on Ethereum research to be found at [ethresear.ch](https://ethresear.ch) and the [Eth R&D Discord channel](https://discord.gg/n7JxAeRu). These are the primary places where Ethereum researchers discuss the latest ideas and development opportunities.
+Regardless of the specific topic, there is a wealth of information on Ethereum research to be found at [ethresear.ch](https://ethresear.ch) and the [Eth R&D Discord channel](https://discord.gg/n7JxAeRu). This report from [DelphiDigital](https://members.delphidigital.io/reports/the-hitchhikers-guide-to-ethereum) also covers a lot of ground. These are the primary places where Ethereum researchers discuss the latest ideas and development opportunities.
## Scaling and performance
@@ -35,6 +35,8 @@ There are now several Layer 2 protocols that scale Ethereum using different tech
[ethresear.ch Layer 2](https://ethresear.ch/c/layer-2/32)
+[Rollup-centric roadmap](https://ethereum-magicians.org/t/a-rollup-centric-ethereum-roadmap/4698)
+
### Bridges
@@ -246,6 +248,8 @@ Ethereum transaction fees protect the network from spam, denial-of-service attac
[Making EIP-1559 more like an AMM curve](https://ethresear.ch/t/make-eip-1559-more-like-an-amm-curve/9082)
+[Cross domain MEV](http://arxiv.org/abs/2112.01472)
+
## Clients and protocol research
@@ -283,6 +287,8 @@ The consensus layer is concerned with the proof-of-stake mechanism securing Ethe
[Single slot finality](https://ethresear.ch/t/a-model-for-cumulative-committee-based-finality/10259)
+[Proposer-builder separation](https://notes.ethereum.org/@vbuterin/pbs_censorship_resistance)
+
### Execution clients
@@ -310,6 +316,10 @@ The execution layer is concerned with executing transactions, running the EVM an
[History management](https://eips.ethereum.org/EIPS/eip-4444)
+[Verkle Trees](https://vitalik.ca/general/2021/06/18/verkle.html)
+
+[Data availability sampling](https://github.com/ethereum/research/wiki/A-note-on-data-availability-and-erasure-coding)
+
### Formal verification
From f6c36d81300db4c650b139edd4d5ca0daada8629 Mon Sep 17 00:00:00 2001
From: Emmanuel Awosika
Date: Mon, 30 May 2022 11:07:21 +0100
Subject: [PATCH 129/298] Add new information to Validium page
I added a detailed description of the Validium scaling solution and briefly explained the differences between validiums and ZK-rollups. The update also contains an explanation of volitions (scaling solutions that allow users to choose between a validium and a ZK-rollup).
---
.../developers/docs/scaling/validium/index.md | 54 +++++++++++++++----
1 file changed, 44 insertions(+), 10 deletions(-)
diff --git a/src/content/developers/docs/scaling/validium/index.md b/src/content/developers/docs/scaling/validium/index.md
index bcd6f0270ec..89f78332993 100644
--- a/src/content/developers/docs/scaling/validium/index.md
+++ b/src/content/developers/docs/scaling/validium/index.md
@@ -7,30 +7,64 @@ incomplete: true
sidebarDepth: 3
---
-Uses validity proofs like [ZK-rollups](/developers/docs/scaling/zk-rollups/) but data is not stored on the main layer 1 Ethereum chain. This can lead to 10k transactions per second per validium chain and multiple chains can be run in parallel.
+Validium is a [scaling solution](/developers/docs/scaling/) that enforces integrity of transactions using validity proofs like [ZK-rollups](/developers/docs/scaling/zk-rollups/), but doesn’t store transaction data on the main Ethereum layer. While off-chain data availability introduces trade-offs, it can lead to massive improvements in scalability (validiums can process ~ 9,000 transactions, or more, per second).
## Prerequisites {#prerequisites}
You should have a good understanding of all the foundational topics and a high-level understanding of [Ethereum scaling](/developers/docs/scaling/). Implementing scaling solutions such as Validium is an advanced topic as the technology is less battle-tested, and continues to be researched and developed.
-## Pros and cons {#pros-and-cons}
+## How does validium work? {#how-does-validium work}
+Validiums are a type of “rollup”: a [Layer 2](/layer-2/) scaling protocol designed to improve throughput by processing transactions off the main Ethereum chain. Off-chain transactions executed on the validium chain are verified via a smart contract on the base Ethereum layer using zero-knowledge proofs. This can be either a SNARK (Succinct Non-Interactive Argument of Knowledge) or SNARK (Scalable Transparent Argument of Knowledge).
+
+As with ZK-rollups, validity proofs prevent invalid state transitions on validium chains and enhance security guarantees available to users. For instance, a malicious operator cannot steal funds since users can always withdraw funds directly from the on-chain contract [using Merkle proofs](/developers/tutorials/merkle-proofs-for-offline-data-integrity/).
+
+The major difference between validiums and ZK-rollups concerns their positions on the data availability spectrum. Both solutions approach data storage differently, which has implications for security and trustlessness.
+
+### Off-chain vs on-chain data availability {#off-chain-vs-on-chain-data-availability}
+
+ZK-rollups post information about off-transactions to Ethereum Mainnet as `calldata`. This information can be used to recreate the state of the rollup, if necessary, to prove the validity (or lack thereof) of a specific state transition. As the data is anchored on Ethereum (on-chain data availability), ZK-rollups can directly benefit from Ethereum’s security guarantees—funds are always secure if Mainnet is operational.
+
+Validiums keep all data relating to transactions off the Ethereum chain (off-chain data availability). This improves throughput on validium chains since less data needs to be posted to Mainnet. It also reduces rollup costs by eliminating the need to publish calldata and increases privacy for users (transaction information doesn't make it to Mainnet).
+
+Off-chain data availability does present a problem: data necessary for creating Merkle proofs may be unavailable. This means users may be unable to withdraw funds from the rollup contract if operators should act maliciously.
+
+To guarantee the availability of off-chain data, some validium solutions use a group of trusted entities to store copies of the state and provide proof of data availability. Of course, this presents another problem: users must trust these entities to make the data available when needed. There's also the possibility of members of data availability committees [getting compromised by a malicious actor](https://notes.ethereum.org/DD7GyItYQ02d0ax_X-UbWg?view) who can then withhold off-chain data.
+
+Other validiums require participants charged with storing offline data to provide a “bond” to reduce trust assumptions. If these participants fail to prove data availability, the bond is slashed. This approach relies on cryptoeconomic incentives and is considerably more secure than appointing trusted parties to secure offline data in the validium.
+
+## Volitions and validium
+
+Validiums offer many benefits, but come with trade-offs (most notably, data availability). But, as with many scaling solutions, validiums are suited to specific use-cases—which is why volitions were created.
+
+Volitions combine a ZK-rollups and validium chain and allow users to switch between the two scaling solutions. With volitions, users can take advantage of validium's off-chain data availability for certain transactions, while retaining the freedom to switch to an on-chain data availability solution (ZK-rollup) if needed. This essentially gives users freedom to choose trade-offs as dictated by their unique circumstances.
+
+A decentralized exchange (DEX) may prefer using a validium’s scalable and private infrastructure for high-value trades. It can also use a ZK-rollup for users who want a ZK-rollup's higher security guarantees and trustlessness.
+
+## Pros and cons of validium {#pros-and-cons-of-validium}
| Pros | Cons |
| --------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| No withdrawal delay (no latency to on-chain/cross-chain tx); consequent greater capital efficiency. | Limited support for general computation/smart contracts; specialized languages required. |
| Not vulnerable to certain economic attacks faced by fraud-proof based systems in high-value applications. | High computational power required to generate ZK proofs; not cost effective for low throughput applications. |
-| | Slower subjective finality time (10-30 min to generate a ZK proof) (but faster to full finality because there is no dispute time delay). |
-| | Generating a proof requires off-chain data to be available at all times. |
+| Reduces rollup fees for users by shrinking costs of publishing data on Ethereum. | Slower subjective finality time (10-30 min to generate a ZK proof) (but faster to full finality because there is no dispute time delay). |
+| Suitable for specific use-cases, like trading or blockchain gaming that prioritize transaction privacy and scalability. | Generating a proof requires off-chain data to be available at all times. |
+| | Security relies on trust assumptions and cryptoeconomic incentives, unlike ZK-rollups which rely on cryptographic security mechanisms.
+
+### Use Validium/Volitions {#use-validium-and-volitions}
-### Use Validium {#use-validium}
+Multiple projects provide implementations of Validium and volitions that you can integrate into your dapps:
-Multiple projects provide implementations of Validium that you can integrate into your dapps:
+**StarkWare StarkEx** - _StarkEx is an Ethereum Layer 2 (L2) scalability solution that is based on validity proofs. It can operate in either ZK-Rollup or Validium data-availability modes._
+- [Documentation](https://docs.starkware.co/starkex-v4/starkex-deep-dive/data-availability-modes#validium)
+- [Website](https://starkware.co/starkex/)
-- [Starkware](https://starkware.co/)
-- [Matter Labs zkPorter](https://matter-labs.io/)
+**Matter Labs zkPorter**- _zkPorter is a Layer 2 scaling protocol tackling data availability with a hybrid approach that combines the ideas of zkRollup and sharding. It can support arbitrarily many shards, each with its own data availability policy._
+- [Documentation](https://docs.zksync.io/zkevm/#what-is-zkporter)
+- [Website](https://zksync.io/)
## Further reading {#further-reading}
- [Validium And The Layer 2 Two-By-Two — Issue No. 99](https://www.buildblockchain.tech/newsletter/issues/no-99-validium-and-the-layer-2-two-by-two)
-
-_Know of a community resource that helped you? Edit this page and add it!_
+- [ZK-rollups vs Validium](https://blog.matter-labs.io/zkrollup-vs-validium-starkex-5614e38bc263)
+- [Volition and the Emerging Data Availability spectrum](https://medium.com/starkware/volition-and-the-emerging-data-availability-spectrum-87e8bfa09bb)
+- [Rollups, Validiums and Volitions: Learn About the Hottest Ethereum Scaling Solutions](https://www.defipulse.com/blog/rollups-validiums-and-volitions-learn-about-the-hottest-ethereum-scaling-solutions)
From 697ee2bc69ce0d4227441900f149e7cfbdb01921 Mon Sep 17 00:00:00 2001
From: "allcontributors[bot]"
<46447321+allcontributors[bot]@users.noreply.github.com>
Date: Mon, 30 May 2022 10:53:22 +0000
Subject: [PATCH 130/298] docs: update README.md [skip ci]
---
README.md | 1 +
1 file changed, 1 insertion(+)
diff --git a/README.md b/README.md
index 8427308c924..f753c56fb50 100644
--- a/README.md
+++ b/README.md
@@ -1230,6 +1230,7 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
From 55c2234bb13f28c91a84b8bf5484be7d8ed08650 Mon Sep 17 00:00:00 2001
From: "allcontributors[bot]"
<46447321+allcontributors[bot]@users.noreply.github.com>
Date: Mon, 30 May 2022 10:53:23 +0000
Subject: [PATCH 131/298] docs: update .all-contributorsrc [skip ci]
---
.all-contributorsrc | 10 ++++++++++
1 file changed, 10 insertions(+)
diff --git a/.all-contributorsrc b/.all-contributorsrc
index 11cd5559648..0fff3c6246d 100644
--- a/.all-contributorsrc
+++ b/.all-contributorsrc
@@ -7589,6 +7589,16 @@
"contributions": [
"doc"
]
+ },
+ {
+ "login": "avcdsld",
+ "name": "Takamasa Arakawa",
+ "avatar_url": "https://avatars.githubusercontent.com/u/10495516?v=4",
+ "profile": "https://github.com/avcdsld",
+ "contributions": [
+ "code",
+ "bug"
+ ]
}
],
"contributorsPerLine": 7,
From 662ce2d671490f912127eb0e1b18da9e49bb9ba9 Mon Sep 17 00:00:00 2001
From: Joshua <62268199+minimalsm@users.noreply.github.com>
Date: Mon, 30 May 2022 12:18:59 +0100
Subject: [PATCH 132/298] Apply suggestions from code review
---
src/data/externalTutorials.json | 20 +++++++-------------
1 file changed, 7 insertions(+), 13 deletions(-)
diff --git a/src/data/externalTutorials.json b/src/data/externalTutorials.json
index 82d3d3ad250..41effae1e1a 100644
--- a/src/data/externalTutorials.json
+++ b/src/data/externalTutorials.json
@@ -2,7 +2,7 @@
{
"url": "https://www.youtube.com/watch?v=gyMwXuJrbJQ",
"title": "Learn Blockchain, Solidity, and Full Stack Web3 Development with JavaScript ",
- "description": "This course will give you a full introduction into all of the core concepts related to blockchain, smart contracts, Solidity, ERC20s, full-stack Web3 dapps, decentralized finance (DeFi), JavaScript, TypeScript, Chainlink, Ethereum, upgradable smart contracts, DAOs, the graph, moralis, aave, IPFS, and more. Follow along with the videos and you'll be a blockchain wizard in no time! ",
+ "description": "This course will give you a full introduction to all of the core concepts related to blockchain, smart contracts, Solidity, ERC20s, full-stack Web3 dapps, DeFi, JavaScript, TypeScript, Chainlink, Ethereum, upgradable smart contracts, DAOs, the graph, Moralis, Aave, IPFS, and more. Follow along with the videos and you'll be a blockchain wizard in no time!",
"author": "Patrick Collins",
"authorGithub": "https://github.com/PatrickAlphaC",
"tags": [
@@ -28,7 +28,6 @@
"slither",
"echidna",
"filecoin",
- "web3uikit",
"moralis",
"alchemy",
"the graph",
@@ -75,10 +74,10 @@
{
"url": "https://www.youtube.com/watch?v=fNMfMxGxeag",
"title": "Introduction to Foundry",
- "description": "We build a minimal foundry project using a staking application. Showing you how to work with foundry. ",
+ "description": "We build a minimal Foundry project using a staking application to show you how to work with Foundry.",
"author": "Patrick Collins",
"authorGithub": "https://github.com/PatrickAlphaC",
- "tags": ["solidity", "foundry", "bash", "video"],
+ "tags": ["solidity", "foundry", "video"],
"skillLevel": "beginner",
"timeToRead": "19",
"lang": "en",
@@ -86,8 +85,8 @@
},
{
"url": "https://www.youtube.com/watch?v=pdsYCkUWrgQ",
- "title": "How to Connect your Smart Contracts to Metamask | Full Stack Web3",
- "description": "We learn exactly how web3 / blockchain / smart contract applications work in the front end using HTML and Javascript. We then go through 6 different ways you can connect your Metamask, Phantom, or other blockchain wallet address to your front end. We’ll look at popular Nextjs / React packages to make your development lifecycle 100 times easier. ",
+ "title": "How to Connect your Smart Contracts to Metamask",
+ "description": "We learn exactly how web3 / blockchain / smart contract applications work in the front end using HTML and Javascript. We then go through 6 different ways you can connect your Metamask, Phantom, or other blockchain wallet address to your front end. We’ll look at popular Nextjs / React packages to make your development lifecycle 100 times easier.",
"author": "Patrick Collins",
"authorGithub": "https://github.com/PatrickAlphaC",
"tags": [
@@ -95,14 +94,11 @@
"javascript",
"hardhat",
"metamask",
- "html",
"nextjs",
"reactjs",
"moralis",
- "web3modal",
"web3-react",
"ethersjs",
- "usedapp",
"video"
],
"skillLevel": "beginner",
@@ -113,7 +109,7 @@
{
"url": "https://www.youtube.com/watch?v=pdsYCkUWrgQ",
"title": "How to build an on-chain DAO",
- "description": "Using Compound and Openzeppelin as a basis, we build a 100% on-chain DAO using an ERC20 governance token for votes. ",
+ "description": "Using Compound and Openzeppelin as a basis, we build a 100% on-chain DAO using an ERC20 governance token for votes.",
"author": "Patrick Collins",
"authorGithub": "https://github.com/PatrickAlphaC",
"tags": [
@@ -133,7 +129,7 @@
{
"url": "https://betterprogramming.pub/how-to-code-an-on-chain-dao-e525e13a57be",
"title": "How to build an on-chain DAO",
- "description": "Using Compound and Openzeppelin as a basis, we build a 100% on-chain DAO using an ERC20 governance token for votes. ",
+ "description": "Using Compound and Openzeppelin as a basis, we build a 100% on-chain DAO using an ERC20 governance token for votes.",
"author": "Patrick Collins",
"authorGithub": "https://github.com/PatrickAlphaC",
"tags": [
@@ -160,14 +156,12 @@
"javascript",
"hardhat",
"metamask",
- "html",
"nextjs",
"reactjs",
"moralis",
"web3modal",
"web3-react",
"ethersjs",
- "usedapp"
],
"skillLevel": "beginner",
"timeToRead": "14",
From e094267ee5ebe25b5156e4d3fc241158474e18b2 Mon Sep 17 00:00:00 2001
From: Joshua <62268199+minimalsm@users.noreply.github.com>
Date: Mon, 30 May 2022 12:20:13 +0100
Subject: [PATCH 133/298] Update
src/content/developers/docs/scaling/plasma/index.md
---
src/content/developers/docs/scaling/plasma/index.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/content/developers/docs/scaling/plasma/index.md b/src/content/developers/docs/scaling/plasma/index.md
index 21a918b4815..b0b9dd5be68 100644
--- a/src/content/developers/docs/scaling/plasma/index.md
+++ b/src/content/developers/docs/scaling/plasma/index.md
@@ -32,7 +32,7 @@ Plasma, sidechains, and sharding are fairly similar because they all connect to
A [sidechain](/developers/docs/scaling/sidechains/) is an independently operated blockchain connected to Ethereum Mainnet via a two-way bridge. [Bridges](/bridges/) allow users to exchange tokens between the two blockchains to transact on the sidechain, reducing congestion on Ethereum Mainnet and improving scalability.
Sidechains use a separate consensus mechanism and are typically much smaller than Ethereum Mainnet. As a result, bridging assets to these chains involves increased risk; given the lack of security guarantees inherited from Ethereum Mainnet in the sidechain model, users risk the loss of funds in an attack on the sidechain.
-Conversely, plasma chains derive their security from Mainnet are somewhat safer than sidechains. Both sidechains and plasma chains can have different consensus protocols, but the difference is that plasma chains publishes Merkle roots for each block on Ethereum Mainnet. Block roots are small pieces of information we can use to verify information about transactions that happen on a plasma chain. If an attack happens on a plasma chain, users can safely exit to Mainnet and withdraw their funds using the appropriate proofs.
+Conversely, plasma chains derive their security from Mainnet. This makes them measurably more secure than sidechains. Both sidechains and plasma chains can have different consensus protocols, but the difference is that plasma chains publish Merkle roots for each block on Ethereum Mainnet. Block roots are small pieces of information we can use to verify information about transactions that happen on a plasma chain. If an attack happens on a plasma chain, users can safely withdraw their funds back to Mainnet using the appropriate proofs.
### Plasma vs sharding {#plasma-vs-sharding}
From 729d8ac9d65cdcef0ce2dfb808c781569340b025 Mon Sep 17 00:00:00 2001
From: "allcontributors[bot]"
<46447321+allcontributors[bot]@users.noreply.github.com>
Date: Mon, 30 May 2022 12:53:06 +0000
Subject: [PATCH 134/298] docs: update README.md [skip ci]
---
README.md | 1 +
1 file changed, 1 insertion(+)
diff --git a/README.md b/README.md
index f753c56fb50..9a71b2348af 100644
--- a/README.md
+++ b/README.md
@@ -1231,6 +1231,7 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
From 252e310866ddd32aeee3187d6730a7155286990e Mon Sep 17 00:00:00 2001
From: "allcontributors[bot]"
<46447321+allcontributors[bot]@users.noreply.github.com>
Date: Mon, 30 May 2022 12:58:07 +0000
Subject: [PATCH 137/298] docs: update .all-contributorsrc [skip ci]
---
.all-contributorsrc | 9 +++++++++
1 file changed, 9 insertions(+)
diff --git a/.all-contributorsrc b/.all-contributorsrc
index 26ca3900fb5..dbe2ac0f152 100644
--- a/.all-contributorsrc
+++ b/.all-contributorsrc
@@ -7608,6 +7608,15 @@
"contributions": [
"doc"
]
+ },
+ {
+ "login": "pcowgill",
+ "name": "Paul Cowgill",
+ "avatar_url": "https://avatars.githubusercontent.com/u/2731712?v=4",
+ "profile": "https://paulcowgill.com",
+ "contributions": [
+ "doc"
+ ]
}
],
"contributorsPerLine": 7,
From 5ab3b0e29b0d1942498b3a8ce73dd214aa03014a Mon Sep 17 00:00:00 2001
From: Joshua <30259508@cityofglacol.ac.uk>
Date: Mon, 30 May 2022 14:27:59 +0100
Subject: [PATCH 138/298] Fix uniswap docs link
---
.../uniswap-v2-annotated-code/index.md | 4 +-
.../uniswap-v2-annotated-code/index.md | 2 +-
.../uniswap-v2-annotated-code/index.md | 2 +-
.../uniswap-v2-annotated-code/index.md | 2 +-
.../uniswap-v2-annotated-code/index.md | 44 +++++++++----------
.../uniswap-v2-annotated-code/index.md | 2 +-
6 files changed, 28 insertions(+), 28 deletions(-)
diff --git a/src/content/developers/tutorials/uniswap-v2-annotated-code/index.md b/src/content/developers/tutorials/uniswap-v2-annotated-code/index.md
index 8d6b9a5dc16..b30ec19e106 100644
--- a/src/content/developers/tutorials/uniswap-v2-annotated-code/index.md
+++ b/src/content/developers/tutorials/uniswap-v2-annotated-code/index.md
@@ -23,7 +23,7 @@ _Traders_ send one type of token to the pool and receive the other (for example,
When liquidity providers want their assets back they can burn the pool tokens and receive back their tokens, including their share of the rewards.
-[Click here for a fuller description](https://uniswap.org/docs/v2/core-concepts/swaps/).
+[Click here for a fuller description](https://docs.uniswap.org/protocol/V2/concepts/core-concepts/swaps/).
### Why v2? Why not v3? {#why-v2}
@@ -50,7 +50,7 @@ This is most common flow, used by traders:
1. Provide the periphery account with an allowance in the amount to be swapped.
2. Call one of the periphery contract's many swap functions (which one depends on whether ETH is involved or not, whether the trader specifies the amount of tokens to deposit or the amount of tokens to get back, etc).
-Every swap function accepts a `path`, an array of exchanges to go through.
+ Every swap function accepts a `path`, an array of exchanges to go through.
#### In the periphery contract (UniswapV2Router02.sol) {#in-the-periphery-contract-uniswapv2router02-sol}
diff --git a/src/content/translations/id/developers/tutorials/uniswap-v2-annotated-code/index.md b/src/content/translations/id/developers/tutorials/uniswap-v2-annotated-code/index.md
index c6472d25c70..26d62bdcee4 100644
--- a/src/content/translations/id/developers/tutorials/uniswap-v2-annotated-code/index.md
+++ b/src/content/translations/id/developers/tutorials/uniswap-v2-annotated-code/index.md
@@ -25,7 +25,7 @@ _Pedagang_ mengirimkan satu jenis token ke pool dan menerima token lainnya (cont
Ketika penyedia likuiditas menginginkan kembali aset mereka, mereka dapat membakar token pool dan menerima kembali token mereka, termasuk bagian imbalan mereka.
-[Klik di sini untuk deskripsi lengkapnya](https://uniswap.org/docs/v2/core-concepts/swaps/).
+[Klik di sini untuk deskripsi lengkapnya](https://docs.uniswap.org/protocol/V2/concepts/core-concepts/swaps/).
### Mengapa v2? Mengapa bukan v3? {#why-v2}
diff --git a/src/content/translations/it/developers/tutorials/uniswap-v2-annotated-code/index.md b/src/content/translations/it/developers/tutorials/uniswap-v2-annotated-code/index.md
index 23072dfe949..384da9ec60a 100644
--- a/src/content/translations/it/developers/tutorials/uniswap-v2-annotated-code/index.md
+++ b/src/content/translations/it/developers/tutorials/uniswap-v2-annotated-code/index.md
@@ -25,7 +25,7 @@ I _trader_ inviano un tipo di token al pool e ricevono l'altro (ad esempio, invi
Quando i fornitori di liquidità rivogliono indietro le loro risorse, possono bruciare i token del pool e ricevere i token, compresa la quota di ricompense.
-[Clicca qui per una descrizione completa](https://uniswap.org/docs/v2/core-concepts/swaps/).
+[Clicca qui per una descrizione completa](https://docs.uniswap.org/protocol/V2/concepts/core-concepts/swaps/).
### Perché v2? Perché non v3? {#why-v2}
diff --git a/src/content/translations/ro/developers/tutorials/uniswap-v2-annotated-code/index.md b/src/content/translations/ro/developers/tutorials/uniswap-v2-annotated-code/index.md
index b67f95361d5..4fc9c8b0a8e 100644
--- a/src/content/translations/ro/developers/tutorials/uniswap-v2-annotated-code/index.md
+++ b/src/content/translations/ro/developers/tutorials/uniswap-v2-annotated-code/index.md
@@ -25,7 +25,7 @@ _Comercianții_ trimit un tip de token la fondul comun și îl primesc pe celăl
Când furnizorii de lichidităţi își vor înapoi activele, aceștia pot arde tokenurile fondului comun și îşi pot primi înapoi tokenurile, inclusiv partea lor de recompense.
-[Faceți clic aici pentru a vedea o descriere completă](https://uniswap.org/docs/v2/core-concepts/swaps/).
+[Faceți clic aici pentru a vedea o descriere completă](https://docs.uniswap.org/protocol/V2/concepts/core-concepts/swaps/).
### De ce v2? De ce nu v3? {#why-v2}
diff --git a/src/content/translations/tr/developers/tutorials/uniswap-v2-annotated-code/index.md b/src/content/translations/tr/developers/tutorials/uniswap-v2-annotated-code/index.md
index 13681170eff..828fc0ff42a 100644
--- a/src/content/translations/tr/developers/tutorials/uniswap-v2-annotated-code/index.md
+++ b/src/content/translations/tr/developers/tutorials/uniswap-v2-annotated-code/index.md
@@ -25,7 +25,7 @@ _Ticaret yapanlar_, havuza bir tür token gönderir ve (örneğin, **Token0** g
Likidite sağlayıcıları varlıklarını geri istediklerinde havuz token'larını yakabilir ve ödül payları da dahil olmak üzere token'larını geri alabilirler.
-[Daha geniş çaplı bir açıklama için buraya tıklayın](https://uniswap.org/docs/v2/core-concepts/swaps/).
+[Daha geniş çaplı bir açıklama için buraya tıklayın](https://docs.uniswap.org/protocol/V2/concepts/core-concepts/swaps/).
### Neden v2? Neden v3 değil? {#why-v2}
@@ -204,13 +204,13 @@ Eş takasının token0 ve token1 arasındaki takas oranına karar verme yöntemi
İşte basit bir örnek. Basitlik adına, tablonun ondalık kısmından sonra yalnızca üç haneye sahip olduğunu ve sayıların doğru olmaması için %0,3 işlem ücretini göz ardı ettiğimizi unutmayın.
| Olay | reserve0 | reserve1 | reserve0 \* reserve1 | Ortalama takas oranı (token1 / token0) |
-| --------------------------------------------------------------- | ---------:| ---------:| ----------------------:| -------------------------------------- |
-| İlk kurulum | 1,000.000 | 1,000.000 | 1,000,000 | |
-| Ticaret Yapan A, 50 tane token0'ı 47.619 token1 ile takas eder | 1,050.000 | 952.381 | 1,000,000 | 0.952 |
-| Ticaret Yapan B, 10 tane token0'ı 8.984 token1 ile takas eder | 1,060.000 | 943.396 | 1,000,000 | 0.898 |
-| Ticaret Yapan C, 40 tane token0'ı 34.305 token1 ile takas eder | 1,100.000 | 909.090 | 1,000,000 | 0.858 |
-| Ticaret Yapan D, 109.01 tane token0'ı 100 token1 ile takas eder | 990.990 | 1,009.090 | 1,000,000 | 0.917 |
-| Ticaret Yapan E, 10 tane token0'ı 10.079 token1 ile takas eder | 1,000.990 | 999.010 | 1,000,000 | 1.008 |
+| --------------------------------------------------------------- | --------: | --------: | -------------------: | -------------------------------------- |
+| İlk kurulum | 1,000.000 | 1,000.000 | 1,000,000 | |
+| Ticaret Yapan A, 50 tane token0'ı 47.619 token1 ile takas eder | 1,050.000 | 952.381 | 1,000,000 | 0.952 |
+| Ticaret Yapan B, 10 tane token0'ı 8.984 token1 ile takas eder | 1,060.000 | 943.396 | 1,000,000 | 0.898 |
+| Ticaret Yapan C, 40 tane token0'ı 34.305 token1 ile takas eder | 1,100.000 | 909.090 | 1,000,000 | 0.858 |
+| Ticaret Yapan D, 109.01 tane token0'ı 100 token1 ile takas eder | 990.990 | 1,009.090 | 1,000,000 | 0.917 |
+| Ticaret Yapan E, 10 tane token0'ı 10.079 token1 ile takas eder | 1,000.990 | 999.010 | 1,000,000 | 1.008 |
Ticaret yapanlar daha fazla token0 sağladıkça, arz ve talebe bağlı olarak token1'in göreceli değeri artar ve bunun tersi de aynı şekilde işler.
@@ -366,10 +366,10 @@ Geçen süre sıfır değilse, bu bloktaki ilk takas işlemi biziz demektir. Bu
Her maliyet biriktirici, son ücret ve (diğer token'ın rezervi/bu token'ın rezervi) saniye cinsinden geçen sürenin çarpımı ile güncellenir. Ortalama bir fiyat elde etmek için kümülatif fiyatın zaman içinde iki nokta olduğunu okursunuz ve aralarındaki zaman farkına bölersiniz. Örneğin, bu olay dizisini varsayalım:
-| Olay | reserve0 | reserve1 | zaman damgası | Marjinal takas oranı (reserve1 / reserve0) | price0CumulativeLast |
-| -------------------------------------------------------------- | ---------:| ---------:| ------------- | ------------------------------------------:| ----------------------------:|
-| İlk kurulum | 1,000.000 | 1,000.000 | 5,000 | 1.000 | 0 |
-| Ticaret Yapan A, 50 token0 yatırır ve 47.619 token1 geri alır | 1,050.000 | 952.381 | 5,020 | 0.907 | 20 |
+| Olay | reserve0 | reserve1 | zaman damgası | Marjinal takas oranı (reserve1 / reserve0) | price0CumulativeLast |
+| -------------------------------------------------------------- | --------: | --------: | ------------- | -----------------------------------------: | -------------------------: |
+| İlk kurulum | 1,000.000 | 1,000.000 | 5,000 | 1.000 | 0 |
+| Ticaret Yapan A, 50 token0 yatırır ve 47.619 token1 geri alır | 1,050.000 | 952.381 | 5,020 | 0.907 | 20 |
| Ticaret Yapan B, 10 token0 yatırır ve 8.984 token1 geri alır | 1,060.000 | 943.396 | 5,030 | 0.890 | 20+10\*0.907 = 29.07 |
| Ticaret Yapan C 40 token0 yatırır ve 34.305 token1 geri alır | 1,100.000 | 909.090 | 5,100 | 0.826 | 29.07+70\*0.890 = 91.37 |
| Ticaret Yapan D, 100 token1 yatırır ve 109.01 token0 geri alır | 990.990 | 1,009.090 | 5,110 | 1.018 | 91.37+10\*0.826 = 99.63 |
@@ -501,9 +501,9 @@ Eğer bu ilk yatırma ise, `MINIMUM_LIQUIDITY` tane token yaratın ve onları ki
Arbitrajda değer kaybetmemek için eşit değer sağlamak para yatıran kişinin çıkarına olduğu için buna güvenebiliriz. Diyelim ki iki token'ın değeri aynı, ancak yatıran kişimiz **Token0**'a göre dört kat daha fazla **Token1** yatırdı. Ticaret yapan bir kişi, eş takasının **Token0**'ın daha değerli olduğunu düşündüğü gerçeğini ondan değer yaratmak için kullanabilir.
| Olay | reserve0 | reserve1 | reserve0 \* reserve1 | Havuzun değeri (reserve0 + reserve1) |
-| ------------------------------------------------------------------ | --------:| --------:| ----------------------:| ------------------------------------:|
-| İlk kurulum | 8 | 32 | 256 | 40 |
-| Ticaret yapan kişi 8 **Token0** tokeni yatırır, 16 **Token1** alır | 16 | 16 | 256 | 32 |
+| ------------------------------------------------------------------ | -------: | -------: | -------------------: | -----------------------------------: |
+| İlk kurulum | 8 | 32 | 256 | 40 |
+| Ticaret yapan kişi 8 **Token0** tokeni yatırır, 16 **Token1** alır | 16 | 16 | 256 | 32 |
Gördüğünüz gibi, ticaret yapan kişi havuzun değerindeki bir düşüşten gelen 8 token kazanarak ona sahip olan yatırım yapan kişiye zarar verdi.
@@ -517,12 +517,12 @@ Sonraki her yatırmada, iki varlık arasındaki takas oranını zaten biliyoruz
İster ilk yatırma ister sonraki bir yatırma olsun, sağladığımız likidite token'larının sayısı `reserve0*reserve1`'deki değişikliğin kareköküne eşittir ve likidite token'ının değeri değişmez (her iki tür için de eşit değerlere sahip olmayan bir yatırım almadığı sürece böyledir, aksi hâlde "para cezası" dağıtılır). İşte aynı değere sahip iki token'lı, üç iyi yatırma ve bir kötü yatırma bulunan başka bir örnek (yalnızca bir token türünden para yatırma, bu nedenle herhangi bir likidite token'ı üretmez).
| Olay | reserve0 | reserve1 | reserve0 \* reserve1 | Havuz değeri (reserve0 + reserve1) | Bu yatırma için basılmış likidite token'ları | Toplam likidite token'ları | her bir likidite token'ının değeri |
-| -------------------------- | --------:| --------:| ----------------------:| ----------------------------------:| --------------------------------------------:| --------------------------:| ----------------------------------:|
-| İlk kurulum | 8.000 | 8.000 | 64 | 16.000 | 8 | 8 | 2.000 |
-| Her türden dördünü yatırma | 12.000 | 12.000 | 144 | 24.000 | 4 | 12 | 2.000 |
-| Her türden ikisini yatırma | 14.000 | 14.000 | 196 | 28.000 | 2 | 14 | 2.000 |
-| Eşit olmayan değer yatırma | 18.000 | 14.000 | 252 | 32.000 | 0 | 14 | ~2.286 |
-| Arbitrajdan sonra | ~15.874 | ~15.874 | 252 | ~31.748 | 0 | 14 | ~2.267 |
+| -------------------------- | -------: | -------: | -------------------: | ---------------------------------: | -------------------------------------------: | -------------------------: | ---------------------------------: |
+| İlk kurulum | 8.000 | 8.000 | 64 | 16.000 | 8 | 8 | 2.000 |
+| Her türden dördünü yatırma | 12.000 | 12.000 | 144 | 24.000 | 4 | 12 | 2.000 |
+| Her türden ikisini yatırma | 14.000 | 14.000 | 196 | 28.000 | 2 | 14 | 2.000 |
+| Eşit olmayan değer yatırma | 18.000 | 14.000 | 252 | 32.000 | 0 | 14 | ~2.286 |
+| Arbitrajdan sonra | ~15.874 | ~15.874 | 252 | ~31.748 | 0 | 14 | ~2.267 |
```solidity
}
@@ -987,7 +987,7 @@ Likidite sağlayıcıları, işlemi mevcut takas oranına yakın bir takas oran
Örneğin, takas oranının bire bir olduğu ve likidite sağlayıcısının şu değerleri belirlediği bir durumu hayal edin:
| Parametre | Değer |
-| -------------- | -----:|
+| -------------- | ----: |
| amountADesired | 1000 |
| amountBDesired | 1000 |
| amountAMin | 900 |
diff --git a/src/content/translations/zh/developers/tutorials/uniswap-v2-annotated-code/index.md b/src/content/translations/zh/developers/tutorials/uniswap-v2-annotated-code/index.md
index 24c8b679f2d..e5242c4f0e7 100644
--- a/src/content/translations/zh/developers/tutorials/uniswap-v2-annotated-code/index.md
+++ b/src/content/translations/zh/developers/tutorials/uniswap-v2-annotated-code/index.md
@@ -25,7 +25,7 @@ lang: zh
当流动资金提供者想要收回他们的代币资产时,他们可以消耗资金池代币并收回他们的代币, 其中包括他们在兑换过程中奖励的份额。
-[点击这里查看更完整的描述](https://uniswap.org/docs/v2/core-concepts/swaps/)。
+[点击这里查看更完整的描述](https://docs.uniswap.org/protocol/V2/concepts/core-concepts/swaps/)。
### 为什么选择 v2? 而不是 v3? {#why-v2}
From 81eac7e864d999c020858b218d9d89c7997dad62 Mon Sep 17 00:00:00 2001
From: "allcontributors[bot]"
<46447321+allcontributors[bot]@users.noreply.github.com>
Date: Mon, 30 May 2022 13:28:51 +0000
Subject: [PATCH 139/298] docs: update README.md [skip ci]
---
README.md | 1 +
1 file changed, 1 insertion(+)
diff --git a/README.md b/README.md
index 3cd2da55c8a..f9817620c35 100644
--- a/README.md
+++ b/README.md
@@ -1233,6 +1233,7 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
From dd404c6170d9b600eabdb592445672504fc15f51 Mon Sep 17 00:00:00 2001
From: "allcontributors[bot]"
<46447321+allcontributors[bot]@users.noreply.github.com>
Date: Mon, 30 May 2022 13:28:52 +0000
Subject: [PATCH 140/298] docs: update .all-contributorsrc [skip ci]
---
.all-contributorsrc | 9 +++++++++
1 file changed, 9 insertions(+)
diff --git a/.all-contributorsrc b/.all-contributorsrc
index dbe2ac0f152..d83741ada37 100644
--- a/.all-contributorsrc
+++ b/.all-contributorsrc
@@ -7617,6 +7617,15 @@
"contributions": [
"doc"
]
+ },
+ {
+ "login": "zjiekai",
+ "name": "zjiekai",
+ "avatar_url": "https://avatars.githubusercontent.com/u/1871071?v=4",
+ "profile": "https://github.com/zjiekai",
+ "contributions": [
+ "doc"
+ ]
}
],
"contributorsPerLine": 7,
From 4c8da270bb06139c2436613591c25fe57b5b38c7 Mon Sep 17 00:00:00 2001
From: Emmanuel Awosika
Date: Mon, 30 May 2022 14:51:06 +0100
Subject: [PATCH 141/298] Add new information to sidechains page.
Reworked the content to add more structure to the page. Also updated pros/cons and described the architecture of sidechains in detail.
---
.../docs/scaling/sidechains/index.md | 59 ++++++++++++++++---
1 file changed, 50 insertions(+), 9 deletions(-)
diff --git a/src/content/developers/docs/scaling/sidechains/index.md b/src/content/developers/docs/scaling/sidechains/index.md
index 5e961750529..b6ba1720216 100644
--- a/src/content/developers/docs/scaling/sidechains/index.md
+++ b/src/content/developers/docs/scaling/sidechains/index.md
@@ -7,21 +7,61 @@ incomplete: true
sidebarDepth: 3
---
-A sidechain is a separate blockchain which runs in parallel to Ethereum Mainnet and operates independently. It has its own [consensus algorithm](/developers/docs/consensus-mechanisms/) (e.g. [proof-of-authority](https://wikipedia.org/wiki/Proof_of_authority), [Delegated proof-of-stake](https://en.bitcoinwiki.org/wiki/DPoS), [Byzantine fault tolerance](https://decrypt.co/resources/byzantine-fault-tolerance-what-is-it-explained)). It is connected to Mainnet by a two-way bridge.
+A sidechain is a separate blockchain which runs in parallel to Ethereum; it is connected to Mainnet by a two-way bridge. Sidechains have separate [consensus algorithms](/developers/docs/consensus-mechanisms/), which are often designed for faster processing times. Using a sidechain involves trade-offs, though, as they do not inherit Ethereum's security properties, unlike [layer 2 scaling solutions](/layer-2/).
-What makes a sidechain particularly exciting is that the chain works the same as the main Ethereum chain because it's based on [the EVM](/developers/docs/evm/). It doesn't use Ethereum, it is Ethereum. This means if you want to use your [dapp](/developers/docs/dapps/) on a sidechain, it's just a matter of deploying your code to this sidechain. It looks, feels, and acts just like Mainnet – you write contracts in Solidity, and interact with the chain via the Web3 API.
+## How do sidechains work? {#how-do-sidechains-work}
-## Prerequisites {#prerequisites}
+### Consensus algorithms {#consensus-algorithms}
-You should have a good understanding of all the foundational topics and a high-level understanding of [Ethereum scaling](/developers/docs/scaling/).
+As mentioned, sidechains use alternative consensus algorithms that are different from Ethereum's proof-of-work (PoW) or proof-of-stake (PoS). Some examples of consensus algorithms used on sidechains include:
-## Pros and cons {#pros-and-cons}
+- [Proof-of-authority](https://wikipedia.org/wiki/Proof_of_authority)
+- [Delegated proof-of-stake](https://en.bitcoinwiki.org/wiki/DPoS)
+- [Byzantine fault tolerance](https://decrypt.co/resources/byzantine-fault-tolerance-what-is-it-explained).
+
+Sidechain nodes (called validators) are responsible for ordering and processing transactions, storing the blockchain state, and securing the network. In some cases, validators may be responsible for approving users' entries and exits between the sidechain and Ethereum Mainnet.
+
+### EVM compatibility {#evm-compatibility}
+
+What makes a sidechain particularly exciting is that the chain works the same as the main Ethereum chain because it's based on [the EVM](/developers/docs/evm/). It doesn't merely use Ethereum, it _is_ Ethereum.
+
+This means if you want to use your [dapp](/developers/docs/dapps/) on a sidechain, it's just a matter of deploying your [smart contract](/developers/docs/smart-contracts/) to this sidechain. It looks, feels, and acts just like Mainnet – you write contracts in Solidity, and interact with the chain via the Web3 API.
+
+Because sidechains are EVM-compatible, they are considered a useful scaling [scaling solution](/developers/docs/scaling/) for Ethereum-native dapps. With your dapp on a sidechain, users can enjoy lower gas fees and faster transactions (albeit, with certain trade-offs), especially if Mainnet is congested.
+
+### Asset movement {#asset-movement}
+
+A crucial feature of sidechains is their ability to facilitate seamless transfer of value from and to Ethereum Mainnet. This interoperability with Ethereum is achieved using a blockchain bridge, which enforces a “two-way peg” between two chains. Bridges use a network of smart contracts deployed on both networks to control transfer of funds between Ethereum and sidechains.
+
+While bridges help users move funds between Ethereum and the sidechain, the assets are not physically moved across the two chains. Instead, a "lock-mint-burn" mechanism is used for transferring value across chains. Here is a description of the actual process:
+
+- **Moving funds from Ethereum to a sidechain**
+
+Bob (an Ethereum user) wishes to use a sidechain. This is what he does to move funds from Mainnet to the sidechain:
+
+1. Bob sends ERC-20 tokens to a smart contract on the Ethereum chain (e.g. Ethereum) and pays the transaction fee.
+2. Bob’s ERC-20 tokens are locked up in the smart contract, with the event being relayed to the smart contract on the sidechain.
+3. Once it receives proof of Bob’s deposit, the sidechain’s smart contract triggers the creation or “minting” of an amount of tokens equal to Bob’s initial deposit.
+4. Bob receives the new tokens in his wallet address and can use it to execute transactions on the sidechain.
+
+- **Moving funds from a sidechain to Ethereum Mainnet**
+
+Having concluded his business on the sidechain, Bob wants to withdraw his remaining funds to Ethereum Mainnet. This is what happens:
+
+1. Bob sends his remaining tokens to the sidechain’s smart contract for “burning”. Burning is a mechanism for destroying tokens by making them irrecoverable.
+2. Information concerning Bob’s deposit transaction and the token burning is relayed to the smart contract on Ethereum.
+3. The smart contract then triggers the release of Bob’s ERC-20 tokens on Ethereum, which are sent back to his wallet.
+
+Note: Bridging funds between Mainnet and sidechains carries its own set of problems (e.g., smart contracts can be hacked), which is another drawback associated with sidechains. More on the [risks of blockchain bridges](/bridges/#bridge-risk).
+
+## Pros and cons of sidechains {#pros-and-cons-of-sidechains}
| Pros | Cons |
| ------------------------------------------------ | ---------------------------------------------------------------------------------------------- |
-| Established technology. | Less decentralized. |
-| Supports general computation, EVM compatibility. | Uses a separate consensus mechanism. Not secured by layer 1 (so technically it’s not layer 2). |
-| | A quorum of sidechain validators can commit fraud. |
+| The technology underpinning sidechains is well-established and benefits from extensive research and improvements in design. | Sidechains trade off some measure of decentralization and trustlesness for scalability. |
+| Sidechains support general computation and offer EVM compatibility (they can run Ethereum-native dapps). | A sidechain uses a separate consensus mechanism and doesn't benefit from Ethereum's security guarantees. |
+| Sidechains use different consensus models to efficiently process transactions and lower transaction fees for users. | Sidechains require higher trust assumptions (e.g., a quorum of malicious sidechain validators can commit fraud).|
+| EVM-compatible sidechains allow dapps to expand their ecosystem. | |
### Use Sidechains {#use-sidechains}
@@ -29,7 +69,8 @@ Multiple projects provide implementations of sidechains that you can integrate i
- [Polygon PoS](https://polygon.technology/solutions/polygon-pos)
- [Skale](https://skale.network/)
-- [Gnosis Chain (formerly xDai)](https://www.xdaichain.com/)
+- [Gnosis Chain (formerly xDai)](https://www.gnosischain.com/)
+- [Loom Network](https://loomx.io/)
## Further reading {#further-reading}
From 9cc8c23cb48f6ce8121c220fa1d36105737af2d8 Mon Sep 17 00:00:00 2001
From: "allcontributors[bot]"
<46447321+allcontributors[bot]@users.noreply.github.com>
Date: Mon, 30 May 2022 14:32:00 +0000
Subject: [PATCH 142/298] docs: update README.md [skip ci]
---
README.md | 3 +++
1 file changed, 3 insertions(+)
diff --git a/README.md b/README.md
index f9817620c35..23c563d54c1 100644
--- a/README.md
+++ b/README.md
@@ -1235,6 +1235,9 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
From ae13fb0efbbf6de75c0a4debbdd7d3d99191ab1d Mon Sep 17 00:00:00 2001
From: "allcontributors[bot]"
<46447321+allcontributors[bot]@users.noreply.github.com>
Date: Mon, 30 May 2022 14:50:09 +0000
Subject: [PATCH 145/298] docs: update .all-contributorsrc [skip ci]
---
.all-contributorsrc | 9 +++++++++
1 file changed, 9 insertions(+)
diff --git a/.all-contributorsrc b/.all-contributorsrc
index c314fbafa5a..004cece6e2c 100644
--- a/.all-contributorsrc
+++ b/.all-contributorsrc
@@ -7635,6 +7635,15 @@
"contributions": [
"ideas"
]
+ },
+ {
+ "login": "MonsieurDMA",
+ "name": "MonsieurDMA",
+ "avatar_url": "https://avatars.githubusercontent.com/u/92155252?v=4",
+ "profile": "https://github.com/MonsieurDMA",
+ "contributions": [
+ "doc"
+ ]
}
],
"contributorsPerLine": 7,
From 9e4d4c83c2dd8139bb9512326aacf05b2f88d59b Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Mon, 30 May 2022 09:05:59 -0600
Subject: [PATCH 146/298] Update src/intl/en/page-layer-2.json
Co-authored-by: Joshua <62268199+minimalsm@users.noreply.github.com>
---
src/intl/en/page-layer-2.json | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/intl/en/page-layer-2.json b/src/intl/en/page-layer-2.json
index a44b89949c1..fde0709374a 100644
--- a/src/intl/en/page-layer-2.json
+++ b/src/intl/en/page-layer-2.json
@@ -6,7 +6,7 @@
"layer-2-hero-title": "Layer 2",
"layer-2-hero-header": "Ethereum for everyone",
"layer-2-hero-subtitle": "Scaling Ethereum without compromising on security or decentralization.",
- "layer-2-hero-alt-text": "Layer 2 diagram",
+ "layer-2-hero-alt-text": "Illustration of transactions being rolled up on Layer 2 and posted to Ethereum Mainnet",
"layer-2-hero-button-1": "What is layer 2",
"layer-2-hero-button-2": "Use layer 2",
"layer-2-statsbox-1": "TVL locked in layer 2 (USD)",
From 7b05cd6221ef86e073d48e107c8155564b9d7de2 Mon Sep 17 00:00:00 2001
From: William
Date: Mon, 30 May 2022 11:21:20 -0400
Subject: [PATCH 147/298] Add requested changes
---
src/data/eth-upgrade-articles.ts | 18 ++++++++++++------
src/utils/calculateStakingRewards.ts | 3 ++-
2 files changed, 14 insertions(+), 7 deletions(-)
diff --git a/src/data/eth-upgrade-articles.ts b/src/data/eth-upgrade-articles.ts
index 36bd86eeaab..881bad3d198 100644
--- a/src/data/eth-upgrade-articles.ts
+++ b/src/data/eth-upgrade-articles.ts
@@ -1,4 +1,10 @@
-export const dannyArticles = [
+interface Article {
+ title: string
+ description: string
+ link: string
+}
+
+export const dannyArticles: Article[] = [
{
title: "Finalized no. 34",
description: "23 March 2022",
@@ -26,24 +32,24 @@ export const dannyArticles = [
},
]
-export const benArticles = [
+export const benArticles: Article[] = [
{
- title: "What’s New in Eth2 – #88",
+ title: "What’s New in Eth2 – #92",
description: "6 May 2022",
link: "https://hackmd.io/@benjaminion/eth2_news/https%3A%2F%2Fhackmd.io%2F%40benjaminion%2Fwnie2_220506",
},
{
- title: "What’s New in Eth2 – #88",
+ title: "What’s New in Eth2 – #91",
description: "8 April 2022",
link: "https://hackmd.io/@benjaminion/eth2_news/https%3A%2F%2Fhackmd.io%2F%40benjaminion%2Fwnie2_220408",
},
{
- title: "What’s New in Eth2 – #88",
+ title: "What’s New in Eth2 – #90",
description: "25 March 2022",
link: "https://hackmd.io/@benjaminion/eth2_news/https%3A%2F%2Fhackmd.io%2F%40benjaminion%2Fwnie2_220325",
},
{
- title: "What’s New in Eth2 – #88",
+ title: "What’s New in Eth2 – #89",
description: "11 March 2022",
link: "https://hackmd.io/@benjaminion/eth2_news/https%3A%2F%2Fhackmd.io%2F%40benjaminion%2Fwnie2_220311",
},
diff --git a/src/utils/calculateStakingRewards.ts b/src/utils/calculateStakingRewards.ts
index 13af22b5e77..789cc94e1f5 100644
--- a/src/utils/calculateStakingRewards.ts
+++ b/src/utils/calculateStakingRewards.ts
@@ -1,4 +1,5 @@
-const calculateStakingRewards = (totalAtStake: number) => {
+/** Calculates the current APR for the staking reward */
+const calculateStakingRewards = (totalAtStake: number): number => {
const slotTimeInSec = 12
const slotsInEpoch = 32
const baseRewardFactor = 64
From 7a14252fb3f3f237daeffeca0684d4f85be00a6e Mon Sep 17 00:00:00 2001
From: William
Date: Mon, 30 May 2022 11:23:43 -0400
Subject: [PATCH 148/298] Fixes & update comment format for intelliense/docs
---
src/data/eth-upgrade-articles.ts | 2 ++
src/lambda/etherscan.ts | 2 +-
src/lambda/etherscanBlock.ts | 2 +-
src/utils/flattenMessages.ts | 2 +-
src/utils/getMessages.ts | 2 +-
5 files changed, 6 insertions(+), 4 deletions(-)
diff --git a/src/data/eth-upgrade-articles.ts b/src/data/eth-upgrade-articles.ts
index 881bad3d198..0127f5b5165 100644
--- a/src/data/eth-upgrade-articles.ts
+++ b/src/data/eth-upgrade-articles.ts
@@ -4,6 +4,7 @@ interface Article {
link: string
}
+/** Articles by Danny Ryan (Ethereum Foundation) */
export const dannyArticles: Article[] = [
{
title: "Finalized no. 34",
@@ -32,6 +33,7 @@ export const dannyArticles: Article[] = [
},
]
+/** Articles by Ben Edgington (PegaSys, ConsenSys) */
export const benArticles: Article[] = [
{
title: "What’s New in Eth2 – #92",
diff --git a/src/lambda/etherscan.ts b/src/lambda/etherscan.ts
index b10d7dc9642..4475b2fabe9 100644
--- a/src/lambda/etherscan.ts
+++ b/src/lambda/etherscan.ts
@@ -31,4 +31,4 @@ const handler = () => {
return lambda(process.env.ETHERSCAN_API_KEY)
}
-module.exports = { handler, lambda }
+export { handler, lambda }
diff --git a/src/lambda/etherscanBlock.ts b/src/lambda/etherscanBlock.ts
index aeb15bbb3ea..6fbbf750240 100644
--- a/src/lambda/etherscanBlock.ts
+++ b/src/lambda/etherscanBlock.ts
@@ -29,4 +29,4 @@ const handler = () => {
return lambda(process.env.ETHERSCAN_API_KEY)
}
-module.exports = { handler, lambda }
+export { handler, lambda }
diff --git a/src/utils/flattenMessages.ts b/src/utils/flattenMessages.ts
index a6f9da15f58..3c5af83b41a 100644
--- a/src/utils/flattenMessages.ts
+++ b/src/utils/flattenMessages.ts
@@ -1,6 +1,6 @@
import type { Messages } from "../interfaces"
-// same function from 'gatsby-plugin-intl'
+/** same function from 'gatsby-plugin-intl' */
const flattenMessages = (nestedMessages: Messages, prefix = ""): Messages => {
return Object.keys(nestedMessages).reduce((messages, key) => {
let value = nestedMessages[key]
diff --git a/src/utils/getMessages.ts b/src/utils/getMessages.ts
index c5499bd2569..3a26fc27524 100644
--- a/src/utils/getMessages.ts
+++ b/src/utils/getMessages.ts
@@ -5,7 +5,7 @@ import flattenMessages from "./flattenMessages"
import type { Messages } from "../interfaces"
import type { Lang } from "./languages"
-// same function from 'gatsby-plugin-intl'
+/** same function from 'gatsby-plugin-intl' */
const getMessages = (path: string, language: Lang): Messages => {
try {
const messages = JSON.parse(
From 4a729a180935d52392f8855009a8d525f1e47582 Mon Sep 17 00:00:00 2001
From: Emmanuel Awosika
Date: Mon, 30 May 2022 16:35:52 +0100
Subject: [PATCH 149/298] Update
src/content/developers/docs/scaling/validium/index.md
Co-authored-by: Sam Richards
---
src/content/developers/docs/scaling/validium/index.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/content/developers/docs/scaling/validium/index.md b/src/content/developers/docs/scaling/validium/index.md
index 89f78332993..88431f27c4a 100644
--- a/src/content/developers/docs/scaling/validium/index.md
+++ b/src/content/developers/docs/scaling/validium/index.md
@@ -15,7 +15,7 @@ You should have a good understanding of all the foundational topics and a high-l
## How does validium work? {#how-does-validium work}
-Validiums are a type of “rollup”: a [Layer 2](/layer-2/) scaling protocol designed to improve throughput by processing transactions off the main Ethereum chain. Off-chain transactions executed on the validium chain are verified via a smart contract on the base Ethereum layer using zero-knowledge proofs. This can be either a SNARK (Succinct Non-Interactive Argument of Knowledge) or SNARK (Scalable Transparent Argument of Knowledge).
+Validiums are a type of “rollup”: a [Layer 2](/layer-2/) scaling protocol designed to improve throughput by processing transactions off the main Ethereum chain. Off-chain transactions executed on the validium chain are verified via a smart contract on the base Ethereum layer using zero-knowledge proofs. This can be either a SNARK (Succinct Non-Interactive Argument of Knowledge) or STARK (Scalable Transparent ARgument of Knowledge).
As with ZK-rollups, validity proofs prevent invalid state transitions on validium chains and enhance security guarantees available to users. For instance, a malicious operator cannot steal funds since users can always withdraw funds directly from the on-chain contract [using Merkle proofs](/developers/tutorials/merkle-proofs-for-offline-data-integrity/).
From 5c2be70a4dc8ea5a46f61f2ac75004c2184454f8 Mon Sep 17 00:00:00 2001
From: Emmanuel Awosika
Date: Mon, 30 May 2022 16:39:30 +0100
Subject: [PATCH 150/298] Update index.md
Edits to incorporate feedback
---
src/content/developers/docs/scaling/validium/index.md | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/src/content/developers/docs/scaling/validium/index.md b/src/content/developers/docs/scaling/validium/index.md
index 88431f27c4a..a5032380e68 100644
--- a/src/content/developers/docs/scaling/validium/index.md
+++ b/src/content/developers/docs/scaling/validium/index.md
@@ -15,7 +15,9 @@ You should have a good understanding of all the foundational topics and a high-l
## How does validium work? {#how-does-validium work}
-Validiums are a type of “rollup”: a [Layer 2](/layer-2/) scaling protocol designed to improve throughput by processing transactions off the main Ethereum chain. Off-chain transactions executed on the validium chain are verified via a smart contract on the base Ethereum layer using zero-knowledge proofs. This can be either a SNARK (Succinct Non-Interactive Argument of Knowledge) or STARK (Scalable Transparent ARgument of Knowledge).
+Validiums are a type of “rollup”: a [Layer 2](/layer-2/) scaling protocol designed to improve throughput by processing transactions off the main Ethereum chain. Off-chain transactions executed on the validium chain are verified via a smart contract on the base Ethereum layer using zero-knowledge proofs, which can be SNARKs (Succinct Non-Interactive Argument of Knowledge) or STARKs (Scalable Transparent ARgument of Knowledge).
+
+More on [zero-knowledge proofs](https://consensys.net/blog/blockchain-explained/zero-knowledge-proofs-starks-vs-snarks/).
As with ZK-rollups, validity proofs prevent invalid state transitions on validium chains and enhance security guarantees available to users. For instance, a malicious operator cannot steal funds since users can always withdraw funds directly from the on-chain contract [using Merkle proofs](/developers/tutorials/merkle-proofs-for-offline-data-integrity/).
From c500d56fc61796ad8123f3ff2af1716ebb564707 Mon Sep 17 00:00:00 2001
From: Nico
Date: Tue, 31 May 2022 01:16:30 +0900
Subject: [PATCH 151/298] addinterface
---
src/components/YouTube.tsx | 9 ++++++++-
1 file changed, 8 insertions(+), 1 deletion(-)
diff --git a/src/components/YouTube.tsx b/src/components/YouTube.tsx
index 2ac3266b568..40da9dd185a 100644
--- a/src/components/YouTube.tsx
+++ b/src/components/YouTube.tsx
@@ -15,7 +15,14 @@ const Figure = styled.figure`
* e.g. For https://www.youtube.com/watch?v=H-O3r2YMWJ4&t=123 the `start` is 123 (which means 123 seconds)
* @returns Embedded YouTube video component
*/
-const YouTube = ({ id, start, title }) => {
+
+export interface IProps {
+ id: string
+ start: string
+ title: string
+}
+
+const YouTube: React.FC = ({ id, start, title }) => {
const startQuery = parseInt(start) > 0 ? `?start=${start}` : ""
const baseUrl = "https://www.youtube.com/embed/"
const src = baseUrl + id + startQuery
From 193a3ebdefe0495e130766d63de96f2b51097790 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Mon, 30 May 2022 10:48:27 -0600
Subject: [PATCH 152/298] remove md issue template
---
.github/ISSUE_TEMPLATE/suggest_wallet.md | 201 -----------------------
1 file changed, 201 deletions(-)
delete mode 100644 .github/ISSUE_TEMPLATE/suggest_wallet.md
diff --git a/.github/ISSUE_TEMPLATE/suggest_wallet.md b/.github/ISSUE_TEMPLATE/suggest_wallet.md
deleted file mode 100644
index 0f3ec96532a..00000000000
--- a/.github/ISSUE_TEMPLATE/suggest_wallet.md
+++ /dev/null
@@ -1,201 +0,0 @@
----
-name: Suggest a wallet
-about: Suggest a new wallet to list on ethereum.org
-title: ""
-labels: "wallet :purse:,"
-assignees: ""
----
-
-Before suggesting a wallet, make sure you've read [our listing policy](https://www.ethereum.org/en/contributing/adding-products/). Only continue with the issue if the wallet meets the criteria listed there.
-
-### Project info
-
-**Wallet name**
-
-
-
-**Wallet description**
-
-
-
-**Wallet logo**
-
-
-
-**Background color for brand logo**
-
-
-
-**URL to the project**
-
-
-
-**URL to the documentation**
-
-
-
-**When did the wallet go live to users?**
-
-
-
-**Does the wallet have an active development team?**
-
-
-
-**Is the wallet globally accessible?**
-
-
-
-**Is the wallet available in multiple languages?**
-
-
-
-**What social links are there for the project?**
-
-
-
-### Device
-
-**Does the wallet have a mobile app? If yes, which operating systems are supported (iOS, Android)?**
-
-
-
-**Does the wallet have a desktop app? If yes, which operating systems are supported (Windows, Mac, Linux)?**
-
-
-
-**Does the wallet have a browser extension? If yes, which browsers are supported (Chromium, Firefox, Safari)?**
-
-
-
-**Is it a hardware wallet?**
-
-
-
-### Security
-
-**Is the source code for the wallet fully open-source?**
-
-
-
-**What license is the wallet software released under?**
-
-
-
-**Who holds the private keys?**
-
-
-
-
-
-**Please describe the measures taken to ensure the wallet's security and provide documentation wherever possible**
-
-
-
-**Has the wallet's smart contract code been audited?**
-
-
-
-**Does the wallet have an internal security team?**
-
-
-
-**Any other security testing that should be noted?**
-
-
-
-**Spam protection?**
-
-
-
-### Features
-
-**Does the wallet support connecting to a hardware wallet?**
-
-
-
-**Does the wallet support WalletConnect?**
-
-
-
-**Does the wallet support importing Ethereum RPC endpoints?**
-
-
-
-**Does the wallet support viewing and interacting with NFTs?**
-
-
-
-**Does the wallet support connecting to Ethereum applications?**
-
-
-
-**Does the wallet support staking directly?**
-
-
-
-**Does the wallet support swaps directly?**
-
-
-
-**Does the wallet support multi-chain networks?**
-
-
-
-**Does the wallet allow the user to customize gas fees?**
-
-
-
-**Does the wallet support sending transactions to ENS addresses?**
-
-
-
-**Does the wallet support importing or automatically querying and displaying ERC-20 tokens?**
-
-
-
-**Does the wallet support EIP-1559 (type 2) transactions?**
-
-
-
-### Finance
-
-**Does the wallet have fiat on-ramps through credit/debit cards, wire transfers, or bank transfers (ACH)?**
-
-
-
-**Does the wallet support withdrawals to fiat?**
-
-
-
-### Smart contract
-
-**Is the wallet a multi-signature wallet?**
-
-
-
-**Does the wallet support social recovery?**
-
-
-
-### Support
-
-**Who can the ethereum.org team can contact regarding the wallet in future?**
-
-
-
-
-**Does the wallet have a dedicated support team?**
-
-
-
-
-**What educational resources/documentation do you provide to users?**
-
-
-
-### Extra
-
-**Does the wallet have any integrated tools not mentioned above?**
-
-
From 8680d9543178b0bce706a13095990bf73aaf18b8 Mon Sep 17 00:00:00 2001
From: Corwin Smith
Date: Mon, 30 May 2022 11:01:02 -0600
Subject: [PATCH 153/298] update new content changes
---
src/content/developers/docs/bridges/index.md | 36 +-
src/gatsby-types.d.ts | 10628 +++++++++++++++++
2 files changed, 10652 insertions(+), 12 deletions(-)
create mode 100644 src/gatsby-types.d.ts
diff --git a/src/content/developers/docs/bridges/index.md b/src/content/developers/docs/bridges/index.md
index bf7824ff26f..db4a20a3add 100644
--- a/src/content/developers/docs/bridges/index.md
+++ b/src/content/developers/docs/bridges/index.md
@@ -7,7 +7,6 @@ sidebar: true
With the proliferation of L1 blockchains and L2 [scaling](/developers/docs/scaling/) solutions, alongside an ever-growing number of decentralized applications going cross-chain, the need for communication and asset movement across chains has become an essential part of network infrastructure. Different types of bridges exist to help make this possible.
-
## Need for bridges {#need-for-bridges}
Bridges exist to connect blockchain networks. They enable connectivity and interoperability between blockchains.
@@ -18,11 +17,17 @@ Bridges offer a way for isolated blockchain environments to connect with each ot
## Benefits of bridges {#benefits-of-bridges}
-Put simply, bridges unlock developer potential by allowing blockchain networks to exchange data and move assets between them.
+Put simply, bridges unlock numerous use cases by allowing blockchain networks to exchange data and move assets between them.
Blockchains have unique strengths, weaknesses, and approaches to building applications (such as speed, throughput, costliness, etc.). Bridges help the development of the overall crypto ecosystem by enabling blockchains to leverage the innovations of each other.
-Moreover, bridges unlock new use cases and possibilities for both users and developers. For example, users can now move assets across different ecosystems, making them more productive. For developers and protocols, bridges open up an almost limitless amount of possibilities by expanding the design space for [dapps](/developers/docs/dapps/) across multiple crypto ecosystems.
+For developers, bridges enable the following:
+
+- the transfer of any data, information, and assets across chains.
+- unlocking new features and use cases for protocols as bridges expand the design space for what protocols can offer. For example, a protocol for yield farming originally deployed on Ethereum Mainnet can offer liquidity pools across all EVM-compatible chains.
+- the opportunity to leverage the strengths of different blockchains. For example, developers can benefit from the lower fees offered by the different L2 solutions by deploying their dapps across rollups, and sidechains and users can bridge across them.
+- collaboration among developers from various blockchain ecosystems to build new products.
+- attracting users and communities from various ecosystems to their dapps.
## How do bridges work? {#how-do-bridges-work}
@@ -36,7 +41,7 @@ While there are many [types of bridge designs](https://blog.li.fi/what-are-block
Bridges can usually be classified into one of the following buckets:
-- **Native Bridges –** These bridges are typically built to bootstrap liquidity on a particular blockchain, making it easier for users to move funds to the ecosystem. For example, the Avalanche Bridge is built to make it convenient for users to bridge from [Ethereum](/developers/docs/intro-to-ethereum/) to Avalanche. Other such bridges include Polygon PoS Bridge, Arbitrum Bridge, etc.
+- **Native Bridges –** These bridges are typically built to bootstrap liquidity on a particular blockchain, making it easier for users to move funds to the ecosystem. For example, the [Arbitrum Bridge](https://bridge.arbitrum.io/) is built to make it convenient for users to bridge from Ethereum Mainnet to Arbitrum. Other such bridges include Polygon PoS Bridge, [Optimism Gateway](https://gateway.optimism.io/), etc.
- **Validator or Oracle Based Bridges –** These bridges rely on an external validator set or oracles to validate cross-chain transfers. Examples: Multichain and Across.
- **Generalized Message Passing Bridges –** These bridges can transfer assets, along with messages and arbitrary data across chains. Examples: Nomad and LayerZero.
- **Liquidity Networks –** These bridges primarily focus on transferring assets from one chain to another via atomic swaps. Generally, they don’t support cross-chain message passing. Examples: Connext and Hop.
@@ -66,7 +71,6 @@ To evaluate trustless bridges based on other factors, we must break them down in
Bridges account for the top three [biggest hacks in DeFi](https://rekt.news/leaderboard/) and are still in the early stages of development. Using any bridge carries the following risks:
- **Smart Contract Risk –** While many bridges have successfully passed audits, all it takes is one flaw in a smart contract for assets to be exposed to hacks (ex: [Solana’s Wormhole Bridge](https://rekt.news/wormhole-rekt/)).
-- **Technology Risk –** Given the complexity of bridge operations, there is a possibility of technology risks like software failure, buggy code, human error, spam, and malicious attacks.
- **Systematic Financial Risks** – Many bridges use wrapped assets to mint canonical versions of the original asset on a new chain. This exposes the ecosystem to systematic risk, as we have seen wrapped versions of tokens exploited.
- **Trusted Third-Party Risk –** Some bridges utilize a trusted design that requires users to rely on the assumption that validators will not collude to steal user funds. The need for users to trust these third-party actors exposes them to risks such as rug pulls, censorship, and other malicious activities.
- **Open Issues –** Given that bridges are in the nascent stages of development, there are many unanswered questions related to how bridges will perform in different market conditions, like times of network congestion and during unforeseen events such as network-level attacks or state rollbacks. This uncertainty poses certain risks, the degree of which is still unknown.
@@ -80,22 +84,30 @@ Here are some practical applications that developers can consider about bridges
For developers, there are many ways to add support for bridges:
1. **Building your own bridge –** Building a secure and reliable bridge is not easy, especially if you take a more trust-minimized route. Moreover, it requires years of experience and technical expertise related to scalability and interoperability studies. Additionally, it would require a hands-on team to maintain a bridge and attract sufficient liquidity to make it feasible.
-2. **Showing users multiple bridge options –** Many dapps require users to have their native token to interact with them. To enable users to access their tokens, they offer different bridge options on their website. However, this method is a quick fix to the problem as it takes the user away from the dapp interface and still requires them to interact with other dapps and bridges. This is a cumbersome onboarding experience with the increased scope of making mistakes.
+
+2. **Showing users multiple bridge options –** Many [dapps](https://ethereum.org/en/developers/docs/dapps/) require users to have their native token to interact with them. To enable users to access their tokens, they offer different bridge options on their website. However, this method is a quick fix to the problem as it takes the user away from the dapp interface and still requires them to interact with other dapps and bridges. This is a cumbersome onboarding experience with the increased scope of making mistakes.
+
3. **Integrating a bridge –** This solution doesn’t require the dapp to send users to the external bridge and DEX interfaces. It allows dapps to improve the user onboarding experience. However, this approach has its limitations:
- - Assessment and maintenance of bridges are hard and time-consuming.
- - Selecting one bridge creates a single point of failure and dependency.
- - The dapp is limited by the bridge’s capabilities.
- - Bridges alone might not be enough. dapps might need DEXs to offer more functionality such as cross-chain swaps.
+
+- Assessment and maintenance of bridges are hard and time-consuming.
+
+- Selecting one bridge creates a single point of failure and dependency.
+
+- The dapp is limited by the bridge’s capabilities.
+
+- Bridges alone might not be enough. dapps might need DEXs to offer more functionality such as cross-chain swaps.
+
4. **Integrating multiple bridges –** This solution solves many problems associated with integrating a single bridge. However, it also has limitations, as integrating multiple bridges is resource-consuming and creates technical and communication overheads for developers – the scarcest resource in crypto.
+
5. **Integrating a bridge aggregator –** Another option for dapps is integrating a bridge aggregation solution that gives them access to multiple bridges. Bridge aggregators inherit the strengths of all the bridges and thus are not limited by any single bridge’s capabilities. Notably, the bridge aggregators typically maintain the bridge integrations, which saves the dapp from the hassle of staying on top of the technical and operational aspects of a bridge integration.
- That being said, bridge aggregators also have their limitations. For instance, while they can offer more bridge options, many more bridges are typically available in the market other than those offered on the aggregator's platform. Moreover, just like bridges, bridge aggregators are also exposed to smart contract and technology risks (more smart contracts = more risks).
+That being said, bridge aggregators also have their limitations. For instance, while they can offer more bridge options, many more bridges are typically available in the market other than those offered on the aggregator's platform. Moreover, just like bridges, bridge aggregators are also exposed to smart contract and technology risks (more smart contracts = more risks).
If a dapp goes down the route of integrating a bridge or an aggregator, there are different options based on how deep the integration is meant to be. For instance, if it’s only a front-end integration to improve the user onboarding experience, a dapp would integrate the widget. However, if the integration is to explore deeper cross-chain strategies like staking, yield farming, etc., the dapp integrates the SDK or API.
### Deploying a dapp on multiple chains {#deploying-a-dapp-on-multiple-chains}
-To deploy a dapp on multiple chains, developers can use development platforms like Alchemy, Hardhat, Truffle, etc. Typically, these platforms come with composable plugins that can enable dapps to go cross-chain. For instance, developers can use a deterministic deployment proxy offered by the hardhat-deploy plugin.
+To deploy a dapp on multiple chains, developers can use development platforms like Alchemy, Hardhat, Truffle, Moralis, etc. Typically, these platforms come with composable plugins that can enable dapps to go cross-chain. For instance, developers can use a deterministic deployment proxy offered by the hardhat-deploy plugin.
### Monitoring contract activity across chains {#monitoring-contract-activity-across-chains}
diff --git a/src/gatsby-types.d.ts b/src/gatsby-types.d.ts
new file mode 100644
index 00000000000..723d2708c56
--- /dev/null
+++ b/src/gatsby-types.d.ts
@@ -0,0 +1,10628 @@
+/* eslint-disable */
+
+/* THIS FILE IS AUTOGENERATED. CHANGES WILL BE LOST ON SUBSEQUENT RUNS. */
+
+declare namespace Queries {
+ type Maybe = T | null
+ type InputMaybe = T | null
+ type Exact = { [K in keyof T]: T[K] }
+ type MakeOptional = Omit & {
+ [SubKey in K]?: Maybe
+ }
+ type MakeMaybe = Omit & {
+ [SubKey in K]: Maybe
+ }
+ /** All built-in and custom scalars, mapped to their actual values */
+ type Scalars = {
+ /** The `ID` scalar type represents a unique identifier, often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as `"4"`) or integer (such as `4`) input value will be accepted as an ID. */
+ ID: string
+ /** The `String` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text. */
+ String: string
+ /** The `Boolean` scalar type represents `true` or `false`. */
+ Boolean: boolean
+ /** The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1. */
+ Int: number
+ /** The `Float` scalar type represents signed double-precision fractional values as specified by [IEEE 754](https://en.wikipedia.org/wiki/IEEE_floating_point). */
+ Float: number
+ /** A date string, such as 2007-12-03, compliant with the ISO 8601 standard for representation of dates and times using the Gregorian calendar. */
+ Date: string
+ /** The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
+ JSON: Record
+ }
+
+ type AVIFOptions = {
+ readonly lossless: InputMaybe
+ readonly quality: InputMaybe
+ readonly speed: InputMaybe
+ }
+
+ type AlltimeJson = Node & {
+ readonly children: ReadonlyArray
+ readonly currency: Maybe
+ readonly data: Maybe>>
+ readonly dateRange: Maybe
+ readonly id: Scalars["ID"]
+ readonly internal: Internal
+ readonly mode: Maybe
+ readonly name: Maybe
+ readonly parent: Maybe
+ readonly totalCosts: Maybe
+ readonly totalPreTranslated: Maybe
+ readonly totalTMSavings: Maybe
+ readonly unit: Maybe
+ readonly url: Maybe
+ }
+
+ type AlltimeJsonConnection = {
+ readonly distinct: ReadonlyArray
+ readonly edges: ReadonlyArray
+ readonly group: ReadonlyArray
+ readonly max: Maybe
+ readonly min: Maybe
+ readonly nodes: ReadonlyArray
+ readonly pageInfo: PageInfo
+ readonly sum: Maybe
+ readonly totalCount: Scalars["Int"]
+ }
+
+ type AlltimeJsonConnection_distinctArgs = {
+ field: AlltimeJsonFieldsEnum
+ }
+
+ type AlltimeJsonConnection_groupArgs = {
+ field: AlltimeJsonFieldsEnum
+ limit: InputMaybe
+ skip: InputMaybe
+ }
+
+ type AlltimeJsonConnection_maxArgs = {
+ field: AlltimeJsonFieldsEnum
+ }
+
+ type AlltimeJsonConnection_minArgs = {
+ field: AlltimeJsonFieldsEnum
+ }
+
+ type AlltimeJsonConnection_sumArgs = {
+ field: AlltimeJsonFieldsEnum
+ }
+
+ type AlltimeJsonData = {
+ readonly languages: Maybe>>
+ readonly user: Maybe
+ }
+
+ type AlltimeJsonDataFilterInput = {
+ readonly languages: InputMaybe
+ readonly user: InputMaybe
+ }
+
+ type AlltimeJsonDataFilterListInput = {
+ readonly elemMatch: InputMaybe
+ }
+
+ type AlltimeJsonDataLanguages = {
+ readonly approvalCosts: Maybe
+ readonly approved: Maybe
+ readonly language: Maybe
+ readonly targetTranslated: Maybe
+ readonly translated: Maybe
+ readonly translatedByMt: Maybe
+ readonly translationCosts: Maybe
+ }
+
+ type AlltimeJsonDataLanguagesApprovalCosts = {
+ readonly default: Maybe
+ readonly tmMatch: Maybe
+ readonly total: Maybe
+ }
+
+ type AlltimeJsonDataLanguagesApprovalCostsFilterInput = {
+ readonly default: InputMaybe
+ readonly tmMatch: InputMaybe
+ readonly total: InputMaybe
+ }
+
+ type AlltimeJsonDataLanguagesApproved = {
+ readonly default: Maybe
+ readonly tmMatch: Maybe
+ readonly total: Maybe
+ }
+
+ type AlltimeJsonDataLanguagesApprovedFilterInput = {
+ readonly default: InputMaybe
+ readonly tmMatch: InputMaybe
+ readonly total: InputMaybe
+ }
+
+ type AlltimeJsonDataLanguagesFilterInput = {
+ readonly approvalCosts: InputMaybe
+ readonly approved: InputMaybe
+ readonly language: InputMaybe
+ readonly targetTranslated: InputMaybe
+ readonly translated: InputMaybe
+ readonly translatedByMt: InputMaybe
+ readonly translationCosts: InputMaybe
+ }
+
+ type AlltimeJsonDataLanguagesFilterListInput = {
+ readonly elemMatch: InputMaybe
+ }
+
+ type AlltimeJsonDataLanguagesLanguage = {
+ readonly id: Maybe
+ readonly name: Maybe
+ readonly preTranslate: Maybe
+ readonly tmSavings: Maybe
+ readonly totalCosts: Maybe
+ }
+
+ type AlltimeJsonDataLanguagesLanguageFilterInput = {
+ readonly id: InputMaybe
+ readonly name: InputMaybe
+ readonly preTranslate: InputMaybe
+ readonly tmSavings: InputMaybe
+ readonly totalCosts: InputMaybe
+ }
+
+ type AlltimeJsonDataLanguagesTargetTranslated = {
+ readonly default: Maybe
+ readonly tmMatch: Maybe
+ readonly total: Maybe
+ }
+
+ type AlltimeJsonDataLanguagesTargetTranslatedFilterInput = {
+ readonly default: InputMaybe
+ readonly tmMatch: InputMaybe
+ readonly total: InputMaybe
+ }
+
+ type AlltimeJsonDataLanguagesTranslated = {
+ readonly default: Maybe
+ readonly tmMatch: Maybe
+ readonly total: Maybe
+ }
+
+ type AlltimeJsonDataLanguagesTranslatedByMt = {
+ readonly default: Maybe
+ readonly tmMatch: Maybe
+ readonly total: Maybe
+ }
+
+ type AlltimeJsonDataLanguagesTranslatedByMtFilterInput = {
+ readonly default: InputMaybe
+ readonly tmMatch: InputMaybe
+ readonly total: InputMaybe
+ }
+
+ type AlltimeJsonDataLanguagesTranslatedFilterInput = {
+ readonly default: InputMaybe
+ readonly tmMatch: InputMaybe
+ readonly total: InputMaybe
+ }
+
+ type AlltimeJsonDataLanguagesTranslationCosts = {
+ readonly default: Maybe
+ readonly tmMatch: Maybe
+ readonly total: Maybe
+ }
+
+ type AlltimeJsonDataLanguagesTranslationCostsFilterInput = {
+ readonly default: InputMaybe
+ readonly tmMatch: InputMaybe
+ readonly total: InputMaybe
+ }
+
+ type AlltimeJsonDataUser = {
+ readonly avatarUrl: Maybe
+ readonly fullName: Maybe
+ readonly id: Maybe
+ readonly preTranslated: Maybe
+ readonly totalCosts: Maybe
+ readonly userRole: Maybe
+ readonly username: Maybe
+ }
+
+ type AlltimeJsonDataUserFilterInput = {
+ readonly avatarUrl: InputMaybe
+ readonly fullName: InputMaybe
+ readonly id: InputMaybe
+ readonly preTranslated: InputMaybe