Ethereum 1.x: On blockchain interop and scaling

Vlad Zamfir and Vitalik Buterin present their latest research on blockchain interoperability and scaling as part of DEVCON 0.

The Path to the Ethereum Light Client

Vitalik Buterin and Dr. Gavin Wood take a look at the Ethereum light client roadmap.

Scalable Blockchains & Asynchronous Programming

Ethereum's Vitalik Buterin presents on scalability and asynchronous programming.

Layer 2s

Ethereum's Dr. Gavin Wood moderates a panel with Vitalik Buterin, Martin Becze, Dominic Williams and Vlad Zamfir on scalability with Ethereum.

The Pathway to Ethereum Adoption

A panel focusing on "The Pathway to Ethereum Adoption" with Vinay Gupta (https://twitter.com/leashless), Gavin Wood (https://twitter.com/gavofyork), Joseph Lubin (https://twitter.com/ethereumJoseph) and William Mougayar (https://twitter.com/wmougayar).

Universal Hash Time

Jeff Coleman of Ledger Labs (http://ledgerlabs.io/) presents on the Universal Hash Time + State Channels.

Build and Operate Internet-Scale Ethereum dApps on Celer Network

Current Ethereum dApps have low throughput because each operation needs to be processed by the vast majority of nodes to reach on-chain consensus. Off-chain scaling techniques such as state channel are able to support truly scale-out dApps with better privacy and no compromise on the trust-free guarantee. Despite its high potentials, off-chain scaling is still in its infancy with challenges remaining unsolved. For example, how to construct state channels that support arbitrary state transitions with minimal on-chain operations? How to route payments to achieve high throughput in an off-chain network that is fundamentally different from data networks? How to help developers to easily build and operate scalable off-chain dApps? How to guarantee that off-chain states are always available for possible disputes? In this talk, we will describe how Celer Network meets these challenges. Celer embraces a layered architecture with clean abstractions that enable rapid evolution of each individual component, including generalized state channels that supports fast and generic off-chain state transitions; a provably optimal payment routing algorithm that achieves orders of magnitude higher throughput compared to state-of-the-art solutions; a powerful development framework and runtime for off-chain dApps; and an incentive-aligned mechanism that provides stable liquidity and high off-chain state availability.

Building a state channel application

State channels are a great tool for building high-performance, low-cost dapps today. By moving some of your dapp behaviour off-chain you can save transaction fees and confirmation times, while continuing to bootstrap security and trustlessness from the underlying blockchain. In order to understand how an application can benefit from state channels, it’s important to understand the mechanics behind them. The good news is that once you’ve managed to model part of your application as a state channel interaction, there are already tools available to help make the switch.In this interactive workshop, we will dig into an existing state channel application. We’ll cover the fundamentals of state channels, as well as the main design decisions behind modeling the interactions and architecting the application. You’ll test your understanding by completing key sections of the code, leaving the session with a functioning state channel application, built with react on top of the force-move games framework!

Cryptoeconomics at Scale

The next wave of internet applications will not only compete on functionality, but also incentives. With cryptoeconomic research we are witnessing the beginnings of incentive analysis being applied to the architecture of internet protocols. As this body of research grows, common methodologies are beginning to emerge. These methodologies are also beginning to be composed to produce even more sophisticated and scalable protocols. This talk provides an overview of these cryptoeconomic methodologies and calls for help in the quest to build a fairer web.

Ethereum 2.0 implementation updates 4Q2018/Prysmatic Labs: Implementing Ethereum 2.0 Today

The sharding implementation updates 4Q2018, mainly on Python side. // Sharding and layer-1 scalability are perhaps the most important, forward-thinking changes that Ethereum 2.0 will implement. Ever since the inception of the Sharding FAQ by Vitalik, both the foundation’s research team and the community have actively engaged in bringing ideas together into a solid specification and road ahead for the future of Ethereum. This task will focus around the ins-and-outs of building the high-level Ethereum 2.0’s Casper & Sharding spec into granular code by one of the main sharding implementation teams, Prysmatic Labs. We will analyze caveats we ran into when designing Ethereum 2.0 while the research is still in flux. Ethereum 2.0 encompasses a lot more than software upgrades, as it gives developers the opportunity to pave a path with better design capabilities, a better open source contribution ecosystem through documentations, and a more modular, pluggable set of tools built to last the test of time. We assembled organically as a team to build this out, and we aim to give back to the community from what we have learned so far in terms of building on a volatile research spes, attracting open source talent, mitigating technical debt, and why transparency and public work are important.

From Scalability to Inclusion: Enabling Mass Adoption

David Lee Kuo Chuen gives his talk on Enabling Mass Adoption.

Fraud Proofs: Maximising Light Client Security and Scaling Blockchains with Dishonest Majorities

Light clients are nodes which only download a small portion of all of the data in a blockchain, and try to use indirect means to verify that a given chain is valid. Typically, instead of validating block data, they assume that the chain favoured by the blockchain's consensus algorithm only contains valid blocks, and that the majority of block producers are honest. By allowing such clients to receive fraud proofs generated by fully validating nodes that a block violates the protocol rules, we can eliminate the assumption that the majority of consensus-participating nodes are honest, and instead assume that there is at least one honest fully validating node that can distribute fraud proofs within a maximum network delay, and a minimum number of honest light clients to reconstruct missing data from blocks. Fraud proofs and data availability proofs are key to enabling on-chain scaling of blockchains (e.g. via sharding or bigger blocks) without significantly reducing the ability of end-user wallets to have assurance that all on-chain data is available and valid. We present, implement, and evaluate a novel complete fraud proof and data availability proof system. Research paper draft (work-in-progress): https://www.dropbox.com/s/3zj3burdfrw5v69/fraudproofs-paper.pdf Data availability code: https://github.com/musalbas/rsmt2d Fraud proofs prototype (work-in-progress): https://github.com/asonnino/fraudproofs-prototype

FunFair Technologies' Fate Channels: Lessons learned Implementing State Channels

Jeremy Longley, CTO of FunFair Technologies, will offer a post-mortem on the delivery of their own version of state channels, Fate Channels, to Mainnet. There have been significant challenges along the way, and there's likely to be many more to come as their use scales up. Having deployed a flexible and creative approach, Jeremy will outline how others can bypass these challenges and embrace state channels as best they can.

INCUBED - A trustless incentivized decentralized remote node network

To enable smart devices of the Internet of Things to be connected to the Ethereum blockchain, an Ethereum client needs to run on hardware. While running a full-node or even a light-client on most IoT devices with low performance or restricted resources is not possible or meaningful, today's state-of-the art solution uses a remote client. By using distinct remote-nodes, the advantages of a decentralized network without being forced to trust single players are undermined and there is a risk of malfunction or attack because there is a single point of failure.With the presented Trustless Incentivized Decentralized Remote Node Network, in short INCUBED, with a stateless minimal verification client it is possible to establish a decentralized and secure network of remote-nodes, which enables trustworthy and fast access to blockchain for a large number of low-performance IoT devices.

Introducing Pantheon, a Mainnet Java Client - Demo & Roadmap

This will be the launch of Pantheon, a Java client built for mainnet with an eye for meeting enterprise requirements. Having multiple, performant clients is important to the long-term viability of the Ethereum ecosystem, and enterprise adoption will draw greater resources. This will be a demo of the new client with a walk-through of our roadmap. By introducing a client in Java and building it open source, we’re hoping to draw in the massive Java community into the Ethereum ecosystem, support research and innovation led by the Ethereum Foundation, and add extensions to meet enterprise needs on privacy, permissioning, and others. We will also talk about some of our research efforts on top of Pantheon.

Less Gas, More Fun: Optimising Smart Contracts through Yul

Due to the relative simplicity of the Ethereum Virtual Machine, it is possible to perform heavy analyses in order to optimize bytecode. The jump operations are a main obstacle for this, because they might require a preservation of all basic blocks in the worst case. To overcome this, Solidity's new optimizer operates on an intermediate language called Yul, which is close to EVM bytecode (and also wasm) but abstracts jump operations through real function calls. Each of the many optimizing operations are simple local equivalence transforms whose effects can be inspected at any time and which in combination should be both more reliable and efficient than the classic optimizer.

Mustekala Project: MetaMask to become a light client over libp2p

MetaMask Labs is doing research for the browser extension to become a light client running on top of libp2p. The project codename is Mustekala. As of now, we have fleshed out a comprehensive architecture (https://github.com/MetaMask/mustekala/blob/master/docs/architecture.md) of four layers, where we extract data from devp2p synchronized clients and make it available in libp2p using the IPLD format. Upstream, an overlay network of peers (named kitsunet) shares this information, allowing data redundancy and decentralization at face value. In terms of vision, in a close future low resource devices (browsers, mobile and IoT) should stop depending on JSON RPC communication with ethereum nodes. This is a huge problem today, as nodes became GB-sized machines. Last but not least, every MetaMask user will become a peer of a bigger and more inclusive ethereum network.

Making Sense of Layer 2

This talk will be a high level overview of the state-of-the-art in "Layer 2" scaling tech. The goal is to give the audience a comparative understanding of techniques like state channels, plasma (and its various flavours), sidechains, etc. Introduce a basic taxonomy of layer 2 tech -What are the similarities and differences between them? -Comparative analysis - what is each technique good at and bad at? -Defining and explaining jargon used to discuss this tech -Distinguishing between "safety net preserving" techniques (plasma, state channels) and others (sidechains)

P2P Networking in Ethereum 2.0

Sharding and Casper promise to greatly improve performance, sustainability, and security of the Ethereum blockchain. Alongside a novel and much-discussed consensus protocol, they also entail fundamental changes to the requirements and constraints imposed on the peer-to-peer (p2p) networking layer. In this talk we report on ongoing research as well as the current implementation state of the latter. We begin by defining key qualitative and quantative properties the network should have. Then we discuss several options for both node discovery and gossip protocols, comparing their performance on the basis of simulationresults. Finally, we give an update on the current state and future developments of protocol implementations.

PISA: Arbitration Outsourcing for State Channels

PISA alleviates the "always online assumption" for all channel protocols and it is necessary for Raiden, L4, Perun, etc. State channels are a leading approach for improving the scalability of blockchains and cryptocurrencies. They allow a group of distrustful parties to optimistically execute an application-defined a program amongst themselves, while the blockchain serves as a backstop in case of a dispute or abort. This effectively bypasses the congestion, fees and performance constraints of the underlying blockchain in the typical case. However, state channels introduce a new and undesirable assumption that a party must remain on-line and synchronised with the blockchain at all times to defend against execution fork attacks. An execution fork can revert a state channel’s history, potentially causing financial damage to a party that is innocent except for having crashed. To provide security even to parties that may go offline for an extended period of time, we present Pisa, a protocol which enables such parties to delegate to a third party, called the custodian, to cancel execution forks on their behalf. To evaluate Pisa, we provide a proof-of-concept implementation for a simplified Sprites and we demonstrate that it is cost-efficient to deploy on the Ethereum network. Blog+Paper: http://hackingdistributed.com/2018/05/22/pisa/

Plasma Cash: Towards improved Plasma constructions

Plasma is a technique which is used to increase Ethereum transaction throughput, while maintaining network decentralization and security. We focus on the variant of Plasma called Plasma Cash, which allows for highly performant sidechains in production, today. We discuss Plasma Exits and Challenges as well as explore the User Interface choices for Plasma Apps. We go over the challenges encountered during the development and final implementation of a Plasma chain and contract. The presentation will highlight the advantages and disadvantages of using Plasma Cash, as well as practical examples of Plasma for Non Fungible Tokens and gaming. Finally, we'll talk about edge-cases such as griefing attacks, and future work towards making Plasma implementations more efficient, such as fast exits through liquidity providers, coin checkpointing through Plasma XT and arbitrary coin denominations through Plasma Debit. The audience is expected to walk away with a detailed understanding of how Plasma Chains should be built as well as the inner workings of the Plasma Cash technique. More experienced individuals who understand but are not following Plasma actively are expected to walk away with an overview of the current status of Plasma research and development, and motivated to tackle the existing open research problems.

Perun: Virtual Payment and State Channel Networks

In this talk, we will present the Perun Network: a general framework of 2nd layer protocols supporting off-chain payments and arbitrary smart contract off-chain execution. Perun allows its users to execute contracts off-chain via complex state channel networks possibly involving many intermediaries over which contract execution can be routed.   One distinctive feature of Perun is that its channels can be virtual, meaning that once a virtual channel is established transactions can be executed even without involvement of the intermediaries. This enables nearly real-time transaction execution with minimal latency at negligible costs. Moreover, privacy of transactions is significantly improved. An additional property of Perun is that its security is backed up by formal proofs using state-of-the-art scientific methods from cryptographic research. Besides presenting the main conceptual ideas of our system, we will outline some of the the major scientific challenges that need to be addressed when designing secure and efficient 2nd layer protocols. Further information available at https://perun.network/

Plasma Implementers Call Live!

The Plasma Implementers Call is a biweekly call which discusses the cutting edge of Plasma research. We will be doing a LIVE session! This is a great group of 9 people:  Joseph Poon, Karl Floersch, Kelvin Fichter, Dan Robinson, David Knott, Xuanji Li, George Konstantopoulos, Alex Vlasov, & (if I can convince him) Vitalik! You can take a look at the YouTube channel here: https://www.youtube.com/channel/UCG2MeKuKDJRK4gFNk-dQuZQ  Please subscribe! ;)

Practical Plasma: Gaming

Talk will explore how Plasma Cash is changing the blockchain gaming landscape. Viewers will come away with a strong understanding of how to add advanced functionality like real time battles and crosschain token transfers to their existing games. Also we will explore how Plasma Cash enables use of sidehains to speed up gaming. What are the UI/UX difficulties of Plasma Cash? What would having wallets on multiple chains look like. Can we have automatic sign transactions for users? First we will delve deeper into L2 solutions like sidechain and state channels. We will see how plasma cash enables token transfers to sidechains, enabling the game to be fully run on the secondary layer. We will compare from a high level some common L2 solutions. We will walk through the UI/UX choices, how existing wallets interact with Plasma contracts. Then we we will delve into the tradeoffs in UI to speed. Finally we will tie everything together, by showing a working game that uses plasma, on a sidechain. So the audience can get the feel of what the end result of all this work would look like. What kind of games are possible and open up ideas for their future titles.

Raiden Network: Getting to a production ready payment channel network

The Raiden Network is the payment channel network for Ethereum aiming to help scale Ethereum payment and all Dapps that utilize Ethereum for payments and rely on no on-chain side effects of the payments. There will be a small explanation of what is payment channels and a payment channel network, an explanation of the raiden network protocol and a demo of using Raiden (hopefully by then live on the mainnet). We will close with future plans, expansion of the protocol and showcasing potential applications.

Snarks for mixing, signaling and scaling

There is general interest in the ethereum community to scale ethereum by moving dapps inside snarks. The key to do this is to make an efficient signature function available inside a snark. We present this signature function https://github.com/barryWhiteHat/baby_jubjub_ecc designed to work efficiently inside a snark. Furthermore we describe an architecture to scale ethereum using snarks. We discuss the trade offs required and compare them to building a dapp inside the evm.

SpankChain: Payment Channels in Production

The original custodial payment hub architecture; Our motivation for upgrading to a non-custodial hub; The new perun-style hub architecture; How we conducted the upgrade; An overview of features: Streaming payments, Currency auto-conversion (+ price negotiation), 2-token exchange, Custodial payments, Fees; A discussion of various design decisions: Payment Channels vs. Plasma, Perun vs. Hashlocks, Unidirectional vs. Bidirectional Virtual Channels, Emphasizing the “Card”, de-emphasizing the wallet; BOOTY Maximalism vs. ERC20 agnosticism; Future Roadmap; Networked hubs; State channels; Integration into Wallets like Gnosis Safe; Delegated signing keys / permissions; Anticipated Ecosystem Impact; SDK - Everyone gets payment channels; As a foundation for state channels; As a focal point for experimentation.

SWARM Team Update

Swarm aims to be the native data storage and content distribution infrastructure layer of the "Web 3.0".Since our last update at Devcon3 in Cancun, Swarm has seen major progress in its codebase. The long awaited network rewrite has been completed and several new features have been merged. In this talk members of the Swarm Team will present quick updates. For example, here are some of the updates we'd touch upon: -Encryption - Since the 0.3 release Swarm supports native encryption on the chunk level. Daniel will present a quick overview. -Access Control Trees - newly introduced in Swarm is the support for Access Control Trees. This feature increases the utility of Swarm to a wide range of use cases. Elad will sketch the main features. -Swarm Light Client - The requirements and limitations of the mobile phone present unique challenges for Swarm and we have begun to address them with the Swarm Light Client. Attila will give an update on this project. -PSS - The PSS protocol has matured significantly since last year. Lois will give the update. -Spam prevention in Swarm - new ideas for countering a flood of bad data. (dani & Aron) -Databases in Swarm (Viktor)

State Channels on Ethereum with Counterfactual

State channels are a critical "layer 2" scaling technology for ethereum. State channels let users conduct "off chain" transactions rapidly, without waiting for blockchain latency, but with each transaction still considered a "final" transfer of digital value or other valuable "state". However, they are difficult to engineer - today, many dapp developers have had to "roll their own" channels. Counterfactual aims to make it easy for developers to use channels in their applications, and get started making secure, scalable, performant ethereum dapps today. This talk will cover: - Overview of state channels technology - Introduction to the Counterfactual framework - How developers can get started using Counterfactual today

The EEA Technical Roadmap

Ron Resnick and Conor Svensson from the EEA present their technical Roadmap.

The Promise of Trusted Compute for Ethereum Scalability, Decentralization and Privacy

The Ethereum community has well known reservations about Trusted Compute and support those concerns. As Ethereum is becoming the dominant chain, scalability, decentralization and privacy will be the most important challenges. With the emergence of technologies such as PoS, Plasma and increasing use of staking and voting as design tenets, we believe Trusted Compute designed and deployed with decentralization as the objective can play a significant supporting role in not only preserving but also extending and democratizing the promise of decentralization. The presentation and related demonstrations are designed to engage with and trigger conversations within the Ethereum  community on the relevance of Trusted Compute.

Turbo-Geth: optimising Ethereum clients

As Ethereum network becomes gets more and more use, the load on the system grows, and the scalability becomes the primary concern. While concepts like Plasma, State Channels, and Sharding offer medium to long term solutions, client software optimisation have a potential to create enough runway in the short term. Turbo-Geth is an experiment to challenge various design choices made in major Ethereum clients and see the outcome. It is currently a fork of go-ethereum, but hopefully the insights are applicable to other client implementations too. This presentation will report on main experiments, findings, benchmarks, and the current state of Turbo-Geth project.

Optimistic Execution: Putting the Internet on Ethereum

Ethereum can serve as an arbiter of trust for the entire internet. To make this a reality we'll have to scale. Our best bet to scale is constructing a comprehensive layer 2.What do plasma, state channels, optimistic rollup, & ETH2 have in common? Optimistic execution! Or in other words, they each make inferences about future Ethereum state based on local information--think fork choice on top of a state machine. Using this concept we construct the Optimistic Virtual Machine (OVM), baking inference logic directly into wallet & application software. In this talk we discuss how the key role trust will play in the internet--from DeFi to timestamping--and how we can build the underlying infrastructure to support internet scale. These are exciting times for blockchain infrastructure. Now we just need to solve identity & UBI -- easy!

Scalabilty with zKSNARKs

Scalabilty with zKSNARKsThis session will introduce iden3’s zkSNARKs implementation and how it will be used at two scenarios: For the trustless relayer implementation at the identity management environment, allowing the identities to perform claims without cost at big scale.And the rollup project for Ethereum scalability, allowing verifiable computation off-chain to increase transaction throughput

A Better Mental Model for Rollups, Plasma, and Validating Bridges

Sidechains, Plasma, Rollups, Valdiums, AnyTrust, PoS chains, Crypto Exchanges, all have one thing in common: the bridge. This talk provides an overview on the trust assumptions, threat model, security goals and solutions associated with the humble bridge smart contract. As we will see, rollups emerged because of the scalability bottlenecks faced by Ethereum, but the product-market fit is solving the operational security issues for bridging funds from Ethereum to an off-chain system.

A Layer 2 Standards Working Group

The L2 ecosystem needs standards! We formed a L2 standards working group as an EEA Community Project, managed by OASIS. We will provide a quick overview of L2 standards discussion topics thus far. Others in the L2 ecosystem are invited to join and participate in existing discussions or raise new topics. https://github.com/eea-oasis/L2

Account Abstraction on StarkNet

An overview of how native account abstraction looks on StarkNet.

An Overview and Wishlist for Rollup Escape Hatches

Escape hatches are meant to be a way to exit assets or state from a rollup in the hopefully unlikely event that sequencers are offline. In this talk, we review which projects have these hatches and what plans are publicly available for future rollups or versions of these rollups. We list some ideas that these, and other rollups, may implement or adopt in the future, for more robust and secure rollups. The suggestions will be rooted in our concern for security and the issues presented by bridges.

AltLayer: Runtime Execution and Elastic Scaling Layer for Ethereum

(1) Multi-VM Support: AltLayer enables Ethereum with on-demand EVM/WASM execution layer. (2) Elastic Scalability: To handle surge requests on Ethereum, AltLayer enables dApps to quickly spin off custom execution layer (flash layers) to serve users, with near-instant finality(<2s), low gas fees (<0.01USD) and high throughput(~2,000 tps). (3) Ubiquitous Verification: To embrace decentralization, AltLayer runs multiple block producers/verifiers including commodity machines, browsers for users.

Building a Layer-2 NFT Bridge

Cross-chain communication is one of the most complex and interesting parts of multi-chain development. In this workshop we’ll build out an NFT bridge from the ground up between Ethereum and Arbitrum covering all you need to know about bridging design and cross chain messaging. You’ll walk out with a set of smart contracts you can use to bridge your mainnet NFT collection along with way more than you ever wanted to know about bridging.

Build a DApp on Optimism: How to Conquer L2 Bridging

L1 to L2, L2 to L2, L2 to L1...bridging is complicated, messy, and difficult! In this workshop, we'll teach you how to easily build a DApp that leverages Truffle's L2 Bridge Box, which helps you quickly set up a DApp configured to handle all the complexities that come with L2 bridging.

Demystifying L2 Transactions

Transactions executed on rollups have a different lifecycle to L1 transactions. In this hands-on workshop, for devs and users alike, we’ll use Arbitrum as a demonstration tool to send transactions, follow them through their different stages of finality and analyse what fees they pay.

ELI5: Scaling Ethereum

Everything you wanted to know about approaches to scaling Ethereum

ENS Cross Chain Integration Strategy

In general, most cross chain use cases are “asset transfer” for bridges to cross tokens from one chain to another then each application deploys the exact copy from L1 to other chains. However, ENS (Ethereum Name Service) has a set of unique challenges because ENS functions as a “global address book” to resolve addresses on any chains from any wallets. We have received lots of requests from chains and dapp developers about how to integrate ENS into their chain of choice and I am going to explain

Fast and Furious Withdrawals from Optimistic Rollups

Bridges are very complex and have under-explored security issues. The issue we are focused on with withdrawing from L2, which requires L1 to be absolutely sure of what occurred on L2 (finality was reached) and current proposals like Offchain Lab’s Arbitrum require 1 week for finality. In this talk, we discuss the three designs for “fast” withdraws that allow a user to move Layer 2 to Layer 1 instantly, while a counter-party takes the risk that the withdraw will not finalize.

Fuel: Scaling Ethereum with the Fastest Modular Execution Layer

Fuel is the fastest modular execution layer. It brings UTXO-based parallel transaction execution, a more flexible transaction format, a more efficient virtual machine, and a superior vertically-integrated developer stack to Ethereum. From the creator of optimistic rollups, this exclusive talk will discuss how users and developers will be able to leverage Fuel for global scale, without having to sacrifice decentralization or the security of Ethereum.

How Bridges Improve L2 Composability

Two of the biggest arguments against L2s are that they are breaking composability and interoperability. DApps are deployed as stand-alone apps in each L2 with limited ability to communicate with each other. This leads to silos and several issues in terms of capital efficiency, governance, security, user experience and maintenance. We will explore how bridges should become the interoperability layer that will connect all the protocol “silos” across L2s, by using secure message passing.

Join the Swarm: how to run a light node or full node

Swarm is a decentralised data storage and distribution technology. In this workshop you can learn how to use Swarm, including running light node or a full node. Also there will be a demo for node operators looking to profit from storage incentives and they will be able to join the network.

Major Trends in the Layer 2 Ecosystem: Where We Are and Likely Upcoming Themes

The Layer 2 space moves at lightning speed. Just as we start to grasp a particular concept or protocol, changes and new ideas flood the ecosystem. It is exciting and fast-paced, but it can be difficult to maintain an accurate birds' eye view of current developments and upcoming themes. This lightning talk will quickly survey the Layer 2 field and make some predictions around what themes we are likely to see in the coming months.

MEV Capturing AMMs(McAMMs)

A prevailing thought is that the power of transaction ordering is mostly in the hands of block-builders in the current MEV-Boost and PBS specifications. This talk will present a new AMM design, which could shift the transaction ordering power, at least partly, to AMM designers and liquidity providers. These constructions would allow AMMs to capture part of the MEV that is currently only harvested by block-builders and proposers.

New Paradigms by Non EVM Compatible L2s!

As L2s become bigger, several like StarkWare, Aztec and Fuel have built a VM that doesn't resemble the EVM for multiple reasons. EVM is great. We love the EVM. But non-EVM based L2s bring about new paradigms, and innovations and expose us to new possibilities that are just not possible on the EVM. These L2s truly are expanding the scope of Ethereum and we should explore these more!

On the Path to a Rollup-Centric Future

It’s only been slightly over a year since Arbitrum launched as the first optimistic rollup that supported general EVM contract deployment. In that time many components have shifted, many users have migrated, and an entirely new generation of technology has shipped with Nitro. Now we look towards tackling the next set of challenges in working towards Ethereum’s rollup centric future, where using Ethereum will mean using a rollup.

Onboard The World Into Your Rollup dApp with BLS Wallet

Bringing non-web3 native users into a dApp is always a fraught, friction filled experience, even with cheaper transaction costs on rollups. In this talk, we will show you how you can modify a dApp using BLS signatures & a smart contract wallet to: - Embed a wallet directly in your dApp, and allow users to eject by swapping its public key. - Bundle multiple transactions into one and submit to an aggregator to lower friction & save on gas. - Pay for your user's transactions.

Optimism’s OP Stack

Introducing the OP Stack — a standardized tech stack for L2 chains. Introducing the Superchain vision — the inevitable unification of the distinct L2 chains into a single, horizontally scalable, super-sequenced, Superchain! The OP Stack is how we realize the Superchain vision.

Proving EVM Bytecode Execution in the zk-EVM

Rollups are the go-to solution to scaling Ethereum and at the heart of the Ethereum roadmap. Programmable rollups and zk-evms have gathered a lot of attention and research interest. Provers in particular, which produce cryptographic proofs of evm execution, pose challenging problems both theoretically and practically. In this talk we will present our arithmetization and proving scheme, and demo the zk-evm under development at ConsenSys, providing an EVM bytecode compatible end to end solution.

Rollups Are the Most Secure Bridges

l2beat.com has established itself as the most trusted community resource assessing security assumptions of different Ethereum scaling solutions. Each such solution has a "native" bridge allowing users to move tokens to L2, but there is a plethora of other bridges available to end users. How do they compare to "native" bridges ? What risks users face sending tokens across these bridges ?

Rollups, Shards & Fractals: The Dream of Atomically Composable Horizontal Scaling

Rollups allow blockchain to scale vertically, while preserving their trust properties. But what do we do when we reach the limits of vertical scalability? It might also be desirable to accomodate multiple rollups with different operating rules, virtual machines, or security trade-offs. Horizontal scaling solves these issues, but doesn't allow atomic composability. In this talk, we review approaches to horizontal scalability & ways to get as close to atomic composability as possible.

Scroll Pre-Alpha Testnet Upgrade

Why do we need secure scaling? How is Scroll different from existing zkRollups? What can Scroll bring to users and developers? In this 20-minute session, we will introduce the design, principles, and the whole workflow of zkEVM, demonstrate our bytecode-level compatible zkEVM on testnet, and show you how easy it is for developers to deploy smart contracts on it.

StarkNet 101 Workshop - Getting started with unlimited scalability

A 2-hour workshop introducing the StarkNet Layer 2 network, how it works, and why it provides scalability to the Ethereum ecosystem. For this, participants will learn how to harness the power of the Cairo programming language and write their first semi-complex smart contract.

Technical Details of the Opcode Compatible zkEVM

I will explain some technical details on how we, at PolygonHermez, built the opcode compatible zkEVM. This will include some design details of specific pieces like the storage, the arithmetic state machine, the keccak circuit, among others. I will also go thru some snippets of the zkASM code that emulates the Ethereum VM. I will include in the talk some performance measures and I will do a live demo of the testnet.

The Blockchain Bridge That You Dream About

In the times where scalability of blockchains depends on multiple layers, and when interoperability holds for an essential blockchain feature, bridges become critical infrastructure parts. They are meant to hold liquidity, asked to operate quickly, but they cannot benefit from the security guarantees of an on-chain application, because they inherently contain off-chain components. In this talk, we discuss the properties of a bridge that is secure and meets all the needs for it to be useful.

The State of Fiat On-Ramps for Layer 2s

In this talk, Thijs Maas, the CEO of Onramper, shall share unique insights into the fiat on-ramp market for layer 2s, using data on fiat on-ramps. We shall demonstrate the gaps in current layer 2 on-ramp coverage.

Understanding L2: Ordering and Execution (aka Everything You've Always Wanted to Know About Sequencers But Were Afraid To Ask)

Overview of design patterns in handling ordering and execution; will cover separation of roles between sequencers and validators, tradeoffs in different ways handing execution & ordering, current approaches — i.e., what various L2 rollups are doing in production, what is and isn't possible in principle.

Using a Hybrid UTXO and Account-based State Model in a ZK Rollup

Many rollups choose to follow Ethereum’s account-based state model. We explore an alternative approach: a hybrid of a UTXO and an account-based model, specifically in a context of a ZK rollup. This approach offers a number of interesting properties including local transaction execution, support for privacy-preserving smart contracts, and reduced state bloat. In this talk we describe tradeoffs between different state models and cover the specific design choices we’ve made with Polygon Miden.

Ups and Downs: Onboarding a Million Users to Layer-2

In the last year we’ve seen thousands of projects and billions of dollars migrate over to rollups. Liquidity and users have started aggressively migrating, but there’s still a long way to go. In this talk we’ll cover successful use cases, pain points that make it challenging for both users and developers to onboard, and emerging projects and protocols in the layer 2 space that are showing a lot of promise.

The Mauve Revolution

Proof of stake and sharding present two of the biggest upcoming milestones in the ongoing development of the Ethereum protocol. Proof of stake offers the promise to greatly reduce the cost of consensus and increase security guarantees, while sharding presents an approach to allow on-chain scaling to tens of thousands of transactions per second while still retaining a network that can, if needed, run on nothing but a sufficiently large set of consumer laptops. The Casper approach to proof of stake also introduces a number of novel concepts, including consensus-by-bet and fork choice by value-at-loss.

A Fast and Scalable Blockchain for Enterprise Users

Almost every bank and major financial institution inChina as well as across the world is eager to revamp their computing infrastructure through blockchain. What a blockchain designed for them should look like? Is it enough to replace PoW with PBFT? What else can we do to leverage the resources enterprise users have? You will find the answers in CITA.

The Raiden Network

Raiden is a payment channel technology for fast, cheap, scalable off- chain token transfers. Introduction for developers planning to prototype applications on top of the Raiden Network testnet as well as μRaiden.