Anatomy of an Ethereum Client

The overview of the building blocks of an Ethereum client: what any client implementation should have. A practical perspective on how Ethereum works under the hood.

Casper and Consensus

Emin Gün Sirer, Peter Czaban, Vitalik Buterin, Vlad Zamfir, and Elaine Shi discuss "Casper & Consensus"

Ethereum in 25 Minutes, Version MMXVII

So what are all of the different moving parts of the Ethereum blockchain? What are uncles, how do contracts call other contracts, who runs them? What is the role of proof of work and proof of stake, and what exactly is gas? What will EIP86 do for you? Vitalik Buterin provides a 25-minute technical overview of the ethereum blockchain, start to finish, and explain many of these concepts in detail.

Evolving the EVM

A discussion focusing on the evolution of the Ethereum Virtual Machine (EVM).

Exploring the Ethereum Blockchain

This talk is about my experience building and using a block explorer for the Ethereum blockchain, which will provide a statistics highlight of the Ethereum blockchain and demographics of the Ethereum user base. The demographics portion will based on analytical data generated over the past years from Etherscan.io, which will assist new/existing developers on building a better user experience by first understanding who their potential target audiences are.

The EVM: Leaner, Meaner, and Closer to the Metal

Dr. Greg Colvin gives their talk titled, "The EVM: Leaner, Meaner, and Closer to the Metal"

Verifying Casper

Why you can be certain that the four slashing conditions of Casper are enough to catch forks.

Using Ethereum for Secure Decentralized Optimization

We demonstrate how complicated optimization problems can be solved by combining decentralized optimization algorithms with an aggregation step in a smart contract. Using tools from convex optimization, we decompose difficult problems into a set of subproblems with can be computed off-blockchain, finally reaching consensus on the global optimum by passing message with the on-blockchain aggregation step. We present an example of applying this approach to optimizing power dispatch on an electricity grid, but the approach can also be used to solve other problems in machine learning, coordinating robotic agents, or coordinating economic systems.

Ethereum for Dummies

Ethereum's CTO Dr. Gavin Wood presents "Ethereum for Dummies" or "So, now we've built it, WTF is it?"

Keynote and Ethereum roadmap

In this first video from the ÐΞVCON ONE series, Vitalik Buterin, Jeffrey Wilcke, Alex van de Sande and Gavin Wood present the Ethereum roadmap.

Understanding the Ethereum Blockchain Protocol

Ethereum's Vitalik Buterin presents on the intricacies of the Ethereum Blockchain Protocol.

Accountable Watching Services (PISA)

At Devcon IV, we presented PISA, a solution to help alleviate the online requirements for state channels. Thanks to an Ethereum Foundation grant, the team has taken the idea of an 'accountable watching service' further to help alleviate the online requirement for other off-chain protocols such as Plasma and in general most smart contracts. What do we mean that PISA is usable by most smart contracts? Ideally, if we consider a smart contract where the user has to be online and watching for an on-chain event, then PISA can be hired to protect them (and perform the final step). Our goal is to help improve the UX for most smart contracts as users can simply go off-line and PISA can finish the task in a financially accountable manner. In this talk, we'll discuss the substantial changes to PISA such that it can be generically used for most smart contracts. We'll discuss the implementation of PISA, the open-source project, and how other projects can use our simple API to sign up to the accountable watching service.

Chainalysis: Building Trust in the Ethereum Blockchain

Mikkel Jensen & Surya Rastogi give their talk on Chainalysis & Building Trust in the Ethereum Blockchain

Complexities in Aggregation at Scale

Mikhail Kalinin presents Complexities in Aggregation at Scale.

Cryptoeconomics In 30 Minutes

Vitalik gives a quick overview behind Cryptoeconomics.

Ethereum Roadmap 2020 Say Hello and Opening Ceremony

The Ethereum Magicians open Devcon 5.

Ewasm 2.0 - State Execution in Eth 2.0

This session aims to bring clarity to what execution on Eth 2.0 means. It will be presented by multiple members of the Ewasm team, starting with a historical overview of how Eth 2.0 designs evolved around execution, followed by deeper technical topics. We will cover: - Scout (an Eth 2.0 execution engine) - Different execution environments (such as the "Eth1 shard") - In-depth presentation of different designs used in the Eth 2.0 stateless model - An Eth 2.0 execution testnet If you are interested in stateless contracts and Merkle proofs, this is the session to attend.

Ewasm: Past, Present, Future

Starting with a brief introduction, we explain the challenges, design directions, and the work done in the last 12 months. We conclude with a roadmap of Ewasm. The session will consist of four parts: 1. Introduction 2. Speed, Size, and Extensibility – a honest report of Wasm in Ethereum (aka "The Benchmarking Report") 3. Is Wasm suitable for blockchain? This part will explain the changes (if any) needed for Wasm, questions relevant to blockchain, and solutions developed and proposed. 4. Roadmap

Funding ETH 1.x With Network Upgrade Sponsors

In this lightning talk, we will propose an auction mechanism to sponsor Ethereum Network Upgrades and use the proceeds to fund Ethereum 1.x initiatives. The talk will (quickly!) go over the proposed auction scheme, distribution of funds, and common objections to & potential pitfalls of this model.

EVM Roundtable: everything you wanted to ask, but were afraid to

A fishbowl style conversation with passionate contributors to the EVM, but allowing anyone from the audience to stand up and lead a topic. The intent is to discuss certain key topics, such as how to evolve the EVM, what the most pressing issues are, and dissecting a handful of EVM proposals.

Grantee Exposé Lightning Talk 3 - Academic Research on Casper

CBC Casper is a promising protocol for the future of Ethereum. However, the research of CBC Casper is still in progress, even about its fundamentals. For example, Casper has been criticized for the lack of liveness proof for a long time. Therefore, we first introduce our liveness proof. Then, we analyze CBC Casper in both its performance & incentive to persuade the audience why CBC Casper matters.  This presentation is based on our unpublished work, which we expect to publish by the time of DEVCON5. The more detailed agenda is: (1) Liveness: We first introduce our liveness proof, which is applicable to each family of CBC Casper. (2) Performance analysis:  We compare CBC Casper with other existing protocols about  TPS and latency, both of which are important performance measures of consensus protocols, showing the advantages of CBC Casper. (3) Incentive analysis: CBC Casper is designed to satisfy economic properties desired for a public ledger. In particular, the notable feature of CBC Casper is "subjective finality", where validators can pick up their own fault threshold. We discuss how this feature affects cartel resistance.

Guidance on Assessing a Blockchain Platform

Blockchain platforms are maturing to enable decentralized architecture but vary in design depending on deployment environments, such as open digital ecosystems or contained multiparty environments. In this session we provide a summary of Gartner's observations on blockchain platforms adoption, a functional framework for assessing blockchain platforms, and future projections on blockchain platforms technical evolution.

Improving the federated 2-way peg: A new sidechain design for trustless bridges on Ethereum

In this talk, we'll introduce a novel mechanism to maintain 2-way pegs, as well an initial implementation of a Bitcoin peg on Ethereum. ## Problem Bitcoin's stable codebase is a strength. Developers are loathe to introduce significant changes, reasoning that a store of value should prioritize stable operation. While this cemented Bitcoin's place in the market, we all know the costs- Bitcoin's ossification at the expense of public experimentation and diverse use cases. In 2014, the answer to this problem was "sidechains". Trustless sidechains are the ultimate vaporware- and since 2014 the goalposts have moved. ## Approaches Blockstream's Liquid touted itself as the "first production sidechain", built on a multi-sig federation. No hashpower validates the sidechain-- funds are fully trusted to 15 Bitcoin multi-sig participants. BitGo's WBTC takes a similar tact-- but instead of building a new chain, custodians operate on Ethereum. Neat! Unfortunately, they require KYC :( These centralized projects have a few custodians that can be convinced by governments-- or their own interests-- to censor or seize funds. ## Design We propose a new approach-- the *bonded, multi-federated peg*. We believe this is the best candidate for a sufficiently trust-minimized alternative, unlocking Bitcoin for use in DeFi.

K Semantic Model of Beacon Chain

Daejun Park gives an overview of the K-Semantic Model of the Beacon Chain.

Kicking Our Infura Addiction: A Quick-Launch Client

How do you connect to mainnet? To minimize effort, there is one obvious answer: Infura. Infura has its place, but using it everywhere means giving up so many of the core promises that Ethereum makes. So how can we make it easier to run your own node and actually deliver on Ethereum's promises? One of the worst parts of starting up your own node from scratch is the launch time. If you're very lucky, you can count launch time in hours. Any less lucky, and you'll be counting in days. In this talk, I explore how to reduce cold-start launch time to minutes. I cover the approach of downloading just the state required to execute the most recent blocks. It requires a new execution strategy, and is significantly accelerated by a supplemental network protocol. I show the progress in a client that I prototyped it in: Trinity.

Lightning fast light clients for the future of Ethereum

The presentation focuses on recent developments of the Go Ethereum light client project (LES) and their relevance for both ETH1.x and ETH2.0. Significant progress has been made towards an efficient and truly decentralized network incentivization model. In addition to solving the hard problem of LES service availability, it can also serve as a PoC for our future networks where a proper incentivization layer will be key to a scalable and reliable infrastructure. The talk covers the following topics: - the challenges of creating a healthy service market in a low-trust environment - building trust between pseudonymous participants without central authorities - guarantees for good performance and quick response times - a two-layered model that allows using different pricing schemes on top of a common simple base layer - more advanced applications and network topologies - a quick demo of how you can already use micropayments with LES

Opportunities for Collaboration: ETH1x and Ethereum Classic

Join us to consider options for collaboration between the Ethereum and Ethereum Classic communities. As a result of significant changes underway in ETC, there are several new and positive sum opportunities for cooperation. Ethereum Classic Labs and it’s core development team is committed to contributing to the Ethereum Classic and Ethereum ecosystems. ETC has been adopting ETH upgrades on ETC to ensure compatibility; and both the ETH and ETC communities have been building bridges and identifying mutually beneficial and complementary activities. We will discuss specific paths for technical development and community engagement going forward. We will also announce several new and exciting developments.

Optimization techniques for EVM implementations

A number of optimization techniques for Ethereum Virtual Machine implementations are going to be presented along with examples and benchmarks based on evmone and EVMJIT projects. Based on performed benchmarks, the presentation will show ~10x speed improvements in evmone comparing to other EVM implementations. While evmone is build in C++, the optimizations are not limited to C++. All of the optimizations are applicable to any compiled language, some of them even to interpreted languages.

Overcoming the smart contract size limit

EIP 170 introduced a limit of 24KB on bytecode size of smart contracts in Ethereum. This talk will explain the rationale behind the decision and then talk about overcoming or playing around the limit. The talk will cover ways like proxy patterns and libraries for working around the limit. Tips on optimizing code for reducing bytecode size will also be shared. The talk will then explain new proposals for removing the contract size limit while still fixing the original problem.

Scaling Many to Many Payments with Probabilisitic Micropayments

Probabilistic Micropayments, in which a sender pays a recipient with a form of lottery ticket for services performed, present an alternative payment scaling solution to state channels that bring advantages in certain use cases such as stream data processing and distributed compute. In this talk we'll present an overview of this form of micropayments, compare and contrast them to hub and spoke payment channels, show the security model against double-spends, present benchmarks from real world usage within the Livepeer protocol, and showcase an open source implementation.

Securing Layer 2 Networks with Ethereum, Decentralized Storage, and Shared Fishermen

Running data-intensive applications on top of existing blockchain platforms remains a challenge. Modern blockchains are designed for maximum security and have limited compute and storage capacity, which means they are too expensive to handle nontrivial amounts of data. However, traditional applications often need high transaction throughput and low latency of request processing. I will show how to address the scalability and cost efficiency requirements with a hybrid architecture composed of several layers. Speed layer consists of real-time shards directly talking to a client; security layer provides finality and consists of fishermen verifying past speed layer behavior; dispute resolution is served by the Ethereum smart contract; finally, decentralized storage networks such as Swarm or IPFS provide data availability. In this talk, we will go through the hybrid architecture approach and explore how it can make the cost of running a classical database (e.g., Redis or SQLite) in the decentralized environment comparable to its centralized deployments without compromising security.

Simulating Ethereum network with SimBlock

SimBlock is a blockchain network simulator. It was designed as an event-driven simulator wherein each participating node behaves according to generated events, e.g., block generation and exchanging messages. This simulator supports Bitcoin, Dogecoin, Litecoin networks and has already been used in several studies about block propagation delay and fork rate. We are developing to support Ethereum, which will allow Ethereum developers or researchers to obtain more realistic data, such as in setting block generation intervals and designing neighbor node selection algorithms. In this presentation, we will show an experiment on how GHOST improves blockchain security as an application of SimBlock. GHOST is a block selection protocol being developed together with Casper, which is PoS protocol of Ethereum. GHOST has been shown analytically to improve blockchain security, but there is little experimental support. In this experiment, we compare the attack success rate in several parameters with the longest protocol.We would like to introduce a practical simulator and get your opinion on future SimBlock Ethereum support.

STARK: From Paper to Product

In this talk, we will describe how we're building a scalability engine for self-custodial trading and payments. We will also describe how to build a STARK-based product over Ethereum, and our contributions to the Ethereum ecosystem (EIP-2028, STARK-friendly hash functions, etc.)

State Channels

Over the past several months, Ethereum's leading state channels researchers and engineers have worked to unify their protocols and implementations. The result is a single state channels network, compatible with all major state channel implementations. Liam Horne and Tom Close will introduce the audience to their work, the State Channels Improvement Proposals (SCIP) process, explain how developers can get started building on it, and provide a live demo of the network in action.

The Next Ethereum Story

The external narrative about Ethereum runs alongside the conversations we have in the community. How much they intersect depends on the day. Members of the Ethereum community influence that narrative, but they are far from the only actors shaping perception. Among these are a motley crew of journalists, government officials, social media personalities, and venture capitalists, with varying degrees of technical savvy, as Ethereum collides with our media environment, market conditions, and geopolitics.Ethereum is young enough that our actions impact its story, which can help or hurt our ecosystem as a whole. With this power should come responsibility. As Ethereum grows and further decentralizes, it's up to the builders of each new generation of projects to write the next chapter.In this workshop, Riley Kim, Asia Pacific PR Lead at ConsenSys, and I will present a history of Ethereum through the lens of public perception up to the present, focused on how media in English-speaking and Asian markets have told its story. Then we will facilitate a collaborative activity to brainstorm a shared Ethereum narrative for the future.

The Surprising Things We Can Do with Decompiled Smart Contracts

Over the last year we have seen a lot of development in the field of smart contract decompilation. This in turn has opened up a lot of new possibilities: -better user interfaces -new ways of finding security flaws -making decisions regarding the future of protocol -network analysis. The talk will show some interesting things that were built during the last year.

The Optimistic Virtual Machine: an Ov(m)erview

The Optimistic Virtual Machine (OVM) is a language for expressing layer 2 scaling solutions like state channels and plasma as a local fork choice. The language is built on a formal model of logical game semantics, along with a "cryptoeconomic dispute assumption." Composing these primitives allows us to describe complex properties of layer 2 state. These layer 2 systems can be written as OVM "programs" which are compiled into both a client-side "proof checker" (the local OVM) and ethereum-side code. The Ethereum code acts as OVM "interpreter" contract on the Ethereum blockchain, which can interpret disputes for any and all of these layer 2 system (state channels, plasmas, etc.). We will go over the details of both the game semantics and Ethereum smart contracts in this workshop.

Toward Backward Compatible Ethereum Upgrades

Ethereum's last hard fork Constantinople and the current ongoing Istanbul hard fork all bring in an important topic that wasn't previously strongly considered -- backward compatibility. In this presentation, we will explain why this is an issue, and why when reviewing EIPs for inclusion, only talking about soundness of the EIP is not enough. We will explore techniques that are being proposed to solve this issue -- most importantly, account versioning, and how it enables EIPs being included hassle-free, and also allow us to drastically change the VM in the future. The presentation will conclude with current challenges we are still facing regarding backward compatibility, and if time permits, traits that we can use when reviewing an EIP to understand whether it requires account versioning or not.

Trains, Planes and Network Upgrades: A Regular Release Cadence

How does an Ethereum Improvement Proposal (EIP) get deployed onto the Ethereum mainnet? At times it feels like an ‘80s buddy comedy, but as part of the Ethereum 1.x initiative, the process should become as predictable as a clock. In this talk, we will propose a regularly scheduled process modeled after Linux distributions and the Java platform that Ethereum could use for its future network upgrades. Frequent and regular network upgrades will remove the time pressure to submit and review EIPs, provide predictability to applications building on Ethereum and reduce the burden on core developers to begin implementing improvements that are not ready. Once a network upgrade leaves the station, another one will be coming right around the corner!

Validating designs and finding points of failure: Testing ETH 1.x and ETH 2.0 against AI agents

We’ve introduced the notion of machine learning algorithms in our network of simulator: Wittgenstein. We explore the different strategies that can be taken by participants in the network to attack the system or manipulate protocol’s design to increase rewards. We focus specifically in reinforcement learning, and set up different agents that engage in different byzantine behaviours. We present results and guidelines to improve the design of protocols such as PoW, Casper and others.

What is happening with Ethereum Classic?

2019 has been an exciting year for the Ethereum Classic community. Three years on from The DAO the focus is on developer experience, on coordinating hard forks to bring Byzantium, Constantinople and Istanbul changes to ETC, and looking forward to opportunities for collaboration with ETH 1.x. This presentation gives an overview of the ETC ecosystem, progress in the last year and some ideas on how ETH 1.x and ETC can work together for mutual benefit. Bob has worked at the Ethereum Foundation, ConsenSys, Enterprise Ethereum Alliance and now at the Ethereum Classic Cooperative.

Yul, eWasm, Solidity: Progress and Future Plans

Over the last months, the Yul language has matured and proved its flexibility. The Solidity team has implemented an optimizer and an eWasm dialect and is now full steam working on rewriting the Solidity code generator to produce Yul code to replace sequences of EVM instructions.The Yul optimizer now matches the old EVM optimizer and already surpasses it with features like function inlining and cross-function optimization. This is also the main reason why the new code generator can be written in a super-modular way. Furthermore, it can equally operate on EVM- and eWasm-flavoured Yul code, which is important to cope with the 256- to 64-bit translation.Through this, the Solidity compiler can now output eWasm code, which makes efficient use of 64 bit types. Furthermore, the new code generator includes automated overflow checks everywhere, again something that would have destroyed the old optimizer. Future work:We plan to use a more intricate formal system to remove redundant operations and checks based on range-relations between variables. The introduction of memory area types will help optimizing memory allocation. Finally, a super-optimizer could prove useful, since it is worth spending extra time on compilation to save gas.

Challenges of Parallelizability under Ethereum's Execution Model

We highlight two challenges of parallel execution on Ethereum: 1. Historical data shows that data dependencies force us to execute a large portion of transactions serially. 2. If we assign incentives to scheduling decisions, this might introduce non-determinism that the system cannot tolerate. In this lightning talk, we present these two problems and outline some proposed solutions. Note that this work was accepted for and presented at ICSE'22 (https://bit.ly/3HzPKZT)

Danksharding Workshop

Danksharding (full danksharding and EIP-4844) is the Ethereum layer 1 scaling protocol that Ethereum R&D teams are working on these days. This workshop is organized by the Ethereum Foundation Consensus R&D team. We will introduce to you the danksharding family solutions.

Debugging the Ethereum Merge with Parallel Universes

The Ethereum merge is a high-stakes event for the entire industry, and requires several large, stateful, distributed software systems to behave flawlessly in order for it to succeed. Unfortunately, it’s very difficult to develop distributed stateful systems like a blockchain with high confidence. Many of the worst bugs in these systems don’t show up in the happy case, but require particular network, hardware, or timing conditions in order to manifest.

EELS: The Future of Execution Layer Specifications

Peter Davies gives an overview of the work of the EELS (Ethereum Execution Layer Specifications) team on the [new executable specifications](https://github.com/ethereum/execution-specs) for the Ethereum execution layer. He discusses why new specifications are needed and how they will impact future governance processes.

Ethereum Magicians Protocol Roadmap Session

Join us for a conversation with protocol developers, researchers and more covering learnings from The Merge, potential future changes to the Ethereum protocol & its governance process, and lightning talks on proposed Core EIPs. Find overview agenda in ETH Magicians post https://ethereum-magicians.org/t/ethereum-magicians-protocol-roadmap-session-devcon-vi/10866

How to Ethically Build Public Good Infrastructure

We at Status have been working to enable an interface to Web3 since our inception. We bought into the principles of this ecosystem, and have spent extraordinary effort to not compromise on those ethics while we continue to create applications that are easily accessible while also maintaining our user's rights. This talk is an overview of this journey, lessons learned, the fruits of this labor, why we're doubling down on this process, and why you should to.

How to Scale a Blockchain: Motivating the Ethereum Rollup-Centric Roadmap

Scaling blockchains to support billions of users without compromising decentralization is one of the biggest remaining challenges in the crypto space. This talk will showcase why there is a fundamental scalability-dencentralization tradeoff for any monolithic chain, and how scalable rollups on top of decentralized settlement chains can overcome this tradeoff. What implications does this have for the future of Ethereum? Beginner friendly, with pictures!

How to use Executable Consensus Pyspec

Ethereum consensus pyspec (https://github.com/ethereum/consensus-specs) is an executable specification that serves as a reference for consensus layer devs. It is also used for creating the test case vectors for client teams. In this lightning talk, we will have a tutorial on how to run the Ethereum consensus pyspec. And bonus, learn how to write a test by yourself!

Hybrid PBS from CL's Perspective

The talk seeks to address the following questions: - Why does PBS matter from CL's point of view? What happens if we completely ignore it on the protocol layer? What if we wait to release it? - How did we implement hybrid PBS on CL clients from history to functional products? - What do they look like in code? - What are the gotchas and the trade-offs? - What are the remaining questions we shall seek before moving to full PBS?

Killing ETH - Finding Consensus Issues on Layer 1

Ethereum's core protocol is highly security critical and thus needs to be tested thoroughly. This talk will discuss the testing methods we use to make sure that all execution layer clients implement the same protocol: - Regression testing on hive - EVM-fuzzing - Devnets - Shadow forks We will discuss a bunch of interesting issues that we found with that

Light Clients After the Merge

The merge unlocks a new era of truly light clients that can stay in sync with the Ethereum network using just 20 bytes / second. All obtained data can be verified in a trust-minimized manner, reducing the risk of a rogue centralized API provider serving incorrect data. This talk describes the latest advancements in CL light client protocols.

Light Client Self Led Session

tbd

Lodestar: Metrics-Driven Development

Lodestar is the newest production-ready consensus client, written entirely in TypeScript. How did we do it? How did we go from buggy, slow, and scared to agile, confident chads? Metrics, metrics, metrics! We will introduce the concept of metrics-driven development in the context of blockchain node development and give fun examples where metrics saved our hide, time and time again.

MEV for the Next Billion: It's Time to Get Serious...

We will take a birds-eye view of research, industry, and L1 developments on MEV. We start with the reasons behind the origins of MEV, a years-old warnings to developers. We revisit these against an explosion of research and industry interest in MEV. We cover the big picture of why these topics, including PBS, MEV auctions, MEV ethics, "fair ordering", cryptography, etc. are key to the decentralization and UX of L1. We will attempt to provide a roadmap to avoid the centralizing effects of MEV.

Post-Merge Ethereum Client Architecture

Take a look at the key components of a post-merge Ethereum "node" and how they fit together, encompassing both the consensus and execution clients. How do the two clients work together? What impact does the different designs of clients have on that? And what opportunities are there for execution and consensus clients to work together better in the future? Let's break down the knowledge silos between consensus and execution layers to get the most out of merged future of Ethereum.

Quest for the Best Tests, a Retrospective on #TestingTheMerge

A retrospective on #TestingTheMerge and all the various testing avenues we explored. I'd also give a brief summary of what went right and wrong in our approach.

Reducing Beacon Chain Bandwidth for Institutional and Home Stakers

This talk gives an overview of the networking infrastructure of beacon nodes and details some of the recent research being done significantly reduce the growing bandwidth requirements of the Ethereum consensus layer. In particular, we will discuss the network requirements of gossipsub, how long-lived subnets can be the cause and a potential solution to high bandwidth usage as well as preliminary results from experiments with an experimental extension to the gossipsub protocol, episub.

Social Slashing

Censorship resistance is not a property of the protocol, it is a property of the community. The Ethereum community controls one of the most powerful tools in the crypto universe to combat censorship—but no one currently knows exactly how to use it. Swing by this talk to prepare yourself. What's at stake? Everything.

Stateless Ethereum: How Verkle Trees Make Ethereum Lean and Mean

This talk goes over the changes brought by verkle trees. It will give a high-level overview of the technical changes, an update on the implementation of verkle trees, and paint a picture of a stateless Ethereum.

The KZG Ceremony - or How I Learnt to Stop Worrying and Love Trusted Setups

Danksharding, ProtoDanksharding, & EIP4844 make use of KZG commitments which require a trusted setup. As usual, Ethereum does this differently by having an order of magnitude more participants than previous trusted setups. I will be running through why the trusted setup is needed, how it works, and why you should trust it.

The Portal Network

The Portal Network is the culmination of five years of development and research targeting lightweight access to the Ethereum Protocol. Learn what the Portal Network is, how it works, and what it will mean for Ethereum to have a reliable decentralized network tailor made for end users to interact with the Ethereum protocol.

Time in Ethereum - on the implications of replacing our dear friend Poisson

Time in PoW is a random process, whereas in PoS we make progress in fixed time intervals. This has far reaching implications and incentivizing timely behavior by validators is non-trivial - especially in the context of MEV.

What Alternative Blockchains Compatibility with Ethereum Tooling Can Teach Us About Ethereum's Future

In this talk the various techniques that some L1s and L2s use to provide EVM and RPC compatibility with end user and developer tooling will be examined. Special attention will be paid to features (address aliasing and expansion, RPC handing of system contracts, account abstraction) of other blockchains that Ethereum developers have discussed with an eye towards the compatibility issues they introduce.