Watch / Show and Tell
Speaker: Virgil Griffith
Event: Devcon 3
Date: Nov 2017
Virgil Griffith is works at the Ethereum Foundation. He has a PhD in theoretical neurobiology from Caltech. The New York Times dubbed him the "Internet Man of Mystery". His Erdős and Bacon numbers are both three. He likes koalas.
C++ Ethereum and Emacs
Lefteris Karapetsas presents on C++ Ethereum and Emacs.
Piotr Janiuk presents on Golem, a P2P distributed computation network running on top of Ethereum.
Looking at the Ethereum IDE - Mix
Dr Gavin Wood presents on Ethereum's IDE - Codename Mix.
Dr. Jack Peterson presents on Augur (http://www.augur.net/), an open-source, decentralized prediction market built on Ethereum.
Solidity, Vision and Roadmap
Dr. Gavin Wood and Dr. Christian Reitwiessner present the vision and roadmap of Solidity, the smart contract programming language.
Gavin Wood, Christian Reitwiessner
Victor Wong, Kieren James Lubin, Jim Hormuzdiar Present on BlockApps STRATO, a full-stack technology solution that allows users to build industry-specific Blockchain applications on the Microsoft Azure Cloud.
Victor Wong, Kieren James Lubin, Jim Hormuzdiar
Balanc3: Triple Entry Accounting
Jeff Scott Ward and Christian Lundkvist of ConsenSys (https://consensys.net/) presents on Balanc3, a smart contract powered Triple-Entry Accounting system.
Jeff Scott Ward, Christian Lundkvist
Blockchain Model Canvas
Blockchain Model Canvas
Joseph Chow (Lead Developer) presents on BTC Relay (http://btcrelay.org/), a collection of smart contracts that allows Ethereum developers to interact with the Bitcoin blockchain and verify Bitcoin transactions.
Building a DApp: What are DApps and why Meteor
Ethereum's Fabian Vogelstellar presents on DApps and why Meteor is awesome (https://www.meteor.com/).
Ethereum's Vlad Zamfir presents on Casper, the PoS blockchain architecture for Serenity release.
Ethereum's Konstantin Kudryavtsev presents on Embark, a DApp Development Framework built by Iuri Mathias.
Christian Lundkvist of ConsenSys (https://consensys.net/) presents on digital identity.
Roman Mandeleil, the Lead Developer of the Ethereum Java client shows off Ether.Camp, a block explorer, IDE and Hackathon Manager on Microsoft's Azure Cloud. http://hack.ether.camp/ http://frontier.ether.camp/
ENS (Ethereal Namespace)
Ryan Casey of Maker DAO (https://makerdao.com/) presents on ENS (Ethereal Namespace), a contract system and set of conventions for unifying all simple (word-sized keys/values) registries into a single hierarchal namespace.
Ethereum & WebAssembly
Ethereum's Martin Becze presents on the Ethereum Virtual Machine (EVM) and WebAssembly
Tim Coulter of ConsenSys (https://consensys.net/) presents on the DApp Store (http://dappstore.io), a platform for sharing Ethereum based DApps.
FreeMyVunk: Join the movement
Tyler Smith presents on FreeMyVunk (http://www.freemyvunk.com/), a DApp dedicated to empowering people to fight for ownership rights over their virtual property, virtual junk or VUNK.
R. Tyler Smith
Martin Koppelmann Presents on Gnosis (https://groupgnosis.com/). Gnosis enables you to make predictions on all kinds of events.
A look into using IPFS with Juan Batiz-Benet to distribute datastructures for various Ethereum use cases, from off-chain data, to the chain itself. IPFS A look into using IPFS to distribute datastructures for various Ethereum use cases, from off-chain data, to the chain itself. About Juan Batiz-Benet Juan Benet invented IPFS, and Filecoin. He is also the founder of Protocol Labs.
Lightning Talk: Metamask.io
Aeron Davis presents on Metamask, a bridge that connects the web of today with the web of tomorrow.
Lightning Talk: Provably Honest Oracle Service
Thomas Bertani presents on Oraclize (http://www.oraclize.it/), a set of tools and APIs aiming to enhance the power of smart contracts by pushing external data to the blockchain.
Lightning Talk: Reality Keys
Edmund Edgar presents on Reality Keys (https://www.realitykeys.com/). The Reality Keys™ service provides automated and human-verified data designed to enable a new generation of automated, trust-free information services.
Microsoft Announcing Ethereum Blockchain as a Service (ETH BaaS) on Azure Cloud
Microsoft's Marley Gray takes the stage to present on Eth Baas, the Ethereum blockchain-as-a-service on the Microsoft Azure Cloud, created in partnership with ConsenSys spokes BlockApps and Ether.Camp.
Lightning Talk: HitFin
Patrick Salami presents on HitFin (http://www.hitfin.com/), a bilateral trading and settlement platform for over-the-counter derivatives.
Nikolai Mushegian presents on Maker (https://makerdao.com/), a contract system which creates and maintains the Dai Stablecoin.
An introduction to Ethereum's IDE Mix.
Progressing toward the Ethereum Light Client
Ethereum's Zsolt Felfoldi presents on the progress made towards the Ethereum Light Client.
Raiden: Scaling Out With Offchain State Networks
Ethereum's Heiko Hees presents on Raiden, the Bitcoin Lightning-Network inspired extension to Ethereum which scales-out asset transfer capacity.
Niran Babalola of ConsenSys (https://consensys.net/) presents on Regis, a platform for building and deploying registries into the Ethereum network.
Ethereum's Christoph Jentzsch presents on Slock.it (http://slock.it/), an IoT/Blockchain company that allows users rent, sell or share anything!
Ethereum's Co-Creator Dr. Gavin Wood presents on Whisper (https://github.com/ethereum/wiki/blob...), the 'pitch black' P2P messaging protocol. Apologies for the poor video framing, individual slides can be found here - http://www.slideshare.net/gavofyork/w...
Ethereum's Dr. Daniel Nagy and Viktor Tron present on Swarm, the decentralised, incentivised file storage system.
Daniel Nagy, Viktor Tron
Vitalik Buterin, Dr. Gavin Wood, Fabian Vogelsteller, Nikolai Mushegian and Christian Lundkvist discuss standardisation in the Ethereum space.
Vitalik Buterin, Dr. Gavin Wood, Fabian Vogelsteller, Nikolai Mushegian, Christian Lundkvist
Simon de la Rouviere of ConsenSys presents on tokens and standards on the Ethereum blockchain.
Simon de la Rouviere
Towards Imandra Contracts: Formal verification for Ethereum
Grant Passmore of Aesthetic Integration (http://aestheticintegration.com/) presents on Imandra, the breakthrough artificial intelligence technology for ensuring financial algorithms are designed and implemented safely and fairly using formal verification.
Towards safer languages for smart contracts
Jack Pettersson and Robert Edström present Chalmers University of Technology, Sweden present on a dependantly typed functional language for smart contracts.
Jack Pettersson, Robert Edström
A Correct by Construction Asynchronous Casper Protocol
This technical talk covers the ongoing formal verification and implementation efforts behind a correct-by-construction asynchronous byzantine-fault tolerant binary version of the Casper consensus protocol that is currently under development. Work extending the correct-by-construction approach to virtual machine replication, validator rotation and public economic consensus will also be discussed.
A Deep Dive into the Colony Foundation Protocol
The Colony Foundation is a non-profit foundation responsible for developing the open source Colony smart contract network on Ethereum. We see the Colony Network as infrastructure for internet organisations and part of the remit of the foundation will be supporting the development of applications on top of the protocol. This talk will give an in-depth look in to how it works.
Aron Fischer, Elena Dimitrova
A Provably Honest Oracle Model: Auditable Offchain Data Gathering and Computations
Providing offchain data to Ethereum contracts is hard. The model we present enables an offchain party to act as a provably honest oracle which can give strong authenticity guarantees for both data and computations. This novel approach prevents it to tamper any data, while being able to deliver them to the blockchain. This is possible thanks to an extensive use of smart HW and SW techniques based on TLSNotary, Intel SGX and Qualcomm TrustZone among the others.
Building Highly Scalable, Optimized, Standardized dApp’s from UI to Contracts
Nick Dodson gives his talk on Building highly scalable, optimized, standardized dApps from UI to contracts.
Building The Light Client Ecosystem
A short explanation of the LES flow control mechanism followed by: incentives and performance with and without micropayment avoiding Sybil attacks using micropayment channels for improved performance economic model for massively scaled networks
Zsolt Zsolt Felfoldi
Complex Dapps and Updating Them
This presentation by Joey Krug of Augur, will show how Augur has setup its contracts such that the business and storage logic are separate. Joey will go over different ways to upgrade contracts (as well as the way they’re settled on), and discuss why Augur thinks this separation of data and logic should be the pattern going forward for larger sets of contracts as it enables easier upgrade and bug fixing paths.
Decentralized Commercial Banking
Dominic Williams gives his talk on Decentralized commercial banking.
Developing Scalable Decentralized Applications for Swarm & Ethereum
Blockchain-coordinated decentralized applications represent a radical departure from the client-server model on which most of the currently popular web applications are based. On one hand, such đapps’ approach to scalability is more natural as the computing power and bandwidth available for applications grows in proportion to their user base, while on the other hand the lack of a centralized trusted infrastructure under the control of a single — typically corporate — entity raises unique challenges in trust, reliability and coordination. In my presentation, I will introduce some of the principles and practices of architecting and developing such applications, highlighting both the challenges and the unique opportunities for transcending the limitations of the client-server model. In addition to developing the underlying infrastructure, the Swarm team also develops some example applications that, while useful themselves for end users, are also meant as a template and a starting point for independent developers. Using these examples as illustrations, the presentation will introduce prospective developers to techniques and approaches of both replicating Web 2.0 patterns in a decentralized fashion and going beyond their limitations, taking full advantage of content-addressed storage and blockchain-arbitrated interactions. In particular, the basic building blocks of decentralized, community-moderated knowledge bases (such as maps or encyclopediae), social networks and other forms of information aggregation are going to be presented.
A Lap Around Developing Cryptlets
Developer tour of Cryptlet implementation, brief overview of Cryptlets, creating a Cryptlet, write Solidity to use Cryptlets and wiring it all up at runtime
Dapple Dev Workflow
Learn how to explore, develop, test, integrate and maintain your dapps with the Dapple dev toolchain.
ENS Ethereum Domain Name System
ENS: Ethereum (Domain) Name System The talk covers three aspects of a proposed Ethereum domain name system: the technical implementation of the recursive and modular lookup protocol (https://github.com/Arachnid/EIPs/blob...), the auction aspects for domain registration and reselling (https://github.com/ethereum/EIPs/issu...) and the possible attack vectors along with the suggestion solution and future expansion.
Ethereum Meets the Outdoors
This talk will introduce Sikorka. It’s a system that allows smarts contracts to be deployed out in the open air. Users can interact with smart contracts deployed around them or deploy their own. We will see how Sikorka works, some of its use cases, the work done so far and what remains to be done.
Ethereum On Ruby
A presentation exploring the Ethereum Ruby Client/Cryptape and the Ethfans community in China.
Evolving the EVM
Greg Colvin, Martin Becze, Paweł Bylica, Christian Reitwiessner, Alex Beregszaszi discuss their personal work and evolving the EVM.
Greg Colvin, Martin Becze, Paweł Bylica, Christian Reitwiessner, Alex Beregszaszi
Formal Verification for Solidity
Christian Reitwiessner & Yoichi Hirai speak on Formal Verification for Solidity.
Christian Reitwiessner, Yoichi Hirai
Going From Analogue to Digital wth Otonomous
The Future of Digital Assets and Exchanges on the Blockchain
Formal Verification of Smart Contracts
Yoichi Hirai gives their talk on Formal Verification of Smart Contracts.
How to Develop Advanced DApps Using Embark
Introducing Embark 2.0; What’s new, and how to develop & test advanced DApps
Import Geth Ethereum from Go and beyond
Teaser presentation about using go-ethereum as a library in other projects: running embedded nodes; interfacing native DApps; Android and iOS support.
Imandra Contracts Formal Verification for Ethereum
A presentation covering Imandra Contracts, Aesthetic Integration’s cloud-based formal verification system for Ethereum.
Grant Passmore, Evgeny Gokhberg
INFURA インフラ – IPFS and Blockchain Infrastructure
INFURA aims to provide ConsenSys spokes and the World, with a stable, robust, balanced, fault tolerant and easily scalable infrastructure of Ethereum and IPFS nodes.
Maker Ecosystem Overview
Andy from Maker speaks about Maker & Simplecoin.
Making Smart Contracts Smarter - Oyente
The contract analyzer OYENTE was built to detect vulnerabilities in smart contracts and will soon be released as open source. This presentation will give an overview of Oyente and how it can me used to make smart contracts smarter.
Mango - Git Completely Decentralized
This presentation will cover an introduction to the problem, explanation of Mango itself, and how it could be further developed to provide all the convenience of GitHub in a decentralised manner.
libp2p ❤ devp2p: IPFS and Ethereum Networking
libp2p is the modular secure networking suite that powers IPFS. It defines a set of interfaces for common networking and peer-to-peer protocols. libp2p is fast, robust, and powerful. It uses multiformats for self-description, avoiding algorithm lock-in, and cryptographic agility. libp2p handles Authentication, Transports, Stream Multiplexing, Peer Discovery, Peer Routing, Content Routing, NAT Traversal, and Relay. The coolest thing? It also runs entirely on the browser! devp2p is the secure networking suite that powers Ethereum. It also defines a set of networking and peer-to-peer protocols. devp2p is also fast and robust. It uses RLPx for authentication, stream multiplexing, network forming, and protocol multiplexing. This talk compares libp2p and devp2p, traces their concurrent history, discusses protocol differences and similarities, and suggests important areas of future collaboration and synthesis of efforts. The aim of this talk is to launch an important collaboration between the Ethereum and IPFS communities.
David Dias, Juan Benet
Marmot y Goodness and Ethereum
RJ Catalano and Zach Ramsey of Eris Industries will showcase how Eris tooling can help you in your ethereum development via chain management solutions, IPFS integration, and the Eris package manager.
RJ Catalano, Zach Ramsey
Making the EVM Scream
How I got the EVM interpreter from where it was to where it will be in the future.
Mist Vision and Demo UPDATED
Alex Van de Sande reviews Mist's vision and previews a demo.
Alex Van de Sande
MetaMask Bridging Browsers to Blockchains
A presentation showing the progress of MetaMask’s efforts and a genral overview of interacting with blockchain technology through browsers.
New and future Features of Solidity
Update on how Solidity evolved in the recent months also showcasing features of Solidity in general and giving a roadmap for the future.
Orbit: Distributed, Real Time Web3 Apps with IPFS and Ethereum
Samuli Poyhtari gives their talk on Orbit: Distributed, Real Time Web3 Apps with IPFS and Ethereum.
Ethcore will be unveiling its powerful new Parity client. With a shiny UI natively baked-in, it is packed full of unique features that will drastically improve every aspect of the Ethereum user-experience. Glimpse the never-before-seen product. You will hear about Ethcore’s vision and how it plans to contribute back to the growing Ethereum ecosystem. We will make it easier for developers and users to utilise the network and foster a new spurt of innovation in the ecosystem.
Remix and Other Ethereum Development Tools
This presentation will explore why we’ve chosen to replace Mix by Remix. It will focus on the integration of Remix in Browser Solidity and other tool/web apps, such as Ether Scan, Mist, Metamask and potentially Dapple, Embark, Truffle, etc.
Ethcore is proud to bring you Parity, a high-performance implementation of the Ethereum client written in Rust. Ethcore will talking about what makes Parity unique for DApp and blockchain developers. Get a brief overview of Parity’s performance and security aspects. You will learn about some of the advanced features, such as state-tree pruning, blockchain snapshotting and transaction tracing. We will also touch on private chain’s use of Parity and present a roadmap for the features to come.
Prove It – Blockchain based KYC
Igor Lillic reviews blockchain-based KYC processes.
Smart Contracts as Parametrization: Why the DLT Talk Can Make Sense
Mistaking blockchain for a distributed ledger usually leads to wrong ideas and broken designs. Other technologies should usually be used to implement an immutable ledger. Especially if there is no use for smart contracts or on-chain code, using Ethereum would usually create too much overhead. However, a different use for smart contracts seems to be emerging that may not be along the lines they are currently understood: instead of facilitating self executing agreements and payments, they can be useful for user parametrization of complex workloads. Parameters of a system can ever only be as powerful as the code they are controlling. In platform systems, users will define parameters to control part of a pre-programmed environment in ways that they need it. Parameters often power creep from static values, over macros to full blown scripts. It’s along those lines that Lua developed from a parameter definition language into a powerful script language. Smart contracts seem to leak into a role where they extend the power of digitally signed parameters to trustable scripts, which can allow e.g. for more flexible controlling of the anonymous execution of analysis code against a provided data stream with full transparency for the data provider and execution guarantee for the code provider.
Swap, Swear and Swindle Swarm Incentivisation
Swap, Swear and Swindle. Swarm Incentivisation A robust peer-to-peer content storage and retrieval system requires a careful balance between the needs of the service providers and those of the consumers. The Swarm network is uniquely able to address these needs due to the new opportunities ethereum offers in the form of micro payments and smart-contract governed incentive schemes. In this talk we want to introduce the swarm incentive system. It is built around three pillars which we call Swap, Swear and Swindle. The Swap system accounts for bandwidth usage and compensates nodes for serving up content. The dynamics of this system suggest that popular content will automatically become more widely distributed and faster to access. Micropayments are handled by a custom chequebook smart contract and we are actively looking to integrate full payment channels as well. The Swear contracts deal with long term storage, allowing nodes to sell access to their storage capacity while allowing others to reliably store their content on swarm for extended periods of time. Finally, the Swindle contracts constitute a litigation engine to resolve disputes. The properties of Swindle make it a natural candidate to be a state-channel judge contract and we will present our research into off-chain state-channels for proofs-of-custody, recurring payments as well as litigation and conflict resolution. Swarm thus touches upon multiple strands of research currently happening in and around the ethereum ecosystem and unifies them in a coherent narrative that we hope to convey in this talk.
Viktor Trón, Aron Fischer
The Browser-Solidity IDE
Christian Reitwiessner gives his talk on the Browser-Solidity IDE.
Testing Ethereum Consensus
Ethereum tests overview and integration instructions for client developers.
Solidity for Dummies
We will explore the basics of the Solidity contract language using examples.
Hudson Jameson, Piper Merriam
Solutions for Storing and Exchanging Data for Consortiums With Real Use Cases
Victor Lysenko gives his talk on Solutions for Storing and Exchanging Data for Consortiums With Real Use Cases.
The Decentralized Colllaborative Web
Since the early days of Ethereum and the blockchain 2.0 movement there has been extensive research regarding the Decentralised Autonomous Organisation (DAO) concept. Nevertheless, and despite TheDAO experiment, a complete understanding of what exactly a DAO is and how its ticks is still lacking. In this talk I’d like to briefly sketch a comprehensive DAO protocol, enabling decentralised reputation-based collaboration, decision making and value distribution. A scalable implementation of the protocol on the Ethereum blockchain is made possible by introducing a novel software architecture composed of a simple smart contract on the chain, and an off-chain component responsible for the majority of the interactions with the protocol.
The Golem Project: Ethereum-based market for computing power
This presentation will cover the most important features of Golem, including the use of Ethereum as a trading platform. It will also describe how Golem’s technology will create an open market for computing power and how that will distort the way the Internet is organised. Finally, it will describe the way ahead of Golem, including our plans for further development.
The new Web3.js
Fabian Vogelsteller gives their talk on the new Web3.js
Smart Contracts in Java
David Roon gives his talk on Smart Contracts in Java.
The Raiden Network
Lefteris Karapetsas gives his talk on the Raiden Network.
uPort – Usable key management & identity
uPort is an Ethereum-based identity system that aims among other things to provide a smooth end-user experience for interacting with Ethereum dapps. Part of the challenge when interacting with blockchain systems is that the end user is in charge of key management, which is a major hurdle for the unsophisticated user.
Rouven Heck, Christian Lundkvist
Truffle Development Ecosystem and Future of Ethereum Development Tools
Truffle Development Ecosystem and Future of Ethereum Development Tools A presentation on the Truffle development ecosystem which encompasses a number of different tools including the Truffle development framework. There will be a demo of new features as well as talk about future plan, keeping an eye toward writing code that benefits the whole Ethereum community and not just Truffle users, focusing on development processes, blockchain simulations, testing, using live chain data for testing and development, and on-chain package management.
Truebit - Trying to Fool a Blockchain
How to use interactive verification for offloading computations, providing help in scaling and giving a proper incentivisation scheme for doing computationally-intensive work.
0x: an open protocol for trustless, low friction exchange of ERC20 tokens
In the two years that have passed since the Ethereum blockchain’s genesis block, numerous decentralized applications (dApps) have created Ethereum smart contracts for peer-to-peer exchange. Rapid iteration and a lack of best practices have left the blockchain scattered with proprietary and application-specific implementations. As a result, end users are exposed to numerous smart contracts of varying quality and security, with unique configuration processes and learning curves, all of which implement the same functionality. This approach imposes unnecessary costs on the network by fragmenting end users according to the particular dApp each user happens to be using, destroying valuable network effects around liquidity. We present 0x: an open protocol and shared settlement layer for trustless, low friction exchange of ERC20 tokens.
1protocol – Virtual Ethereum Workers
1protocol is a platform that enables users with idle tokens and machines with idle computing power to collaboratively perform work for staking protocols on Ethereum such as Casper. Using 1protocol, users can trustlessly earn interest on their token holdings and machines can perform work for staking protocols without putting up stake.
Axel Ericsson, Zack Lawrence
Advancing Ethereum in Permissioned Networks: Integrating PBFT into Quorum
J.P. Morgan and Amis discuss Quorum’s latest consensus mechanism option. Istanbul Byzantine Fault Tolerance (IBFT) is a native Practical Byzantine Fault Tolerance (PBFT). This integration continues Quorum’s tradition of partnering with the community to produce innovations that bolster Ethereum.
Tyrone Lobban, Yu-Te Lin
Babbage: A mechanical smart contract language
In textual programming languages it is often almost impossible to see how different parts interact and fit together. Babbage is a visual programming language that consists of simple mechanical parts that aims to be understandable even by untrained people. Since interacting components have to be physically close, modularity is already guaranteed by design. The goal of Babbage is not to make it easy to create smart contracts, but to make it possible to create smart contracts whose functionality is easy to explain and understand.
Dr. Christian Reitwiessner
AKASHA: Unveiling The Next Experiment
Following the successful AKASHA alpha release, we started working in parallel on a complete code refactoring and an information architecture overhaul. In this presentation we will cover the lessons learned during the alpha, the progress made so far with the beta and our first token proposal designed to kickstart AKASHA’s crypto economic olympics.
Mihai Alisie, Marius Darila
Building a decentralized sharing economy on top of Ethereum
I will describe the technical architecture of the universal sharing network (USN) and will discuss some implementation details.
Building an Ethereum assisted Decentralized Data Marketplace Breakout
Data has become a valuable digital currency in its own right over the past decade, but despite its utility, it remains consolidated at the hands of a few large organizations. We propose a new protocol layer for creating an open-access data marketplace. The protocol is decentralized, and allows anyone to publish data in the system in return for incentives. We will discuss the hybrid architecture of the protocol, combining Ethereum smart-contracts for managing data access and subscription, alongside an off-chain network for storing and transmitting the data. Finally, we will introduce Catalyst – the first application to make use of a decentralized marketplace of crypto-data.
Casper the Friendly GHOST: A correct-by-construction blockchain
Vlad Zamfir presents their talk titled, "Casper the Friendly GHOST: A correct-by-construction blockchain"
Since its formation, DappHub has focused its attention on making blockchain development an ergonomic and efficient experience. We built our reputation on this topic by first creating a popular Ethereum development tool called Dapple. In the last year, our research has begun to produce significant results. This talk will be about the different tools that DappHub has created to add usability to the Ethereum blockchain.
Challenges Ahead for Smart Contracts
Ethereum has unleashed the power of smart contracts by creating a massively distributed, resilient, and replicated computing platform. In this talk, I will discuss the three challenges I see ahead for Ethereum, go over known techniques for addressing them, and will identify the future work that needs to be done because of the unique challenges faced by the Ethereum platform. First, we’ll talk about scale, touch upon known techniques for scaling on- and off-chain. Next, we’ll talk about program verification, what it can do, and why it is not the panacea that many people make out to be. In particular, I’ll talk about the kinds of smart contract properties that we know how to ascertain, versus the kinds of smart contract properties that we would ideally like to verify, and discuss the gap between the two. Finally, I’ll talk about the next frontier involving private data and private computation on a public blockchain, a combination thought to be impossible by some, and describe how we can achieve it with the help of secure hardware.
Emin Gün Sirer
Data is the Missing Link
Thomson Reuters distributes 2.5m financial instrument price updates per second; data that is used to price over $3tn in assets each day. Blockchains rely on trusted sources of data and trusted mechanisms for data delivery, without which many of the use cases for smart contracts cannot be realized. This presentation will cover a range of active use cases that include Thomson Reuters data on people, organizations and tradable instruments being applied within financial services as well as other industries such as commodities and energy. It will introduce the complexities of having data as part of your value proposition, and look at current and future approaches for data commercialization on blockchains and DLTs. All of these key learnings have been developed through the use of the Thomson Reuters oracle, BlockOne IQ, that was designed specifically for Ethereum.
Tim Nugent, Sam Chadwick
Decentralised Autonomous Organization: Integral Platform for Climate Initiatives
DAO IPCI is a Decentralized Autonomous Organization operating, sustaining and developing the Integral Platform for Climate Initiatives, smart contracts and blockchain technology-based independent ecosystem designed for carbon market instruments, including carbon compliance units’, carbon-offset credits, other environmental mitigations credits, environmental assets, rights and liabilities registration, accounting and transaction data.
Anton Galenovich, Sergei Lonshakov
Dapp Development using Remix, Mist, and Geth
Yann Levreau and Rob Stupay give their talk titled, "Dapp Development using Remix, Mist, and Geth"
Yann Levreau, Rob Stupay
Deep Dive into WALLETH – the Ethereum Android Wallet
Devices that run Android are now often one (if not even the only) computer for a lot of users to access many services currently. So to bring Ethereum to the masses and replace current services we need good clients for this platform. WALLETH aims to fill some of this gap. After looking at the surface of in the short talk earlier at the conference: this talk I will dive deeper into WALLETH. Instead of looking from the users side we will look behind the curtains into technical details and development aspects of the project. And I also intend on seeding some ideas in this session – there is so much more possible with this growing codebase and other targets that could be deployed to like Android Things or Chrome-OS.
Designing Future-proof Smart Contract Systems
Exploring techniques to build more modular smart contract systems that allow for more graceful upgrades and gas savings using delegate calls.
Developers, Developers, Developers – Ethereum for all your networks!
Péter Szilágyi gives their talk titled, "Developers, Developers, Developers – Ethereum for all your networks!"
Andy Milenius, Conor Svensson, Yann Levreau, Jack Peterson, Piper Merriam, Nick Dodson, & Iuri Matias discuss Development Frameworks.
Andy Milenius, Conor Svensson, Yann Levreau, Jack Peterson, Piper Merriam, Nick Dodson, Iuri Matias
Fabian Vogelsteller (author of ERC20) will be talking about his new work on standard functions for a unique identity for humans and machines.
EtherDelta: Off-chain Order Book with On-chain Settlement
This presentation will cover EtherDelta’s deployment of the first working off-chain order book with on-chain settlement. Topics covered will include scaling, security, user experience, onboarding, and real world results.
Ethereum for Python Developers
Everything you need to know to get started with Ethereum with Python.
Designing IoT Frameworks Using Ethereum
Shuang Liang & John Gerryts give their talk titled, "Designing IoT Frameworks Using Ethereum"
Shuang Liang, John Gerryts
Ethereum Protocol Testing
Dimitry Khokhlov gives their talk titled, "Ethereum Protocol Testing"
Felix Lange gives their talk titled, "Evolving devp2p"
EVM-C: Portable API for Ethereum Virtual Machines
Pawel Bylica gives their talk titled, "EVM-C: Portable API for Ethereum Virtual Machines"
EthJS is a collection of presently 16 precision JS modules made over the past year to support the dApp developers of the Ethereum community. Currently, the modules are being used in the Truffle Suite, web3.js, wafr developer tool, and uport libraries among many other projects.
Extending Ethereum with Enterprise Smart Contracts
A depth walkthrough of extending Smart Contract logic into a secure, scalable cloud execution environment using Cryptlets and the Cryptlet Proof Engine.
Flexibility in Solidity
This talk presents latest updates and upcoming features of the Solidity language. Improvements in the code generator will greatly improve maintainability in the future. Furthermore, the next iteration of formal verification tools which will soon be a built-in component that helps you write safer smart contracts.
Dr. Christian Reitwiessner
Phil Daian, Everett Hildenbrandt, Yoichi Hirai, Loi Luu, & Reto Trinkler discuss Formal Verification.
Phil Daian, Everett Hildenbrandt, Yoichi Hirai, Loi Luu, Reto Trinkler
IDbox – Cost efficient device for self-sovereign identity
IDbox (www.idbox.io) is a cost efficient device that enables people to create a unique identity where is no internet or grid-electricity. People can then use their analog phone to access land registry, healthcare, remittance, electricity, etc.
Intro to Solidity 2017 Edition
Hudson Jameson gives their talk titled, "Intro to Solidity 2017 Edition"
Intro to Casper Implementation
Chang-Wu Chen gives their talk titled, "Intro to Casper Implementation"
iExec: Allowing Scalable, Efficient and Virtualized Off-chain Execution for Arbitrary Applications
This presentation is a follow-up to Devcon2 and EDCON. We’ll introduce the iExec SDK that allows to execute any legacy applications from Ethereum smart contracts. Using a set of simple CLI tools, developers can register, deploy and administrate their applications in the iExec distributed Cloud. We’ll present examples that explain the solidity smart contract API and illustrate off-chain computations.
Introducing the TrueBit Virtual Machine
This talk will focus the economic and architectural mechanics behind TrueBit, a trustless, general purpose computer which obliterates Ethereum’s gas limit. By wrapping the new TrueBit Virtual Machine (TVM) inside a novel incentive structure, smart contracts achieve secure, scalable, and affordable computation. Decentralized big data applications loom on the horizon.
Juzix: Maneuvering Data to Flow
Juzix (formerly Juzhen Financials) is an infrastructure provider for distributed data exchange using distributed ledger technology and multi-party computation. We started out as a financial infrastructure provider in 2014 and have now expanded to other industries interested in adopting distributed data processing and collaborative computation to enable secure data exchange. Juzix currently has over 100 employees, and working with the leading institutions in China to release the first open-source platform using Ethereum that comply with local standards and regulations in China. Version 1.0 (Chinese) will be released in July, 2017, and we think this will enable more Chinese institutions and start-ups to use Ethereum.
Kleros: Building a decentralized court system to arbitrate smart contracts
Smart contracts can’t take decisions requiring outside-world information and subjectivity. However they are a great tool to enforce those decisions. We explain how by drawing jurors at random and providing them proper game-theoretical incentives based on Schellingcoin principles we can design a trustless arbitration mechanism for smart contracts.
Introduction to WALLETH – the Ethereum Android Wallet
Devices that run Android are now often one (if not even the only) computer for a lot users to access many services currently. So to bring Ethereum to the masses and replace current services we need good clients for this platform. WALLETH aims to fill some of this gap. Here I will talk about the concepts behind the user-interface and general ideas behind the project. Another area that I want to shed some light on in this talk is the special security properties mobile applications on Android have. We will not have time for much more in this talk but there is also one 30min deep-dive session later in the conference.
KEVM: Overview and Progress Report
Since the IC3 Crypto Boot Camp, we have been extending the KEVM semantics in several directions. At the time, we only supported the VMTests from the Ethereum Test Suite, it was somewhat difficult to write properties and proofs about programs in EVM, and EVM-PRIME was a simple demonstrative toy language. This session will cover the progress so far in addressing these issues, as well as our goals and intentions for the semantics moving forward. In particular, we are focused on providing tools to ease the process of writing and proving specifications about programs written in high-level languages. Everett Hildenbrandt is a CS PhD student at University of Illinois Urbana-Champaign studying formal methods and programming languages. He is focused on improving the scalability of symbolic reasoning for applications in both distributed and physical systems. In the context of blockchain systems, he is interested in formalizing the semantics of both the underlying languages used and the consensus protocols. To this end, he recently led the KEVM project which developed an executable mathematical model of the EVM in the K Framework.
JAAK: A New Engine to Power the Web of Content
Founded by Vaughn McKenzie, Freddie Tibbles and Viktor Tron, JAAK connects songs, films, and TV shows directly to the artists, producers, writers, and organisations that create, own and distribute them.We believe a simpler framework for licensing media on the web will unlock a world of new content experiences and untapped value opportunities for the entire media industry – we call it Smart Content.
Julia – IR for Ethereum Contracts
Brief introduction to Julia, a new intermediate language to be used in the Solidity compiler. It reduces the complexity of the compiler, helps in auditing contracts and makes supporting multiple VMs, such as EVM 1.5 and eWASM, possible.
Methods for deterministic parallelizing message processing
Martin Becze gives their talk on methods for deterministic parallelizing message processing.
A correct-by-construction concurrent smart contracting language. We give a basic introduction and show a translation of ERC 20 token contract into Rholang.
Mind the Gap: Application-driven evaluation of Smart Contract languages
How can we quantify the expressiveness of smart contract programming languages? In this talk I’ll present research conducted over the past two years that answers this question with an application driven approach. We take several well-known applications as case studies (a random coin flipping gadget, fair off-chain multiparty computations, and payment channel networks), and attempt to implement them in both Bitcoin script (UTXO-based) and in Ethereum (contract-based). In each setting, we find that the UTXO-based framework requires additional asymptotic overhead compared to Ethereum (either time, computing power, or locked-up collateral). These case studies can therefore serve as a benchmark suite for evaluating new languages as well.
MetaMask: Dissecting the fox
Aaron Davis and Frankie Pangilinan give their talk titled, "MetaMask: Dissecting the fox"
Aaron Davis, Frankie Pangilinan
Missing Links in the Ethereum Stack
Observations about what developer tools missing from the Ethereum stack, yet currently available to traditional web developers.
Morphing Smart Contracts with Bamboo
An Ethereum contract language called Bamboo mitigates common mistakes. A Bamboo program textually displays all states and transitions. A program runs always one-pass without loops or functions. Runtime checks never allow reentrant execution. Erlang folks might like the syntax. OCaml people, I need you.
Pluggable crypto for Ethereum nodes: Masterchain experience
Ethereum has a few subsystems which use cryptography in their core functionality: 1. Transaction processing system, 2. P2P node communication, 3. EVM (Ethereum Virtual Machine), 4. Mining. So far all these systems use only one crypto library but they use it in different ways. We have developed an extra crypto-layer, which makes crypto to work as an additional abstract layer. The extra-crypto layer is completely transparent for all ethereum logic. It allows to switch crypto-algorithms to use in Ethereum.
Alexey Troshichev, Dmitry Bozhko
Package Management for Smart Contracts
Building the Ethereum standard library. Learn what package management looks like for smart contracts and explore the potential that a rich packaging ecosystem can unlock.
Oyente: Development update
Oyente: An Analysis Tool for Smart Contracts. https://github.com/melonproject/oyente
Practical Applications of Off Chain Computation in the Light Client
A not extremely technical demonstration of how a new and exciting technology can help implementing advanced light client features like trustless instant syncing, fast log searching and more.
Presenting Parity: A Light Client for a Heavy Chain
I will present the Parity Light Client, summarize the protocol, and provide DApp development guidelines. I will also discuss light client use-cases in the mobile and IoT space, particularly when coupled with other key web3 ecosystem components like Whisper.
Plasma Overview and Transaction Data Availability
Ethereum faces both opportunities and challenges around scaling smart contracts, a proposed method using EVM contracts and a description of what changes to Ethereum are needed for optimal performance is proposed.
Real-World Smart Contract Development Lessons
Smart contract development tips you won’t find in the Solidity docs, from low level coding patterns to high level leadership skills. Raine Revere describes the techniques of central logging, modular libraries, arbitration, role analysis, context dependence, and skilled leadership in a talk for experienced and aspiring smart contract developers alike.
Scalable Onchain Verification for Authenticated Data Feeds and Offchain Computations
Ethereum smart contracts live like in a walled garden and they cannot fetch offchain data by themselves. One approach to securely feed offchain data into smart contracts is to provide attestation-backed data authenticity proofs that anybody can verify to ensure that the data-transport-layer is safe. By leveraging some new techniques, it is possible to do an effective onchain verification: the smart contract receiving the data can easily verify its authenticity onchain at a negligible cost and with a minimum amount of data.
Scalable Responsive Đapps with Swarm and ENS
Daniel Nagy gives their talk titled, "Scalable Responsive Đapps with Swarm and ENS"
Scalable Secure Scuttlebutt
secure-scuttlebutt is a secure gossip protocol with efficient data replication. This talk is about how efficient that data replication is. In the blockchain world, the first goal is global consensus – secure scuttlebutt throws this out the window, and goes for eventual consistency and local consensus, and that frees us up to get really great efficiency. Fortunately there are many useful and important things you can build without global consensus (for example, social networks, and things strapped onto social networks) and these usually benefit greatly from efficiency.
Semantic Ethereum – Linking Dapps together with data
There has been a great deal of interest in using blockchain technology in order to enable the web of trust, and to realize the original vision of the Semantic Web (more commonly known to developers as “linked data” and “microdata”). Two papers to look at for this talk: Block Chain Technologies & The Semantic Web: A Framework for Symbiotic Development by Matthew English, Sören Auer, and John Domingue A more pragmatic Web 3.0: Linked Blockchain Data by Héctor E. Ugarte
Secure Decentralized Oracles: Applying Intel SGX and TownCrier to external data, payments and off-chain computation
We will cover the need for secure and maximally decentralized oracles for Ethereum smart contracts. The focus of the presentation will be on how allowing data providers, payment providers, and various API-based services to be accessed by Ethereum smart contracts through a decentralized oracle network can greatly expand functionality, while maintaining the key security guarantees of smart contracts. We’ll focus on how TownCrier’s approach to implementing Intel SGX enables third party oracles to be provably secure, as is already being done on production using the currently live TownCrier implementation. We’ll also look at how oracle operations and off-chain computation can be written in solidity to be run entirely in an SGX Enclave, allowing provable off-chain computation and retrieval of external resources. Smart contracts need to retain a high level of security in both the network they run on, and the inputs/outputs they rely on, we aim to show how decentralized oracle networks, TownCrier’s approach to using Intel SGX for secure external access , and off-chain computation using solidity in Intel SGX can together allow smart contracts to remain secure as they access key resources outside the Ethereum network.
SmartPool: using smart contracts to eliminate middlemen in cryptocurrency mining
We provide updates on SmartPool, a decentralized mining pool using smart contracts. Typically, we present our findings after running SmartPool privately on the Ethereum mainnet with the highest hashrate of 30 GHs for a month.
Status – Ethereum at the edges of the Network
Running an Ethereum node on resource restricted device has not been without it’s challenges, in this talk Jarrad describes some of the technical limitations faced, their solutions along with plans & proposals for making Ethereum accessible.
Securify: Not Your Grandma’s Smart Contract Verification
We present Securify (www.securify.ch), the first push-button security auditing tool for Ethereum smart contracts that is fully automated, easily extensible to new security vulnerabilities, and provides strong security guarantees. The core technical idea behind Securify is to soundly extract deep semantic information from the smart contract using automated abstract reasoning. This information is then used to ensure the absence of critical security vulnerabilities, such as reentrant calls, unprivileged storage accesses, and many others. Securify precisely analyzes real-world smart contracts within seconds, and handles any language that compiles to Ethereum bytecode.
Snopes meets Mechanical Turk on a Blockchain: Reality Keys, On-chain Truth Verification and Subjectivocracy
The next-generation smart contract oracle platform by Reality Keys crowd-sources the process of data gathering and fact checking with an incentive-based system on the Ethereum blockchain. Our system is designed allow contract authors to fetch arbitrary structured or unstructured factual data, without relying on a pre-existing trusted off-chain data source.
Sikorka – Proof of Presence for Blockchain Applications
Sikorka – Proof of Presence for Blockchain Applications
Swarm Development Update
An Update on the Swarm project. Current status, upcoming changes, roadmap; introducing project PSS, the FUSE driver, the Network Testing Framework, updates on encryption and encoding. Previews for the p2p breakout session on Saturday.
Viktor Trón, Daniel Nagy, Aron Fischer, Louis Holbrook
The Blockchain Virus: Can a blockchain pay to replicate?
Full nodes provide many services to a cryptocurrency network: data forward, blockchain storage and retrieval, and some privacy and DoS protection. But as the resources consumed by a blockchain network grows, so is the node cost. Full nodes are usually altruistic, they take resources from their peers and they give back. But there is no immediate benefit to give back. This problem, which can lead to a tragedy of the commons, was early identified in the “Red Balloons” paper. Some solutions involve using master-nodes, leading to centralization risks. In this talk we’ll show how to create a fully decentralized system for rewarding full nodes that is fully autonomous, and controlled by a smart-contract.
Swarm City: Decentralized Peer to Peer Commerce
We will describe the technical architecture of Swarm City. Specifically how we use Whisper to communicate and initiate the payment without having to send a public key.
Michael Thuy, Stefaan Ponnet
The Future of Token Contracts: MiniMe, Governance, LiquidPledging & ERC223
The standard vanilla ERC-20 token has been heavily used in the Ethereum ecosystem, but the innovative application of tokens has not been explored nearly enough. In this talk i will explore: – The MiniMe token and its many applications, especially in decentralized governance. – The current status in the ERC223 token standard and my opinion on the path forward. – LiquidPledging, an innovative solution for fund management.
Thunderella: Blockchains with Optimistic Instant Confirmation
Elaine Shi is an Associate Professor at Cornell University. Elaine’s research creates platforms and tools that aids non-expert programmers in creating systems that are “secure by design” and “secure by default”.
Towards a Permanent ENS Registrar
Nick Johnson gives their talk titled, "Towards a Permanent ENS Registrar"
Trustlines Network: Open Protocol for Decentralized, IOU-based Currency Networks
The Trustlines Network targets the problem of fair access to money by implementing money as peer-to-peer issued IOUs on the Ethereum blockchain. We present the basics of the protocol, as well as the prototype of the mobile app, which aims to provide a seamless onboarding experience to the Ethereum ecosystem.
Bernd Bohmeier, Kristoffer Nærland
Turn-key Smart Contracts
How do we empower Rapid Application Development on Ethereum? How do we enable mass adoption of Ethereum? And how does one build such a platform? Now is the time to abstract development away from the “elusive and mythical creature,” or the average user as defined by Alex Van de Sande. UI driven development will finally bridge the gap between Ethereum developers and the average user.
Mike Alonso, Matt Swezey
Uport – Usable Key Management for Multiple Identities Across Multiple Chains
Exploring how private keys can be securely managed for multiple identities with an intuitive mobile user interface like the uPort app. In addition, we explore the notion of how identities can communicate and transact across multiple chains with varying consensus systems.
Michael Sena, Rouven Heck, Pelle Braendgaard
Fabian Vogelsteller gives their talk titled, "Web3.js 1.0"
USCC – The Underhanded Solidity Coding Contest
João Gabriel Carvalho, Richard Moore, Martin Swende, Nick Johnson discuss USCC – The Underhanded Solidity Coding Contest
João Gabriel Carvalho, Richard Moore, Martin Swende, Nick Johnson
ZoKrates – A Toolbox for zkSNARKs on Ethereum
Scalability and confidentiality remain two important challenges in the context of the Ethereum Blockchain. zkSNARKs promise to address these challenges, but they are notoriously complex and hard to use. To help bridge the gap between theory and practice, this talk will introduce ZoKrates: a toolbox for zkSNARKs on Ethereum, making zkSNARKS easier to use. This talk elaborates on the vision, features and design of ZoKrates as well as future steps.
A Conversation with Stewart Brand
A Panel discussion with Stewart Brand, a pioneer in creating the Personal Computer, featuring Wendell Davis and Althea Allen. Stewart gives a brief history of his life and work spent "hacking civilization," and discusses a variety of topics including: The progress in the "hacking" ecosystem; The role of institutions in decentralization; The overlap of blockchain & climate change; Aging within a movement. A Q&A session follows the Panel.
AxLang: Compiling Scala to EVM Bytecode for Secure and Reliable Ethereum Smart Contracts
We present AxLang Backend: a compiler framework for verifiable Ethereum smart contracts, and Axoni’s first step toward releasing an open source full-stack Scala compiler for the Ethereum Virtual Machine (EVM). AxLang Backend significantly improves the ability to optimize, analyze, and verify/audit smart contracts through a standard intermediate representation (IR), a compiler norm that hasn’t previously been used by EVM compilers. Additionally, AxLang Backend can be used by other compilers to target the EVM in a more efficient manner. AxLang Backend consists of four main features: a clean, minimal intermediate language (IL) that serves as an effective compiler target as well as a human readable/writable languagea standard three-address code IR that is convertible to a static single assignment (SSA) form, as is common in widely-used general purpose compiler frameworksa retargetable code-generation module that converts IR into the desired executable codea decompiler that constructs the above IR from Ethereum bytecode produced by other compilers like Solidity. Axoni is developing AxLang because the ability to write verifiable smart contracts is critical to our clients' broad adoption of this technology. AxLang Backend is the underlying structure that makes it possible for AxLang and other high-level languages to efficiently target the EVM.
Athanasios (Thanasis) Konstantinidis
Ackee - Mobile Development Studio
We present our dev kit that has been funded by the Ethereum Foundation. With the devkit iOS developers can easily use Ethereum smart contracts in their applications. This will be the official introduction of the dev kit.
BlockScout - The Ethereum Explorer
Etherscan is a block explorer used and loved by many of us. One of the core features of Ethereum is the ability to verify, view, and interact with smart contracts through Etherscan. The problem is that this functionality is mostly closed source and end users have to trust a single entity that this information is valid.With the help of EthPrize (http://ethprize.io/) and the Ethereum Foundation, POA Network has been building an Open Source EVM block explorer to solve this issue. Our v1 release will take place very and soon and we would love the opportunity to show developers and the Ethereum community that there is another option other than Etherscan. Along with the standard blocks, transactions, internal transactions, tokens, and logs, our v1 release will include contract verification, contract read and write functionality, and exportable smart contracts for further verification from developers. Our plan is to support Ethereum, Kovan, Rinkeby, Ropsten, POA Network, and Sokol testnet in our first release. We've had the great opportunity to work with many developers in the space to build an open and accessible block explorer for the Ethereum community. Here is more info on the project: https://github.com/poanetwork/poa-explorer
Building Augur - Lessons Learned
Scott Bigelow discusses the experience building Augur, and the lessons they've learned.
Bridging the ÐApp: contracts talking across chains
"A year ago Parity Tech published an initial PoC of Parity Bridge, a federated system that can connect any two EVM-based networks. In this talk, we'll give an overview on the progress we've made and present our new release. Today many Ethereum dapp teams have 'working' products but neither can they launch their product due to mainnet's limitations (congestion/high tx-fees) nor can they improve their products since today’s non-value-bearing testnets don't cater to realistic testing environments. At the same time, strongly sought-after scaling solutions (such as Shasper) are either far out or not applicable to current generation dapps. Some of the points that will be covered in this talk are: - Arbitrary message passing Bridge - interfaces, extensions, deployment and usage - How can bridged sidechains mitigate current scaling issues of the Ethereum mainnet? - How can they extend capabilities and be used to test potential, future mainnet functionality? - What are important security considerations? (i.e. trust model, integration with different consensus engines & validator sets) - Which tooling is needed and what's available today?"
Contributing to Ethereum and Open-Source
The Ethereum community is an open source community. We rely on implementations of an open protocol, open tools built to interface with these implementations, and ultimately open source dApps and contracts that live on top. Without a healthy ecosystem of open source developers, Ethereum is nothing. That said, contributing to open source can sometimes feel intimidating, and it's not always clear how to get started. Fortunately, it is actually easy in the Ethereum community! Everything is growing and changing so much. There is so much to do and to build, and there are a ton of great ways to get started. This talk will help demystify contributing to Ethereum and open-source in general.
Decentralized development: what even does it mean and should we care? (yes!)
Amber Baldet and Patrick Nielsen discuss decentralized development.
Amber Baldet, Patrick Nielsen
Antoine Cote & Philippe Camacho from Enuma present their progress after receiving a Grant.
Antoine Cote, Philippe Camacho
Ethereum for all : develop mobile apps using MIT AppInventor
Imagine a world where programming Ethereum on mobile is made easy, fun and accessible to anyone. AppInventor aims to make coding accessible to all by providing a graphical API to develop Android applications through high level components usually referred to by “blocks” (by Blockly). It comes from Google, then MIT, and is open source. The strength of AppInventor lies in its simplicity and ergonomics : kids can learn to build an app in a few hours, and business professionals can as easily construct a proof-of-concept of their ideas. Ethereum and public blockchains in general must be accessible to anyone, we are now making blockchain programming accessible to anyone with an AppInventor extension: Qaxh.Eth. With basic blocks such as connecting to Infura, "getBalance", “signTX”, "sendTx" or "getTxStatus" anyone can now create his own app to interact with Ethereum. I will show how I have added extensions based on web3j in order to create blocks for accessing the blockchain. The lightning talk will quickly present the technology, a workshop whose agenda is on another submission will have participants make their own mobile app and create more appinventor blocks, either borrowing functionality from web3j or fully making their own.
ERC1066: Better UX & DX in Just One Byte
This talk discusses ERC1066: a common set of Ethereum status codes ("ESC") in the same vein as signals, tagged tuples, and HTTP status codes. They provide an opt-in way of enriching payloads with a finite set of shared metadata. ESCs improve smart contract autonomy, UX, and DX, with clear application for localization, wallet integration, and contract interoperability. Code layout, Solidity and JS helper libraries, and tooling are all designed with developer experience in mind. While much broader than errors, ESCs are fully compatible with revert-with-message, with the added bonus of being localized for the end user. Come see the difference a byte makes!
EthereumJS - Our Roadmap for 2019
In this talk we will give an introduction to the EthereumJS ecosystem and the various libraries we are maintaining and provide an outlook on future developments. We will tell you about the state of our virtual machine implementation and plans on Ewasm integration and we will retrace the progress on our client project. We will further talk about where we think we can contribute to the latest sharding research efforts and explain why we get more and more excited about TypeScript, what AssemblyScript is and what all this has to do with progress and future integration of an Ewasm virtual machine. This will be a combined talk by various members of the EthereumJS team.
Holger Drewes, Jared Wasinger, Casey Detrio, Vinay Pulim, Alex Beregszaszi
Ethermint 2.0: Cosmos SDK + EVM
Chris Goes presents his talk on Ethermint 2.0: Cosmos SDK + EVM.
Ewasm: Ethereum-flavored WebAssembly and Ethereum 2.0 - Part 1
Ewasm is a candidate for the future Ethereum engine to replace EVM with the rollout of Shasper. Ewasm stands for Ethereum-flavored WebAssembly and it encompasses a broad range of initiatives being led by the Foundation Ewasm team including building an execution engine for Ethereum 2.0, adding support for a host of languages including C++, Rust, and AssemblyScript, and lots of related research and tooling to make Ethereum development easier and more powerful than ever. The team is in the process of launching a public testnet and releasing tooling which will be officially announced in this breakout session. In addition, members of the Ewasm team will introduce the technology, walk through the new stack, and give demos of the bleeding edge development tooling we've built around Rust, AssemblyScript, and other frameworks. We'll have an hour-long workshop where developers can download the new tools and get their hands dirty, building and deploying their first Ewasm-compatible smart contracts, with the team serving as mentors.
Alex Beregszaszi, Guillaume Ballet, Paweł Bylica, Hugo De La Cruz, Casey Detrio, Paul Dworzanski, Jake Lang, Lane Rettig, Jared Wasinger
ethers.js - A Complete and Compact Ethereum Library
The ethers.js library, which has received a DevEx Grant from the Ethereum Foundation is an Ethereum library designed to be complete, while remaining small, flexible and secure. By creating a library which abstracts many of the features available in the Ethereum eco-system to a collection of lowest-common denominator objects, developers can focus on the aspects they care about for their application without having to take into account the type of signer (a geth node? a hardware wallet? a multi-sig contract) or the provider back-end (geth? parity? INFURA? Etherscan?).
EVM Packages: using OpenZeppelin from ZeppelinOS
Proxy contracts are gaining traction as a mean to support upgradeability, reduce deployment gas costs, and share on-chain libraries. In this talk, we'll quickly review: -The minimal proxy contract, being formalised as EIP 1167 -The transparent upgradeability proxy, in use in ZeppelinOS -And the vtable proxy contract, which enables new development patterns
Ewasm: Ethereum-flavored WebAssembly and Ethereum 2.0 - Part 2
Ewasm is a candidate for the future Ethereum engine to replace EVM with the rollout of Shasper. Ewasm stands for Ethereum-flavored WebAssembly and it encompasses a broad range of initiatives being led by the Foundation Ewasm team including building an execution engine for Ethereum 2.0, adding support for a host of languages including C++, Rust, and AssemblyScript, and lots of related research and tooling to make Ethereum development easier and more powerful than ever. The team is in the process of launching a public testnet and releasing tooling which will be officially announced in this breakout session. In addition, members of the Ewasm team will introduce the technology, walk through the new stack, and give demos of the bleeding edge development tooling we've built around Rust, AssemblyScript, and other frameworks. We'll have an hour-long workshop where developers can download the new tools and get their hands dirty, building and deploying their first Ewasm-compatible smart contracts, with the team serving as mentors.
Alex Beregszaszi, Guillaume Ballet, Paweł Bylica, Hugo De La Cruz, Casey Detrio, Paul Dworzanski, Jake Lang, Lane Rettig, Jared Wasinger
How can the Enterprise Ethereum Alliance interoperate with the public Ethereum chain EIP process?
Members of the Enterprise Ethereum Alliance and the Ethereum core Ethereum Improvement Proposal (EIP) process will have a facilitated breakout session discussion on how to interoperate, learn from each other. The EIP process builds on large scale public open source collaboration, also inspired for historical reasons by the Bitcoin BIP process. Which in turn borrows from Python PEPs, XMPP XEPs, and so on. The EEA has a more formal technical steering committee process for its corporate members. The goal is to improve the quality of the technical Ethereum ecosystem overall, and understand how private chain, enterprise use cases can interoperate with public chain EIP processes.
Boris Mann, Nick Johnson, Conor Svensson, Bob Summerwill, Jamie Pitts, Charles Nevile, Alessandro Voto
Introducing Embark 4 - A powerful engine to build DApps
Iuri Matias, Lead Developer of the Embark Framework, introduces the new version of the framework and how it can be used to easily build the next generation of DApps and Decentralized Services-----Abstract (for submission): The Embark Team has been hard at work these past months working on the next version of Embark which allows to create in minutes DApps that would otherwise take hours if not days, easily allow the developer to find bugs & security issues, a powerful development "command center" and create easily not just classic DApps but other types of Decentralized Services as well on top of Ethereum.
Integrating Ethereum at Scale
Many developers understand how to integrate with the Ethereum blockchain with a few accounts, but how do you grow your product to support millions of users? Jake & Eric, engineering leads at Coinbase, will facilitate a roundtable discussion about the unique challenges of integrating with Ethereum at scale, including key management, protecting customer privacy, and building for forks. We hope this conversation will be a starting point for other major companies in the space to share how they’ve scaled and learn ways we can support each other to grow this industry.
Eric Scrivner, Jake Craige, Pete Kim
Inside Out and Upside Down: Making the Web Distributed Despite Itself
I'll talk about efforts at Mozilla to enable decentralized and distributed web applications, how the success of the web is one of the biggest challenges to changing it, and share lessons we've learned shipping open source software to hundreds of millions of people worldwide.
Improving the Ethereum Virtual Machine (EVM 1.0, 1.5, 2.0)
This panel will consist of experts with deep experience designing and building both the current iteration of the Ethereum Virtual Machine, EVM 1.0, as well as various candidates for future virtual machines including EVM 1.5 (several improvements to the existing EVM) and Ewasm (a reimagining of the Ethereum Virtual Machine built using industry-standard WebAssembly technology). These experts will discuss the history and current state of EVM 1.0, the various improvement proposals that are on the table, and the various initiatives underway today. It will also touch upon harder, more controversial questions regarding the EVM 1.5 and EVM 2.0 (Ewasm) proposals. The panel will give audience members an opportunity to learn about how and why Ethereum and its smart contracts work the way they do today, to ask questions of the experts behind this design, and to participate in the conversation about the future of Ethereum--both the low-level virtual machine and the stack of developer tooling (such as Solidity) built on top of it.
Alex Beregszaszi, Casey Detrio, Lane Rettig, Gregory Colvin, Danny Ryan, Paweł Bylica
Introduction of Ethereum iOS dev kit
We present our dev kit that has been funded by the Ethereum Foundation. With the devkit iOS developers can easily use Ethereum smart contracts in their applications. This will be the official introduction of the dev kit.
Josef Gattermayer, Jan Mísař
Nethermind - .NET Core Ethereum Client
If you are familiar with .NET and new to Ethereum programming, this workshop will teach you how to integrate .net applications or new dapps with Ethereum smart contracts using Nethereum. This programming session will guide through the creation of a standard token (ERC20 smartcontract) as well as through the creation of a .Net api definition and interaction with a smart contract (deployment, transactions, calls and events). Members of the Nethereum team will of course be there to answer any questions you may have regarding Ethereum programming and its cumulated benefits when used in the .NET context.
Tomasz Kajetan Stanczak
Piet is a web application providing support to understand smart contract architectures. This is approached by generating a graphical representation of such architectures and a possibility to query deployed instances of smart contracts. The graphical representation shows the inheritance structure of solidity contracts. In addition to the inheritance structure the defined enumerations and structs are shown. To provide understanding of one single solidity contract Piet offers an inspector view showing all members of the contract including the inherited ones. The presentation of the contract and the contract members is enriched by documentation labels derived from Ethereum NatSpec tags. Piet also provides an interactive mode enabling to read the state of a smart contract, sending transactions and browsing through events. This is achieved by connecting to deployed smart contracts through an injected web3 object.
S-gram: Statistical Linter For Incomplete Solidity Smart Contracts
This presentation will introduce a statistical linting technique called S-gram for Solidity smart contracts. Generally, S-gram aims at finding bugs, stylistic errors, bad programming practice patterns in Solidity contracts. Unlike traditional approaches relying on program analysis which requires full/compilable contracts, S-gram offers automatic checking capability even for incomplete Solidity contracts, thus can help create better development experience where developers can almost code and check simultaneously. The key insight behind S-gram is that "unusual code is more likely to be buggy". The likelihood is measured via probability computation in statistical language models, e.g. N-gram. Specifically, S-gram builds an N-gram model out of a corpus of “good” contracts (“good” means meeting stylistic specifications and having no bugs). Given an incomplete contract c, S-gram first parses it into a token sequence based on abstract syntax tree types e.g., AssignExpr, CallExpr etc. Then, S-gram calculates probabilities with respect to the N-gram model for all the subsequences of c and further flags less-probable code as suspicious. This presentation will also introduce preliminary evaluation on S-gram in terms of capturing real-world smart contract errors. In the end, this presentation will highlight the future tooling support to integrate S-gram with a Solidity IDE.
Shasper on Substrate
Robert Habermeier gives an overview of Parity Technology's work on Serenity.
State of the ENS
Updates on the state of the Ethereum Name Service, and our plans for the next year.
Nick Johnson & Jeff Lau
Jarrad Hope from Status gives an update on their Changelog.
The Trinity Ethereum Client - A platform for blockchain applications
Trinity is a new full client for the Ethereum network. This talk will cover three main areas. First, highlighting the role that Trinity plays in the research and development of the core Ethereum protocols. Second, that once Trinity is no longer in an alpha stage that it will be a production client which you can use as core infrastructure. Last, explaining the "Plugin API" being developed for trinity as well as exploring the planned use cases we foresee it being used for.
The State of Plasma
David Knott and Kelvin Fichter give an update on the state of Plasma.
David Knott, Kelvin Fichter
Updates from the Solidity Team
In this talk we will give an overview of what the Solidity team has worked on in 2017/2018 and what our plans our for the next year. It will cover features, challenges and plans.
web3j 4.0 will be released just in time for Devcon4.web3j provides the glue for Java and Android developers to work with Ethereum. It is now the most popular Java/Android Ethereum library on GitHub. I will be providing a quick update on the great new functionality contained in this milestone release.
Conor Svensson, Ivaylo Kirilov
Year working with Geth on a production Ethereum application
AirSwap is a decentralized trading network. As Infura can attest, these applications end up making quite a few calls to Ethereum nodes. Most of the calls are simple lookup calls just checking balances. In addition, because the network supports trading there are many transferring token calls as well. This talk focuses on the evolution of AirSwap's geth infrastructure through the course of the year and how the setup has changed. We started from using Infura, to a single node, to making an in-house cluster. Along the way, we've experienced down times, slow syncs, and code issues. While, the infrastructure is bound to change as the ecosystem shifts, we'd love to share what we've learned and a bit of our setup.
Adam Link, Don Mosites
Yul - Intermediate language for Ethereum
This talk will give an introduction to Yul, the intermediate language developed by the Solidity team. We'll go through the motivation, design decisions and progress of implementation. Yul is designed to have multiple targets, EVM and ewasm, and support multiple languages as a frontend. We'll touch on languages using it (Flint, LLL) and what is ahead in order to support it in Solidity.
A Visual Overview of Blockchain Development
“The open-source model is a decentralized software development model that encourages open collaboration. Depending on the license terms, others may then download, modify, and publish their version (fork) back to the community.”Yet the ‘open source way’ doesn’t always abide by the rules and many developers just don’t care enough to choose the right license. Arguably, the more than 80 license types scare developers away. This talk will show us the current state of licenses out in the wild west of open source Ethereum communities- for that, we’ll look at charts, diagrams and maybe even maps- and help you choose an appropriate one when starting a new project.
An EVM-based formal Rules Language
Smart contracts are immutable programs on the blockchain. They are automatically executed based on pre-defined rules. However, complex and inferencing rules could be extremely difficult to program, test, and validate, using standard programming languages like Solidity. The long sequences of highly nested and intersecting IF / THEN statements are fragile and error-prone. The problem is compounded by the need to frequently change rules based on business requirements. Enterprise software developers have long relied on Business Rules Engines (BREs) to solve this problem. BREs allow business analysts to write transactional (state changing) programs in a specialized programming language called formal rules language, which can be generated by graphical user interfaces. BREs automatically evaluate, re-evaluate, and execute those rules. They have been proven successful in traditional financial services. The Open Source Lity project developed extensions to Solidity so that the EVM could support BRE for smart contracts. In this presentation, I will discuss the benefits and use cases of rules language and engine for smart contracts especially in the context of financial services and e-commerce applications. I will further describe how the rules language extension for Solidity, modeled after Drools, is designed and implemented, including compiler and runtime support.
Timothy McCallum, Hung Ying Tai, Michael Yuan
Analyzing decentralized exchange liquidity with DexIndex
DexIndex is a free, open source library for developers working with Ethereum decentralized exchange data. It launched in February of 2019 and has seen spectacular growth since then, with almost half of all new commits coming from outside contributors! In this lightning talk, we'll go over what DexIndex is and how you can use it your applications and APIs with just a few lines of code. https://medium.com/fluidity/introducing-dexindex-93dc0bac77d0
Architecting a Decentralized GitHub Backup
When it comes to building dApps, there is a key part of the process that remains very centralized. The tools we use for version control, like GitHub, are centralized, leaving dApp builders and communities at the mercy of providers and prone to censorship. By building a decentralized backup of GitHub in case of censorship, downtime, or other sudden loss of source code access, dApps can better decentralize access to their codebase. This presentation will outline the architecture behind a decentralized GitHub alternative and demo the proof of concept.
Autonomous Ethereum mixers
I demonstrate how to build a profitable, self-sustaining Ethereum mixer. I use zkSNARKs as the core mixer mechanism , and invest the shielded money pool into a risk-free DeFi application to earn interest . The mixer complies with Vitalik's interface proposal . The general privacy setup is similar to ZCash: a "shielded" pool, which contains all the ETH deposited by people who desire anonymity, and "notes" that can be withdrawn without revealing any connection to the deposit transaction. Importantly, this provides K-anonymity for K → ∞, unlike ring signatures or MimbleWimble, providing K-anonymity for K < 15 (ring signature size in Monero, block size in MimbleWimble) and thus prone to several attacks [4, 5]. The pool of ETH deposited into the mixer and awaiting withdrawal is supplied into the Uniswap WETH converter (~4%/year ROI). Unfortunately, that revenue cannot be supplied to the users, since the exact amount would give away precisely when the deposit was made. On the other hand, it can be used to subsidize infrastructure and "keepers" that made the withdrawal transactions for clients – a known problem for all previous mixer designs.  https://github.com/barryWhiteHat/miximus  https://zumzoom.github.io/analytics/uniswap/roi.html ETH-WETH pair  https://hackmd.io/@HWeNw8hNRimMm2m2GH56Cw/rJj9hEJTN?type=view  https://ipfs.io/ipfs/QmWYTeggKeL8xBitA8uQWAaNDWfFrUHXAxBXkvmnisdDw7  https://eprint.iacr.org/2019/455.pdf
Blockchain × 3D data, Publishing NFT for whole body 3D scanned data.
The development and diffusion of VR and AR technology has made 3D data familiar.However, 3D data can be copied, and there are challenges in protecting copyrights and portrait rights. Also, monetization can be difficult.By publishing NFT of the original 3D data and providing the benefit that only the owner of the NFT can enjoy, we aim to create an eco-system that the value of the NFT will increase when the data duplicated.We(BlockBase,inc, DiGITAL ARTISAN, and MiraCreative) started a project to publish NFT of Whole body 3D scanned data of Japanese celebrities.
Beyond CryptoKitties: building tradeable, interoperable ERC721 digital assets
ERC721, a standard for non-fungible tokens pioneered by CryptoKitties, is the new standard on the block, somewhat less well understood than the more mature ERC20. ERC721 has a variety of emerging use cases, including pure collectibles, game items, event tickets, naming systems, and even physical assets like real estate. This workshop will guide participants through the process of creating a new ERC721 contract from start to finish, with functionality beyond simple collection and trading. It will cover a range of tools for building robust, useful ERC721 assets, including decentralized file systems like IPFS for metadata storage, integration with marketplaces like OpenSea, interoperability with virtual worlds like Decentraland and CryptoVoxels, ERC20-compliant wrapped ERC721's, and ties to off-chain data with Oracles like ChainLink. The workshop will leverage existing Ethereum infrastructure like Truffle and Infura, allowing the user to deploy a fully-functional ERC721 contract that could then be launched alongside a dapp on the Ethereum mainnet. The workshop will also discuss extensions to the ERC721 contract, as well as newer standards like ERC1155.
Birthmarking Your Smart Contracts For Vulnerability Search
In this talk, we will highlight an automatic vulnerability search technique for smart contracts. In the context of security, vulnerability search enables us to make quick response to new threats and zero-day exploits. In those cases, well-designed analysis is far from prepared to deliever precise detections. Our vulnerability search technique can act as a complement in this setting to efficiently identify potentially vulnerable contracts without heavyweight in-depth reasoning and analysis.The key insight is to "birthmarking" a smart contract by abstracting its programming intents. Generally, the generation of birthmarks is realized via symbolically executing the bytecode of a smart contract and building global dependency on the fly. More specifically, both syntax features (e.g., number and type of instructions) and semantic features (e.g., load and store at the same storage) are considered in birthmarks. Then, the task of searching for a known vulnerability is converted to computing a similarity between a target contract (with the vulnerability) and a candidate contract (may/may not have the vulnerability). We have implemented a prototype to search for known vulnerabilities and conducted large-scale evaluations on real-world security issues. Particularly, we will use CVE-2018-10376 to explain how the search technique can help existing security analyzers
Han Liu, Qian Ren, Zhiqiang Yang
Building a Decentralized BitMEX Using an Optimistic Financial Contract (OFC) Framework: New Tools for Fast and Secure Financial Contracts on Ethereum
We introduce the Optimistic Financial Contract (OFC) framework, a novel approach to financial contract design that allows for hyper fast, secure, and scalable DeFi contracts *without* requiring an on-chain price feed. This framework makes it easy for developers to build otherwise complex synthetic financial derivatives on Ethereum. We show how this design can be used to build a decentralized derivatives exchange (aka BitMEX) that can be as performant as the centralized alternatives. How it works: optimistic contracts work by assuming contract participants will act optimistically to avoid penalties. This formalization borrows heavily from Plasma and state channel research. “Long” contract participants enforce that “shorts” remargin contracts on a timely basis (and vice versa). Surprisingly, no on-chain price feed is required—an oracle is *only* needed to resolve disputes in what is conceptually similar to Plasma’s exit games. This simple framework works at both the L1 and L2 levels and can be extended to create almost any type of financial contract developers can imagine.
Hart Lambur, Allison Lu
Building dApps and IoT using the Incubed Ultra Light Client
The Incubed protocol is an incentivized, secure and fully decentralized protocol for stateless ultra light clients. It is specially designed for devices or applications which are restricted in available resources like memory, calculation power, connectivity or bandwidth. During the workshop, we will discuss the advantages and disadvantages of non-synchronizing (stateless) clients and demonstrate with comprehensible programming examples how mobile apps, web applications and especially IoT applications can be realized with minimal resource consumption using the Incubed client. In the second part, we will take a closer look at the proofs used by the Incubed protocol to verify the correctness of blockchain information. In a programming challenge, we will examine how those proofs work in the application context.
Simon Jentzsch, Steffen Kux
Building Synthetic Derivatives on Ethereum
This workshop will teach participants how to build best-in-class financial contracts on Ethereum that can support a wide array of DeFi use cases. Using concepts borrowed from fiat financial derivatives, participants will learn—with real, interactive examples—how to design and create their own decentralized financial contracts that are self-enforcing, permissionless and universally accessible. Participants will learn common design patterns for a wide range of financial products, including contracts for synthetic asset tokenization, decentralized margin trading, and interest rate swaps. We will also discuss how to implement these design patterns using the Optimistic Financial Contract framework, a new approach to financial contract design that allows for fast, secure, and scalable DeFi contracts. With examples and real-life code, participants will learn how to design new, scalable DeFi products, including a simplified design for a decentralized derivatives exchange (aka a decentralized BitMEX).
Regina Cai, Hart Lambur, Allison Lu
Building a Formally-Verified DApp with the Reach DSL, today!
Catching exceptions in Solidity
When a revert happens in solidity, all the state changes done in that transaction are rolled back. All the changes done in sub calls are also rolled back. If a contract A tries to do a token transfer in contract B but contract B reverts, all the changes done by contract A will also be rolled back. This is fine for some cases but sometimes there might be a need to ignore or handle this revert in the smart contract itself. The talk will demonstrate how reverts and other exceptions can be caught in Solidity.
Building on Uniswap
Uniswap is an automated market maker on Ethereum. It can be used directly as an exchange, but arguably its most interesting use is as a building block for other protocols and applications. This talk will discuss how Uniswap was designed to favor composability, including offering synchronous contract-accessible liquidity, turning pooled market maker liquidity into its own fungible asset, and aiming for simplicity and efficiency rather than completeness. The talk will demonstrate ways in which Uniswap can be composed with other protocols to create new kinds of on-chain financial products. The talk will also preview some future features of Uniswap—ERC20-ERC20 pairs and Uniswap-based price oracles—and show how they would expand Uniswap’s usefulness as a building block of decentralized finance.
Hayden Adams, Daniel Robinson
Building Mainstream-Ready dApps
Matt Slipper speaks about building mainstream-ready dApps.
Choosing composition over inheritance wherever possible: is that right?
Composition over inheritance is a staple in object oriented programming since the early 1990s. Developing with Solidity on the EVM has forced me to re-examine several programming paradigms. With Ethereum, there are other considerations given that smart contracts are typically immutable and gas costs become a more important factor. I wanted to take some time talking about this design pattern and sharing some examples with the community.
Conquering the Nonce
The nonce - just a single, incrementing integer that lets you send your transactions to the Eth network. Simple, right? Our experience working with hundreds of dApp developers tells a very different story - thousands of failing RPC requests, transactions that never get mined, and dozens of hours spent debugging with nothing more to show than a fragile work around. Overlooked and under considered, nonces have been the single biggest pain point for tons of Ethereum developers. In this talk we will share all of the techniques and best practices we’ve gathered in our hundreds of hours helping DEXs, dApps, and more solve exactly this issue. A few thoughtful design choices and properly handled nonces can lead to better products and significantly higher quality of life for developers.
Connecting Decentralized Liquidity
The talk will introduce decentralized liquidity, its role in the ecosystem and how several defi projects are utilising the decentralized liquidity in different ways. The talk will also touch base on what Kyber does to connect different decentralized liquidity sources to make them available for the defi ecosystem.
Daily: An easy, open source dollar wallet for Venezuelans
We'll quickly go through the user experience decisions we took when building Daily, a wallet that Venezuelans can use to send digital dollars from one phone to another. We'll talk about the Linkdrop protocol, supporting old Android versions, and the importance of connecting deeply with liquidity sources.Daily is a project supported by MakerDAO and Binance Labs.
Dapps Ain't Easy
Along with my job at OpenZeppelin, I spent the last year writing a book on Ethereum for traditional web developers new to the space. While writing, I found that many things that we take for granted when coding on Ethereum are much more difficult to get right than we think. On this lightning talk, we will briefly present overlooked challenges on gas estimations, handling reorganizations, and even managing subscriptions. Though there will be no silver bullet solution to close, we will discuss what we can do as an ecosystem to mitigate these problems.
Creating Type Safe DApps with TypeScript and TypeChain
Lately, we've seen a huge spike in TypeScript popularity, wouldn't it be great to be able to leverage it for DApp development?In my talk, I want to show how to use TypeScript and tool that I created called TypeChain to achieve fully type-safe communication with Ethereum smart contracts. This speeds up development process, helps to find bugs in compile-time and warns about breaking changes.TypeChain is not only useful during DApp development but it integrates with Truffle Suite as well which makes writing tests for smart contracts in TypeScript possible.
Decentralized Federated Learning on the Oasis Network
Machine learning is being adopted more and more broadly in technology. Such success is largely due to a combination of algorithmic breakthroughs, computation resource improvements, and the access to a large amount of diverse training data. The collection of data can raise concerns about siloing, security, and user privacy. In this talk, I will highlight a new blockchain-based machine learning technology that allows users to share their data, train models in a fully decentralized way, and incentive end users to keep their data on the network using the Oasis network. This technology, called HiveMind, leverages a federated learning framework to reduce overhead both in communication and computation. In addition, the talk will highlight the benefits of a novel blockchain-based secure aggregation protocol that ensures client-level differential privacy, and thus prevents information leakage from trained model parameters.
Decentralize All The Things: Deploying Your Own Node Infrastructure
Many developers rely on third-party node services to make dapp development easier and reduce user onboarding challenges, but this can lead to single points of failure and systemic weaknesses in web3 infrastructure. This presentation will go over some of the weaknesses in different ethereum node implementations and show you how to mitigate against them in your own resilient node service, including how to reduce node start times with efficient state replication and how to protect against DDoS attacks. Reduce your dependence on third parties and make sure your dapp or blockchain-related service can take a beating. Blockscale used these same techniques to help MyCrypto significantly improve the performance and cost-effectiveness of their node services. This presentation includes code examples and deployment demos.
Delightful Developer Experience with Solidity Hot Loader
Mass adoption of Ethereum requires attracting both users and developers. Developers trying to enter Ethereum are often pushed away by unstable libraries, lack of documentation and poor developer tools. The typical Solidity development cycle is: change a Solidity code, compile the code, restart a local node, apply an initial state, and restart a frontend app. It can be reduced to just saving Solidity source code and all the changes will propagate automatically. We present a practical implementation of Solidity Hot Loader as well as a generic approach to enable it across the entire Ethereum developer space.
Designing Awesome Developer APIs for Protocols
The growth of your protocol ecosystem is rooted in the ease at which developers can build applications using your tools. How do you create intuitive, powerful developer experiences to encourage people to build a vibrant application ecosystem?We share the behind the scenes of what really goes into powering marquee developer communities. In this talk, we cover the design and implementation of custom APIs for some of the most popular applications: CheezeWizards by CryptoKitties, Kyber, and more.
EIP 2020, E-money Token Standard: A standard for financial payments and operations for tokenized money
The EM Token builds on Ethereum standards currently in use such as ERC20, but it extends them to provide few key additional pieces of functionality, needed in the regulated financial world: Compliance: EM Tokens implement a set of methods to check in advance whether user-initiated transactions can be done from a compliance point of view. Implementations must `require` that these methods return a positive answer before executing the transaction Clearing: In addition to the standard ERC20 `transfer` method, EM Token provides a way to submit transfers that need to be cleared by the token issuing authority offchain. These transfers are then executed in two steps: 1. transfers are ordered 1. after clearing them, transfers are executed or rejected by the operator of the token contract Holds: token balances can be put on hold, which will make the held amount unavailable for further use until the hold is resolved (i.e. either executed or released). Funding requests: users can request for a wallet to be funded by calling the smart contract and attaching a debit instruction string. Payouts: users can request payouts by calling the smart contract and attaching a payment instruction string. https://emoneytokenstandard.org/
Daniel Lehrner, Fernando Paris
(e)WASM code golfing - below par with Nim
On the horizon of Ethereum2, WebAssembly being proposed for phase 2 execution. Just like with the EVM, we'll be paying for gas and storage, and thus it's important that you're able to use contract space efficiently.In this presentation, we'll go over the WASM pipeline from program code to assembly bytecode, looking step by step at:* where storage goes* tricks and techniques to optimize for size, speed or both* how the compiler looks at and reasons about your code* what tooling is available to help you!* how the choice of programming language might affect the efficiency of your codeFor our examples, we'll be using NimPlay - an easy to use smart contract development environment currently being researched at Status.
Formally verified EVM golf and reverse bug bounties
With the formalized semantics of the EVM in the K framework (the Jello paper), a new arsenal of analysis tools has become available for Ethereum smart contract development. This workshop will demonstrate how this tooling can be used to verify the complete behavior of smart contracts, sharing the techniques and tools used to verify the core contracts of multicollateral dai.We will demonstrate the power of formal verification by presenting the Ethereum community with two challenges:In the first one, we invite the workshop participants to a round of formally verified EVM golf. The most gas efficient implementation of an ERC20 contract which provably matches the specification wins!In the second challenge, the task is to challenge the specification itself, by writing a passing adversarial smart contract. In this "reverse bug bounty", participants are invited to poke holes in a specification by writing smart contracts which satisfy the postulated requirements but are otherwise faulty in some way.
Lev Livnev, Martin Lundfall
Extending Ethereum’s Account and Transaction Models in Klaytn
Ethereum has usability limitations that hindered mass adoption. To solve the issues, Klaytn, an Ethereum-forked blockchain platform, extended account and transaction models while preserving compatibility. Blockchain user accounts have been a technology adoption barrier. There are two pain points that Klaytn aims to solve. 1) A random hex string as an account address that is not human readable. 2) A single private key that is permanently attached to an account. Klaytn supports the creation of alphanumeric account address and update of the private key of an account. On top of that, the native support of multi-sig and role-based keys, which is needed by industry, will expedite the blockchain mass adoption. Klaytn refined the transaction model as well so that each transaction type serves a specific function. This separation of concerns gives more opportunities for performance and storage optimization and makes it easy to add or extend platform features. Utilizing this design, several new transaction types are introduced in Klaytn without breaking backward compatibility to support the transaction-fee delegation and the extended account management features mentioned above. We believe that Klaytn's new account and transaction models are applicable to other Ethereum-compatible blockchain platforms to increase usability and performance.
Junghyun Kim, Donghwan Kwon, Sangmin Seo
Functional programming for Ethereum
Statically typed functional programming has received more attention in the age of blockchain than perhaps ever before. Languages like Haskell and PureScript were once thought to have a more natural home in academia than in industry. Now their powerful static analysis and security guarantees allow blockchain developers to prove more about the correctness of their programs. This is especially important as we move into the era of application-specific blockchains and scaling solutions written in ordinary languages.We’ll walk through the state of Ethereum libraries and tooling in Haskell and PureScript to highlight some of their interesting features, as well as compare and contrast them with their counterparts in non-functional languages. We’ll also discuss the ongoing work on hs-abci, the Haskell bindings to the Tendermint ABCI protocol, which enables Haskell developers to write application specific blockchains backed by cosmos/Tendermint.The session will be a mix of live demonstrations and slides. There will be a repository to follow along with for the interactive portions.
Martin Allen, Kristoffer Josefsson, Irakli Safareli
Grantee Exposé Lightning Talk 2 - Perun’s research on off chain protocols
Lisa Eckey presents Perun's research on off-chain protocols.
Grantee Exposé Lightning Talk 3 - Twitch Plays Pokemon on Plasma
Tom Nash presents Twitch Plays Pokémon on Plasma.
Grid: tools for the ETH 2.0
In this lightning talk we'll show how Grid lets you safely download and manage ETH clients and interact with the ETH 2.0 beacon and validator chains.
Grantee Exposé Lightning Talk 1 - The Web3j-SDK
This talk at Devcon will be used to announce the release of the web3j SDK (final name TBC), which provides a fully integrated development and deployment environment for Java/Android/Kotlin/etc developers working on Ethereum. It also includes a smart contract registry and blockchain explorer for ongoing smart contract management and support.
Conor Svensson, Ivaylo Kirilov
Grid: your new personal Ethereum infrastructure
Grid provides new and experienced users alike with a powerful tool to help them find, download, configure, and use Ethereum clients and tools in a secure way, enabling them not only to become participants in the Ethereum network, but also strengthen the core philosophies. Grid tries to make the Ethereum ecosystem, and access to powerful financial and cryptographic applications, more inclusive and accessible for everyone.
Everton Fraga, Marc Garreau, Ryan Ghods, Philipp Langhans
Grantee Exposé Lightning Talk 2 - What’s next for GSN
Liraz Siri speaks on what's next for the Gas Station Network.
Holly Atkinson: from zero knowledge to zero knowledge proof
Holly Atkinson left her role as Lead Business Developer at a green energy company on 31 October 2018, to pursue a new career as a software engineer. Holly now works as Frontend Engineer at Tracr, a company that is bringing the benefit of the Internet of Things to the Diamond Industry, and plays an active role London’s blockchain community. She will share her technical pathway to date, her perspectives on the two types of role and her reflections on turning from a user of technology into a creator.Specifically, Holly will share her story about how and why she became a developer, useful resources, getting into Ethereum in London, observations on the differences between old and new career, key learnings from being a mentor to women in tech and her vision for the future.
How Microsoft engineers build enterprise Blockchain apps on Ethereum Networks
Enterprise Blockchain applications have different constraints and challenges to ones on public networks. Come see how Microsoft engineers architect based on market segment (B2B / B2C), and use serverless compute to integrate systems onto Ethereum networks. This will be a demo heavy presentation showing real world engineering used at top enterprises, such as DevOps, unit testing, serverless compute, VS Code scaffolding.
David Burela, Whitney Griffith
How to Develop Generalized Applications on Layer2
Cryptoeconomics Lab has been researching generalized Dapps using the second layer technology especially Plasma and building a framework with developer tools for them. The final goal of our R&D is to produce more viable applications running on top of Ethereum by enabling developers to build secure, scalable, and usable Dapps with better developer experience. In this talk, we will first clarify what it’s like to build L2 applications based on the design of the Optimistic Virtual Machine, our latest research focus, which enables the generalization of various Layer2 constructions. Then, we will showcase example L2 applications, such as a payment application with instant finality using Plasma and payment channel and DEX supported by Atomic Swap technique.We hope that we can contribute to the Ethereum ecosystem by sharing our research outcome and its implementation as a library with all the other research teams and create more of the application use cases on Ethereum cooperatively.
Shuhei Hiya, Yuriko Nishijima
How much gas does it use interacting with this smart contract?
Developing a smart contract is easy. There are a lot of tutorials and examples on how to write a smart contract. In some cases, it is even possible to simply copy the code. Afterwards compile it, deploy it and let the users use it. But has it been optimized before the deployment or does it waste the user’s gas?We present a tool which analyzes the bytecode of a deployed smart contract based on the rules presented in Chen et al. (2018): “Towards Saving Money in Using Smart Contracts”. A user can enter a transaction hash and the tool reveals if the smart contract has been optimized. For non-optimized cases the user sees how much gas is wasted by using the functions. The estimation is based on the analysis of the OP codes. Thus, is not necessary to provide the ABI or the source code. This gives users the possibility to verify that smart contracts do not use too much gas and forces developers to optimize their smart contracts.
How to Integrate Ultralight Beam
The objective of Ultralight Beam ("UB") is to provide a simple and extensible messaging format for applications to transmit arbitrary data over a mobile ad hoc network (MANET). MANETs are devices that come together to form a network without relying on any infrastructure. In the context of Ethereum, this allows for transactions to be broadcasted and state channels to be formed, but offline. This workshop aims to show how a developer could integrate Ultralight Beam into their application to allow for offline interactions as described above.
Dean Eigenmann, Greg Markou, Eric Tu
How to publish websites in a decentralized way and index it using Ethereum Smart contracts. After is possible to search keywords in the websites. In this talk will be presented tools to register, store and explore the Web 3.0.
Infura's Open Architecture Initiative
Infura engineers have found unique ways to utilize tools openly available in cloud provider offerings to reduce the time to sync Ethereum nodes and run them reliably. At DevCon5 we’d like to share this new architecture paradigm so that other development teams will be able to utilize the same tools that we do to run their own reliable infrastructure. We first launched at Devcon2 as a handful of nodes and a simple architecture. We’ve scaled and iterated on our architecture for API traffic that grew from millions to billions of requests per day-- serving applications like Metamask, MyCrypto, Coinbase Wallet, Opera, and Brave Browser. Infura makes it easier for developers to build on Ethereum. During this talk, we’ll share our findings on scaling access to blockchain data. We’ll also discuss ways on how to efficiently cache blockchain data for the JSON-RPC API. We’ll talk about what worked and what didn’t so that others can learn from our applied research.
Jee Choi, Eleazar Galano
KWasm: Executable (E)Wasm semantics for verificaton and profit
KWasm is a project for specifying Wasm in the K framework, much like the EVM was specified with KEVM. KEVM has been used extensively for verifying smart contracts, and as Ethereum transitions to Wasm, it's time to get ready to verify Ewasm contracts. With KWasm complete, the new focus is embedding it into KEwasm and other blockchain execution interfaces. This talk is a quick introduction to the power of K, our roadmap and how you can use KWasm to start verifying Wasm code.
Keycard - An open source Smartcard hardware wallet framework
Keycard is an open source smartcard framework and API to build smartcards for cryptocurrency. We propose a workshop where developers can learn everything about using Keycard hardware and software. Using Android, iOS or Go SDKs they will quickly learn how to integrate Keycard with existing applications on both mobile (iOS/Android) and desktop. Interacting with the Keycard applet, they will able to integrate a smartcard hardware wallet that implements all the features of an HD Wallet. Using the Keycard Cash wallet, they will learn how to interact with a smartcard “burner wallet” that enables quick onboarding with “pre-paid/pre-loaded” cards and ready to use NFC enabled smartcard to tap and pay at Point of Sales devices.<sup></sup> Keycard applets run on standard javacard smart cards, the same platform used by credit cards or SIM cards, and turns them into a hardware implementation of a BIP-32 HD wallet that supports key generation, derivation and signing. [full text + links/projects/integrations in the PDF attached because of words count limits here]
Michele Balistreri, Andrea Franz, Guy-Louis GRAU
Lessons Learned From Phase 0 Testnets
Preston Van Loon discusses lessons learned from Phase 0 testnets.
Preston Van Loon
Learn how to secure your code as you write it
The Ethereum Virtual Machine and the Solidity language are not trivial components to build with. When you code, you need to consider many more things than with other traditional languages. Things like execution cost, storage and the most importantly: Security. Also, using a code style guide is a must. It will help any current programmer in a project adhere to the rules pre-established by the team, and enormously help a newcomer avoid some undesired writing styles, impacting on code review quality and speed. I will introduce you to one of the most used open source linters in the ethereum ecosystem: Solhint. Solhint allows for detecting syntax-related security code vulnerabilities. Covering a wide range of validation rules, the tool also enables developers to add new ones, while complying with the Solidity style guide and granting 2x–4x boost in performance. By attending to this workshop you will go through the journey of using Solhint. From integrating it to your preferred IDE all the way down to get the most out of its functionality. I will close the workshop sharing best practices that are hard to port - and are still yet to be implemented into Solhint.
Lessons Learned to Build a Dapp On a Light Client
Builders on Ethereum are concerned by centralization, otherwise they wouldn't build on Ethereum right? Still, most Dapps today rely on trusted 3rd party nodes. We need to change this. Over the past months, we have built Fether, a wallet based on a light client. We will show in this presentation the lessons learned and share our takeaways on how to best build an application on top of a light client. We will present light.js, the library we've built to enable builders to use good practice and have a Dapp that is truly decentralized.
Mapping finite state machines to zkSNARKs
Fabrizio Romano Genovese speaks about Mapping finite state machines to zkSNARKs.
Fabrizio Romano Genovese
Make the tests feel the user's pain - E2E testing for DApps
With the move from protocol development to more user-focused products, the decentralized applications are in a stage where frontend testing is not an easy task due to the lack of tools and experience in the field of Web3. Protocols have strong testing and auditing, but their user-facing apps lack a simple way to do so. In this workshop, we aim to explain how to start focusing on the user and ensure that they get what we expect even when the chain behaves unexpectedly. The main things that we will touch in the workshop will be: - Classic E2E tools (Puppeteer and Cypress) - Why they don't work the same way in DApps - How to use them with Web3 injectors like Metamask and connect to different testnets - What are the key pieces to test The workshop will start with a bit more of theory around testing and then we will move to a practical exercise where we will set up the architecture needed to properly test our decentralized app.
MakerDAO Oracles: The Backbone of Decentralized Finance
For the past two years, MakerDAO's Oracles have been running on Mainnet, powering not only the 500 million Dollar Dai Credit System, but most of the Decentralized Finance projects that run peripheral to it, like secondary lending platforms.In this presentation, you'll learn about the history of MakerDAO's Oracles, what worked, what didn't, and get a good look at the Version 2 Oracles that will power Multi-Collateral Dai and the rest of Decentralized Finance on Ethereum.
Meta Transaction Relayers at Scale
Earlier this year Bloom’s smart contracts were consuming over 2% of all gas on Ethereum mainnet. All coming from one meta transaction relayer. In this talk we will cover the techniques implemented in Bloom’s transaction broadcasting service to meet strict requirements of transaction ordering, fee management, chain reorg detection and alerting. We will also cover the challenges of moving a Meta transaction service from test nets with low, consistent volume and quick confirmation times to main net with irregular costs and spiking periods of congestions.We will officially open source the service at Devcon and discuss future work involving how to reliably cache and batch transactions to further reduce meta transaction costs.
Monitoring an Ethereum infrastructure
Have you ever wondered what goes on under the hood of an Ethereum node? Frankly, most people don't care. If you are, however, running production systems with multiple nodes across geographical locations, knowing what your nodes do internally is more important than you might think.It is a general fallacy to believe that a software either works, or does not. In reality, there is a whole spectrum in between. A software almost never works perfectly, rather there are quirks that may or may not affect your use case. These quirks may manifest only above a certain load or compound as time passes. The only way to build out a robust infrastructure, is to accept that your nodes are quirky. Instead of getting surprised when they break - having no idea what caused it - you must always be aware of buildups and correlations to external stimuli. This talk will present the suite of metrics that Geth exports for monitoring, highlighting why these have been added and why they might be important to you. By correlatinh your own load and use case with Geth's internals, you'll be able to gauge issues before they ever get strained enough to cause catastrophic meltdowns.
New Application Design Principles in Ethereum 2.0
With the Phase 0 spec freeze and Phase 1 in progress, the mechanics of Casper FFG and sharding of data availability has received plenty of attention. On the other hand, the mechanics of Ethereum 2.0 for application developers hasn’t received the same amount of clarity from the implementors nor scrutiny from the community. This talk will focus on how application design will (and will not!) evolve in the context of three trends in application design right now: DeFi, zero knowledge proofs, and layer 2 solutions.
Practical design patterns for DApp developers
Used to building apps in Python or Ruby on Rails, but new to blockchain? This talk is aimed at experienced developers who are new to Ethereum. My goal is to give developers practical frameworks for architecting their decentralized applications, that will minimize gas costs, reduce the attack surface and simplify upgrades. Decentralized applications require a new way of thinking. I want to share some templates for developers who are making the jump to decentralized applications and aren't familiar with the quirks and limitation of the Ethereum EVM. We will look at the following Solidity design patterns: Approve and call Factory contracts Proxy contracts Name registry Upgradability As well as ways to reduce gas costs without compromising on security, including: Event sourcing Using IPFS effectively Building decentralized applications is hard. The stakes are high and there are a lot of ways to get things wrong. Mistakes can be expensive, either from security losses or high gas costs. I’m looking forward to sharing some of the lessons Origin’s engineering team has learned over the past two years building peer-to-peer marketplaces on top of Ethereum.
Remix New Features and Plug-in Governance
We’ve updated Remix’s architecture so that everything is a plugin. We’ve invited developers out there in "Ethereumland" to make plugins to expand Remix’s functionality to address their uses cases. This workshop will begin with introductions to some of these plugins. Then together, we will go through tutorials using the NEW Remix tutorial framework, to learn the techniques needed to use these plugins.
François Guezengar, Liana Husikyan, Yann Levreau, Iuri Matias, Rob Stupay
Quickly develop data driven reactive ÐApps
We present a new developer library that can do serverless event sourcing & automatic data syncing for querying smart contracts that greatly improves creating reactive ÐApps.
Iuri Matias, Richard Ramos
RADON: a domain-specific language for oracles
Oracles are bound to bridge the gap—or abyss—between the realm of smart contracts and data coming from outside the blockchain. But, at the end of the day, achieving such ambitious goal boils down to removing the inherent indeterminism of real world events by aggregating, filtering and reducing multiple data points into a single one in a predictable way. This is no easy task—even more in the case of decentralized oracles. In this talk we will introduce RADON: a domain-specific language that provides a new ontology and semantics to enable smart contract developers to define how external data will be retrieved, aggregated, filtered, reduced and reported to their contracts. In a learn-by-doing manner, we will reflect on the challenges that we faced and the quirky, wicked and hidden incentives that can be accidentally introduced by poorly constructed queries. Finally, we will also demonstrate relevant tooling for ergonomically creating and troubleshooting oracle queries within the context of existing Solidity projects.
Mario Cao, Gorka Irazoqui, Adán Sánchez de Pedro Crespo
Scaling your favourite dapp with ZkRollup
Rollup allows dapps to scale by using ethereum as the data availability layer and using snarks to create an off-chain execution environment where your dapp business logic can run easily. Rollup aggregates transactions so that they only require a single on-chain transactions required to validate multiple other transactions. The snark checks the signature and applies the transaction to the leaf that the signer owns. Multiple users create signatures. Provers aggregate these signatures into snark and use it to update a smart contract on the ethereum blockchain. A malicious prover who does not also have that leaf's private key cannot change a leaf. Only the person who controls the private key can. This is intended to be the database layer of snark-dapp (snaps) where the layers above define more rules about changing and updating the leaves Rollup does not make any rules about what happens in a leaf, what kind of leaves can be created and destroyed.
Vaibhav Chellani, Barry WhiteHat
Sharding From A Dapp Developer's Perspective
From launching CryptoKitties at the ETHWaterloo hackathon to the rise of KittyVerse experiences and designing Cheeze Wizards to be more extensible, our successes and failures have advised us each step of the way. Join this talk where we will share more about what we learned (sometimes the hard way) in designing for open ecosystems and how iterative improvement on smart contracts has the power to result in stronger development communities.
Smart Contracts Design Pattern
Design pattern are essential to create secure and efficient software even more in the smart contract world where every bug can have fatal consequences. This talk features a live demo of the development tool Piet and its plugin to access a catalog of smart contract pattern and anti-pattern. The presented Piet plugin queries existing pattern registries, categorizes them and presents the patterns in an enhanced way. A pattern view in Piet consists of its inheritance graph, an example implementation, a description, curated comments and a graphical interface to interact with deployed example contracts. The curated comments are way to inform the developer regarding issues related to this pattern which are not included in the original description.
Heiko Burkhardt, Ai Suzuki
Standards in Ethereum - how do we make them, how should we?
Ethereum, unlike most distributed ledgers, is based on standards, from the Yellow Paper to EIPs. Even the "corporate" technology users in the Enterprise Ethereum Alliance build on the Ethereum standards and extend them with their own standards process designed to avoid fragmentation or divergence. This session will explain the existing standards mechanisms and processes both for Ethereum and the Enterprise Ethereum Alliance, how they work individually and together, and be a collaborative exploration of what we can do to improve the various standards processes and make sure they produce better outcomes for the ecosystems and the variety of stakeholders that Ethereum serves.
Daniel Burnett, Jory Burson, Nick Johnson, Chaals Neville, Charles St.Louis
Smart Contract as a Service: Using messages to share contracts
Currently, developers deploy multiple copies of the same contract to the Ethereum blockchain. But with a shared global system, why not deploy contracts once and make them available for everyone?Learning from the actor model of message passing and the ERC1066 Status Codes Standard, I will present a model for “smart contract as a service”. This style of contract design can lead to highly vetted and secure contracts that anyone can re-use. Their persistence and re-use means we can also write integrations so that non-smart contract developers can make use of them off chain.
Standardized Incentives on Ethereum: a round-table discussion about StandardBounties
Since it's inception at the beginning of 2017, the StandardBounties "protocol" (group of smart contracts) has aimed to create a generalized and robust interface for dapps on Ethereum to manage bounties. These would be useful not only for work-like incentive schemes (like outsourcing coding or design tasks), but also for more nascent use cases like incentivizing social impact. The goal here was to create shared/open source "order book" of incentives which individuals or teams had put up, with the intention that bounties could be easily created within one dapp, and fulfilled on another.Since then, we've seen great interest in StandardBounties, with the protocol already being used to power bounties on Gitcoin and Bounties Network, while also working with DAOStack, Aragon, Giveth, ETHLance, and other teams to have them integrate and use a shared standard. Although this endeavour has been difficult (owing to the friction of coordinating individuals), we've worked hard to have StandardBounties be a collaboratively crafted, and collectively used protocol. This implies that the protocol isn't "open" just because its code is open source; it's open because multiple competing stakeholders are coordinating around the same contracts to the benefit of their users.This breakout room will be used to facilitate an open discussion among the aforementioned parties (Gitcoin, Bounties Network, DAOStack, Aragon, Giveth, ETHLance, etc) as well as any others who wish to partake, in order to discuss any changes or new features which may be necessary in the contract's evolution, and ensure things are running smoothly between the collaborating parties.
State of Ethereum 2019
We last presented at Devcon 3 Cancun. Fast forward to 2019, we explore how the network has evolved and grown since by looking at the overall top stats. As Developers, to build better dApps it is also essential to understand the user base we are serving. Using analytics data, we look at the changing user demographics of the Ethereum eco-system, learn & discover what the Ethereum "User Persona" looks like today vs 2 years ago, has it changed or largely remained the same over time? And while it goes without saying that building technical infrastructure is challenging, there are also unique non-technical issues in delivering basic essential infrastructure service to the community. We share some of these challenges, scaling issues and what we learned.
Matthew Tan, Wee Chuan Tan
Taking the DX to the next level: The OpenZeppelin Platform in a nutshell
The Ethereum developer ecosystem is in constant change. Undoubtedly, teams have started to leave the development of Smart Contracts in the background to focus on the development of decentralized applications and UX improvements on them. But developer experience is still important: We need the right tools to minimize the difficulty of working on Ethereum projects, while preserving high security standards. In this talk we will discuss how OpenZeppelin has been working on a frictionless tool for developing, deploying, upgrading and interacting with Smart Contracts and for creating DApps in an easy and secure way, introducing the latest version of the OpenZeppelin Platform.
Juan Bautista Carpanelli
Supersonic: Transparent SNARKs from DARK Compilers
Benedikt Bunz presents Supersonic: Transparent SNARKs from DARK Compilers.
Testing DApps with Realistic Web3 Mocking
I will demonstrate using a Web3 Mock for UI testing of DApps. It can be difficult to test with actual transactions between the frontend and blockchain. This is because transactions must be signed by a private key, but UI testing frameworks cannot interact with Web3 providers to do so. A Web3 Mock solves this problem by signing transactions with a private key automatically and sending them to the blockchain. This offers developers better experiences writing blockchain apps. It uses open source technology and is compatible with a range of blockchain development environments including Ganache, PoA, and remote APIs like Infura. It is integrated with the popular TestCafe platform to perform full end-to-end DApp testing.
The challenge of implementing Solidity stack traces
The Augur Master Plan, Part 2
The first Augur master plan from 2017 is almost completed, so it's time to look to what's next. To refresh, the original one was:1. Release a v1 which'll be pretty, slow, hard to use, and expensive 2. Integrate 0x and release a v1.5 that allows partially off chain trading so people can create, modify, and cancel orders quickly 3. Integrate Maker once out and release a v2 (“Soros”) 4. Add automatic rollover contracts 5. Release a v3 with super high transactions per second using sharding and/or raiden (“Simons”)In this lightning talk we'll go over what's next!
The MakerDAO Critical Governance Vulnerability
While working on an audit for the Coinbase team, we found a critical vulnerability in one of the DappHub library contracts, which affected the MakerDAO governance system in production. In this short talk, we will provide a beginner-friendly technical description of the issue and its remediation.
The Next Evolution of Web3 Wallets
Metamask’s aim is to empower the web3 ecosystem to create useful and usable applications for users. We have led the way thus far by being a web3 connector and a wallet that serves different types of user groups, and hence juggle their different needs. We are at a critical turning point, where we believe a one-size-fits-all solution is not the answer. We are looking forward to make Metamask modular, more secure, and extensible that dapp builders can use for the specific needs of their end users. We’ll do this with the help of new Metamask APIs, which will empower the developer community to build creative solutions that inherently integrate with Metamask. In this workshop, we will share developer beta version of Metamask APIs! What you can expect from this workshop: - You’ll learn about some new APIs the MetaMask team has been working on. - You'll learn how to use these APIs to enhance your products’ functionality and UX. - We'll bring a few working demos, and facilitate a brainstorm on how these features could help your users, and how we can improve them for you. - Build a simple application that is made possible with these new APIs.
Dan Finlay, Erik Marks, Omna Toshniwal
The Road to ETH 2.0: How to Build EWASM DApps with Embark v5
In this workshop we will be building step by step a modern DApp step that uses the latest Ethereum 2.0 technologies with the aid of Embark & Cockpit.
Michael Bradley, Iuri M, Eric Mastro, Pascal Precht, Richard Ramos
Towards Better Debugging: Data Format Design Session
On traditional computing platforms, most language compilers output debug information to enable debuggers to decode a program's operation and to enable the user to make sense of their code through hands-on inspection. With smart contract languages, however, this is not yet possible. Existing debugging data formats don't support Ethereum's computing paradigm, leaving debuggers to guess at compiler behavior in hopes of understanding how compiled bytecode reflects user-written source. In this breakout session, we will present the current state of debugging support on Ethereum, an overview of how debugging support exists on traditional computing platforms, and what the disconnects are that make this more difficult for Ethereum. From there, we seek to discuss how to overcome these limitations and how we can make smart contract debugging better. The goal of this session is to lay the groundwork for a new data format, including its high-level design and a clear understanding of the path forward for this effort.
Harry Altman, G. Nicholas D'Andrea
Universal Chain Registry: EVM + Cosmos ChainIds
We will present a new initiative to list all the ids of EVM and Cosmos-based chains. We will also speak about the ongoing work to provide a standardization of the chainId format and data structures to represent multi-interface blockchains information. Github: https://github.com/UCRegistry Telegram: https://t.me/UCRegistry
Pedro Gomes, Antoine Herzog
User Research: How to get out of our bubbles by talking to users
In this workshop targeted at anyone building blockchain products or services, an experienced User Research team will help you step out of your comfort zone; by learning to interview and observe end users. Georgia and Sasha will explain the benefits of doing user research, what it looks and feels like when we talk to people who are different from us, with some "tales from the trenches". Then we will help groups 1) identify and find the right users for your research, 2) work out what to ask them 3) practice interviewing people to get to the core insights. Attendees will leave the workshop with a taste for conducting their own future user research, as well as increased confidence to challenge their own biases and blindspots.
Georgia Rakusen, Sasha Tanase
Using DAOs to Make Decentralized Protocols Actually Decentralized
Luis Cuende gives his talk on Using DAOs to Make Decentralized Protocols Actually Decentralized.
Welcome to the Samsung Blockchain Galaxy
The ideological value of the Blockchain is similar to the chracteristics of Blockchain technology itself. Both the real world as well as the technology are both creating and inspiring new values to communicate to one another. At DevCon5, we look forward to sharing Samsung's vision of Blockchain along with its technical features. We'll explains the background of Samsung Blockchain Keystore launch from a security perspective along with why Ethereum was the first choice for solving the security and tech challenges many face. We'll also look at how the Ethreum ecosystem has allowed Samsung to strategize our blockchain strategy when it comes to regional launch selections, vertical segments, and future roadmap. Samsung would also like to share our market leadership by voicing why we, as the global OEM leader for smartphones, are making the leap into the Blockchain community by making SDK's available for developers and welcoming developers to embrace the platform from a mobile perspective. and welcoming them to partner with us and create amazing decentralized applications. Our scale and market position combined with the dev community's insight and know-how will be very exciting!
Wook Lim, Minji Chae
Workshop: Building on top of Golem with gWasm and Unlimited
Are you ready for a thrill of doing something new and exciting? Would you like playing with WebAssembly on Golem Network? During the workshop, we will demonstrate a set up of a Golem Unlimited cluster - including machines brought by the audience. We will showcase how to distribute the execution of existing apps within the ad-hoc infrastructure. You will have an opportunity to run 3 apps with source-code available and code your own app using the simplistic API and cross-compile to Wasm target. Attending the workshop will give you the tools and knowledge to tackle our white-hat hacker challenge. Stay alert! To fully experience hands-on experience in the workshop, please install the docker on your machine and do `docker pull golemfactory/gwasm-tutorial`beforehand.
Mikolaj Barwicki, Piotr Chromiec, Piotrek "Viggith" Janiuk, Jakub "KubKon" Konka
1 Human 1 Vote Money Legos 🔜 More Democratic DAOs 🧱🤝✨
Right now, the DAO ecosystem is built around one-token-one-vote or one-cpu-one-vote schemes. With strong sybil resistence, the ecosystem could move to DAOs built on one-human-one-vote. This unlocks more democratic use cases like: - quadratic funding - quadratic voting - Gini coefficient measurements - UBI - one-person-one-vote DAOs - data collectives - sybil resistant airdrops + more Learn about the current landscape of sybil resistance techniques in web3.
5 Smart Contract Patterns I Wish More Devs Would Use
A few creative and undervalued smart contract design patterns that could help you build more effectivelly.
Account Abstraction: Making Accounts Smarter
This talk discusses the limitations of externally owned accounts (EOAs), use cases for account abstraction, and how to join the account abstraction revolution.
Liraz, Dror Tirosh
Advanced Seaport Techniques
Seaport is a marketplace protocol for buying and selling NFTs. While it powers OpenSea in a horizontal capacity, Seaport is open source and allows marketplaces to share a pool of liquidity – enabling project-specific, bespoke vertical marketplaces. Since launch, it’s helped spur innovation across emerging NFT verticals, including ENS names, in-game purchases, etc. This workshop will explore advanced techniques and use cases for the Seaport protocol.
Alice in Proxyland
The story of Alice in her journey of making her smart contract upgradeable. She starts with a very naive approach, and quickly bumps into the fundamental problems of proxies: using CALL vs DELEGATECALL, the execution context, storage collisions, the importance of tooling, etc. As her system grows in complexity, her proxy architecture iterates and becomes more and more sophisticated, finally arriving to a very powerful, elegant and easy to use architecture: The Router Proxy.
Autonomous Worlds Self Led Session
A session for those interested in the latest developments in Autonomous Worlds and fully on-chain games, including demos of cutting-edge projects, a panel with Optimism co-founder Kevin Ho and Dark Forest creator gubsheep, and an introduction to MUD — the open-source engine for building Autonomous Worlds. More info here: https://0xparc.notion.site/Autonomous-Worlds-SLS-612ff18a99f54594806776971b5a8ec6
Justin Glibert, Remy, Andy, Lethe, Arthur Baer, GVN, Flynn Calcutt, Fraser, Omar Mezenner
Blockchain Analytics 101: Building an Indexer from Scratch
A workshop which goes through how to build an EVM observability application and how to interpret the data collected. This workshop aims to empower users to venture into blockchain analytics to identify arbitrage opportunities, high value projects and the centralization of protocol/DAO voting power in a protocol.
Build Your First Contract with the Wizard of OZ
Whether you are a new developer writing your first contract, or an advanced one starting a new project, the OpenZepplin wizard is here to help you bootstrap your smart contract contracts. Let's see how to use it, from the basic contract idea to its deployment, in under 5 minutes!
Building a Thriving Developer Community
I want to give a talk on the ins and outs of building a thriving web3 developer community. I help lead DevX at https://superfluid.finance and I've learned the hard way what it takes to get hundreds of projects built on your protocol. I'll give an overview of what both engineers and marketing/growth people get wrong about building a developer ecosystem, how we run hackathons, and how we've productized our docs and developer tooling.
Better Solidity Support in VSCode by Hardhat
A brisk jaunt through the state of the art in Solidity editor tooling, a tour of Nomic's Solidity Language Server and how we can take Solidity editor support to the next level.
Building an End-to-End EVM Symbolic Execution Engine in Solidity
Symbolic execution is a widely used approach to formally verify/analyze EVM bytecode. But what exactly is it? What are constraints, and solvers?? Why do you need symbols anyway?? In this talk we will go through a symbolic execution engine for EVM bytecode fully written in Solidity, hopefully demonstrating how beautiful and simple these techniques are, and incentivizing developers to contribute to or write their own formal methods tools.
Decentralized Programmable Key Pairs
Join this talk to get an introduction to Decentralized Programable Key Pairs (PKPs), by Lit Protocol. PKPs are 'distributed custody cloud wallets' that act as a personal compute platform that can write to a variety of state machines (e.g Ethereum, IPFS) because they are 'smart contracts with a secret' that can make arbitrary HTTP requests and use that data in the computation.
David Sneider, Chris Cassano
Infura has provided a centralized API service to help grow the Ethereum and Web3 ecosystem since we launched in 2016. In 2023 we will be launching Decentralized Infura. This talk will go over the details of the decentralized protocol and the transition to it. We will also discuss why this is necessary at this point in the growth of the ecosystem and the emergence of a multi-chain future.
E.G. Galano, Tim Myers
Demystifying Ethereum Assembly
# Demystifying Ethereum Assembly The EVM creates an economic incentive to minimize computation and data storage. This leads to extreme gas optimizations in a few different assembly languages and patterns. In this workshop, we will learn about EVM assembly through both a walkthrough of EVM basics and real-world, practical examples of assembly. This workshop assumes an intermediate level understanding of programming and at least a beginner understanding of Ethereum.
dm3 - Decentralized, Secure and Open Messaging Protocol
dm3 is a protocol enabling decentralized, open, and secure messaging based on established web3 services like ENS and IPFS. It doesn't rely on any central service. The user has complete control over where their messaging data is stored. By using ENS names and ENS text records as the registry for public keys, the user owns the identity linked to their messages. dm3 comes with a reference implementation for a standalone web application, a widget, and a delivery service.
ELI5: Account Abstraction
ERC lightning talks
15mins lightning talks about ERCs, mainly focused on following topics: NFTs/SBTs/ABTs/Token-gating/Curation Music NFT metadata Privacy and self-sovereign identity Other Radical Exchange topics e.g. Plural Property
timdaub, Anett Rolikova
EVM-first EIPs Workshop
This is a workshop discussion about the EVM. Anyone can come up and pitch their favourite EVM-first EIPs. We want to be a bit more unconventional and would like to transform the room into a "live voting space" where attendees can fight for their favourite new EVM feature. Different proposals will be listed and discussed for 3-5 minutes each, where invited panelists give a short opinion followed by loud interaction from the audience.
Alex Beregszaszi, Paweł Bylica
EVM Tracing in Geth
Ethers: What's New in v6?
Just a quick overview of some of the new APIs and features of Ethers introduced in v6, including Typed-Values, more-flexible Contract interaction and Layer 2 enhancements.
EVM - Some Assembly Required
EVM assembly can be quite opaque and intimidating at first glance. In this talk we'll take a look at exactly how EVM assembly works under the hood while analyzing some common functionality we see in smart contracts - as well as showing some optimization techniques you can use by jumping down to assembly in your solidity contracts.
Experiments with EthereumJS
The idea of the workshop is to present the EthereumJS stack and then help people to set up a local EthereumJS experimentation environment. We will demonstrate how how our packages can be used for research, testing and experimentation and will then let people experiment on their own (or in small groups), for example by activating one of the newer EIPs and testing blocks/tx, or even running our experimental client.
Gabriel Rocheleau, Scott Simpson
Geth Team AMA
Marius van der Wijden, lightclient, Guillaume Ballet, Péter Szilágyi
Getting Started with MetaMask Snaps
[MetaMask Snaps](https://bit.ly/3u8bDKh) is the next phase in [MetaMask](https://metamask.io)'s evolution. First previewed at Devcon V in 2019, we are now focused on growing the Snaps platform and ecosystem, and new features are added every month. In this workshop, you'll build a Snap from start to finish with the MetaMask Snaps dev team. In the process, you'll learn about all the features you can make use of for Ethereum, Layer 2's, zero knowledge cryptography, and beyond.
Hardhat & Nomic Foundation: the creation of an Ethereum non-profit
Learn about the creation of the Nomic Foundation and what's coming next from the creators of Hardhat.
In this workshop, we will cover how you can leverage the power of Storage Proofs to enable your applications to read the current and historical state of another blockchain in a secure and verifiable manner.
headlong: A Contract ABI and RLP Library for the JVM
I describe how I implemented the solidity Contract ABI specification to make encoding and decoding faster and therefore more scaleable while also improving usability. headlong can parse any function signature or JSON description at runtime and do the type-checking of inputs before encoding and of outputs during decoding. I also discuss how the command-line interface uses human-to-machine and machine-to-machine RLP-based serialization formats to consume arguments and produce results.
How to Build a Multilayer DApp in Less Than 30 Minutes?
Learn how to rapidly develop front-ends for your smart contracts with useDApp. Make the user experience snappy, while reducing your Infura/Alchemy bill. Create auto-refreshing UIs, which update on each new block, on wallet, and network change. Track transactions progress, replaced transactions, history, and show notifications.
Justyna Broniszewska, Michał Sieczkowski
How to Integrate Diverse Sources of Reputational Evidence: Learnings from the Lens Protocol Reputation System
Many people are working on reputation systems. Many are computing reputation scores as linear models, which is less than ideal. I propose a new way of combining sources of reputational evidence based on Bayesian updating.
How to Stay Up To Date With Web3 Technologies
Following a vast technology field with thousands of projects, protocols, tools, and frameworks is complex. Inspired by ThoughtWorks, we decided to map all these Web3 technologies, present them using a radar metaphor, and give them as a public good. This initiative helps developers understand ecosystems and technology stacks in the Web3 universe. It further allows them to create their radars. This talk will introduce this methodology framework to help tech teams make better decisions.
Milos Novitovic, Uros Kukic
Improving Oracle Infrastructure on Ethereum
Oracles continue to fuel the growth of the Ethereum and layer-2 ecosystem. To build dApps that serve real-world use cases, from DeFi and DAOs to NFTs and beyond, Ethereum developers need access to secure oracle networks. In this session, we will dive into the latest oracle innovations and showcase new capabilities that enable Ethereum developers to build the scalable, secure, and feature-rich applications that can achieve widespread adoption.
Intro to Scaffold-ETH
Join Kevin Jones for a workshop on Scaffold-ETH, an off-the-shelf stack for rapid prototyping on Ethereum, giving developers access to state-of-the-art tools to quickly learn and ship an Ethereum-based dapp. Scaffold-ETH is everything you need to get started building decentralized applications powered by smart contracts. Learn more at https://github.com/scaffold-eth/scaffold-eth
Human-Friendly Contract Interactions
Web3 users often sign transactions without knowing what they are doing. How can we let them take more informed decisions? Contracts verified on Sourcify (https://sourcify.dev) can be presented with human-friendly information via the ABI and the NatSpec documentation The talk will explain how it's made possible with "Solidity contract metadata" and how Sourcify's "full verification" works. We'll also touch upon alternative approaches to how to display human-readable tx information to the users
Introducción a Scaffold-ETH y SpeedRunEthereum
Descubre las posibilidades de Scaffold-ETH para desarrollar aplicaciones full-stack en Ethereum y mejora tus habilidades como programador de Smart Contracts gracias a SpeedRunEthereum.
Introducing The Graph Substreams for High-Performance Indexing
Substreams is a powerful, parallelizable, blockchain data indexing technology, developed within The Graph. It enables truly composable indexing, with shared modules written in Rust, both in batch and in streaming. It reaches unbeforeseen performances by virtue of its parallel design that supports both mappers and stateful store modules. In this session, we will see how Substreams solve indexing for all blockchain protocols.
Lessons from the Nomad Hack
The Nomad Bridge suffered an incident in early August, resulting in about $190M in cryptocurrencies lost. We will see how the Nomad Bridge was able to get hacked and how it relates to the Nomad Protocol. Finally, we will share learnings and insights we got from this incident, actionable tips that all protocols should take into serious consideration in order to reduce the probability of a potential hack.
A Web3.py maintainer steps though how to use some of the lesser-known features recently released: async functionality, off-chain data lookups, plugin support and more.
MUD: an Engine for On-chain Games
For the past year and a half, 0xPARC and Lattice have been hard at work building MUD — an open-source engine for building on-chain games. In this talk, Justin and Alvarius from Lattice will be joined by Kelvin Fichter from Optimism, to talk about on-chain games, MUD, and an exciting new collaboration with Optimism to be unveiled on the day.
Justin Glibert, Alvarius, Kelvin Fichter
Modular Rollup Theory Through the Lens of the OP Stack
We've got 25 minutes to go as deep as we can possibly go into the architecture of modern (modular) rollups. We'll be looking at the theory behind the components of these rollups and we'll be grounding this theory in the concrete components of the OP Stack. Cmon, where do you think we are, 2019? It's 2022 y'all, and rollups are getting really, really cool. This talk will cover a lot of technical detail in a short amount of time, so come prepared and chug a lot of coffee beforehand.
On the Future of Web3 — Paving the Way to End-to-End Fully-Decentralized Web
One key feature of Web3 is decentralized compared to the current Web2, which is controlled by a few centralized companies such as Facebook, Google. However, when 99% of the users interact with the blockchain, one critical problem shows up: the dApp servers / NSPs are centralized! In this talk, we propose a solution for the future of Web3: an End-to-End Fully Trustless Decentralized Web, which means that any components in our Web2 from the user side and server side will be decentralized in Web3.
The merge of the beacon-chain consensus layer with the EVM execution layer is a major milestone for Ethereum, if not the most significant. The changes introduced are also affecting testing infrastructure. It's an excellent opportunity to look at the public testnet infrastructure, compare the various networks, and present the Sepolia and Goerli testnets to teams and developers still relying on Kovan, Rinkeby, or Ropsten.
Practical Pluralism ♻️🌱
Pluralism — the understanding that diversity of people, beliefs, opinions, mechanisms, approaches, implementations, etc within a given context generally results in better outcomes than in the absence of such diversity. In this lightning talk, Regen Web3 Founders Trent Van Epps, Abbey Titcomb, Karl Flouresch, Kevin Owocki, Griff Green, and Auryn MacMillan will talk about how they're baking pluralism into their projects + building a more pluralistic world by doing so.
Kevin Owocki, Griff Green, Auryn, Karl Floersch, Trent Van Epps, abbey
Remix has a program to reward our contributors with non-transferable NFT’s on Optimism. We’ll go over the details and the goals of this token / badge.
Remix intro workshop - EN ESPAÑOL
Remix IDE is the tool that most people begin with for their journey through Ethereum development. Come learn some basics of Solidity, the most popular language for programming smart contracts. We’ll be using the tutorials inside of Remix - so you can continue working after the workshop is over. The workshop will be conducted in Spanish.
Sign-in with Ethereum
The talk sheds insight on Sign-in with Ethereum, a new form of authentication that enables users to control their digital identity with their Ethereum account and ENS profile instead of relying on a traditional intermediary.
Smart Contracts and Petri Dishes: Creating a Shared Technical Infrastructure Roadmap for Descentralised Science (DeSci) on Ethereum
DeSci is the combination of open science principles and decentralization. This workshop aims to unite founders and developers in the DeSci ecosystem to explore what infrastructure is needed: from reputation systems for scientific credentials, to file storage, public good funding and financialisation. Participants will actively determine pressing needs and a roadmap to functioning DeSci dapps, while also exploring the cultural complexity and UX of scientists as a user group.
Smart-contract Testing Using Waffle Framework
Let’s learn how to effectively and easily write TypeScript smart contracts tests suites. We’re going to explore how to create a testing environment, execute transactions, assert balances, state and event emissions. This is going to be the place where developer experience and smart contract security truly meet.
Supporting the Ethereum Roadmap with a Decentralized Blockchain Data Supply Chain
The original Ethereum vision was for users to run full or light clients to use the network, yet today the most widely used block explorers and JSON-RPC APIs are centralized. Decentralizing the blockchain data supply chain is more important now than ever, as it supports key parts of the Ethereum roadmap, such as Stateless Clients and “The Purge”, which unlock major gains in security, scalability, and decentralization. Join us to learn about decentralizing this core part of the Web3 stack.
Symbolic Computation for Fun and for Profit
How symbolic computation in EVM / Solidity works, end-to-end. I'll try to give insights on problems that can be solved efficiently, forming constraints, relaxations, how to build custom solvers from scratch, and produce computer proofs. We'll be saving gas!
Technical Details of the Solidity Compiler
Recent updates about Solidity and plans for the future.
The Challenges and Learnings of Implementing Wallet Connection on Mobile
Web3 is mostly a desktop experience, but we spend most of our time on mobile devices. How can we bridge the gap between Dapps and Mobile, especially in such a crucial step as the wallet connection? In this talk, we want to share the failures and learnings we had while developing GM Shop, the first tokengated experience built for mobile that partnered with the biggest NFT brands such as Doodles, Invisible Friends, and Cool Cats.
Carolina Pinzon, Bryan Moreno
The Future of Wallets: MPC vs Smart Wallets
There's undoubtedly more we can do to improve Ethereum wallet UX, and there's two technologies competing for this: MPC (multi-party computation) and smart wallets. Let's explore the relative strenghts and weaknesses of each, as well as the protocol upgrades that will help (eg account abstractions, EIP3074 and EIP4337) and how those affect the comparsion.
The Road to Standardized Subgraphs
This session will explore how we can build subgraph infrastructures that are consistent across the board in order to enable the transformation of raw blockchain data into meaningful metrics.
The Showdown: Best Ethereum Language
This session will be an unconventional panel discussion. Instead of being boring and repeating the same things, we will spice things up a bit. The goal is to decide which is the best language for Ethereum. How do we find that out? Though a combination of "pub quiz" and on-stage activity (e.g. tug-of-war) between members of different language teams. The audience can chime in as well.
Hari, Leo Alt, Alex Beregszaszi
The Right Way to Hash a Merkle Tree
We shill an assembly SHA256 library that is optimized to compute the hash tree root of a Merkle tree. It consists of reusing two publicly available methods: 1. Hardcoding padding block. This method is used in Bitcoin's core client hashing algo. 2. Use CPU-vectorization to hash different branches in parallell. This is Intel's "multi-buffer" method. Initial benchmarks show up to 1200% improvement on hashing of large lists on AVX512. A GoAssembly version is used by prysm.
Understanding Transactions in EVM-Compatible Blockchains Powered by Opensource
Transactions are stored in the blockchain as hexadecimal data. That may be ok if you are a shadowy super coder but if you are like the rest of us you just need to have them explained in English. If there are no tools that allow decoding of those transactions then the potential of web3 can not be realized Its crucial such tools are developed in the open, as opensource code since decoding events for different chains and protocols scale faster than what any team of developers can maintain alone
Using IPFS to Create a Metaverse
Leverage the decentralized IPFS network to scale content storage management for a Metaverse implementation. - Manage all assets storage and remove S3 dependency - Navigate through the Metaverse Assets changelog history - Ownership validation based on Ethereum blockchain - Strength the network and decentralization by fostering the community to contribute with nodes - Remove the complexity to manually implement content synchronization on the network
Unlimited Size Contracts Using Solidity
Ethereum currently have a limit of 24KB for a contract size which cause a major pain for many Solidity devs. I would present all available options to address this issue using Solidity language during the workshop and provide cons and pros of them. * External libs * Transparent and uups proxies * EIP-2535 * Static precompiled router proxy * Dynamic router I will also provide gas optimization tricks for above methods and a novel method to reduce a gas cost for unlimited size contracts.
Using The Graph and Dune to Power on Chain Actions
Indexing protocols like The Graph and Dune analytics are great for getting insights on application-specific protocols. However, most are used strategic planning rather than being directly actionable. This workshop teaches developers how to make these insights actionable, by building simple programs in 3 steps: 1. Fetching indexed data streams from public data providers 2. Passing streams through models to generate signals 3. Generating and submitting transactions based on those signals
Christian St.Louis, Mattias Lightstone
What would Solidity 1.0 and 2.0 look like?
Solidity has quite a long history already, especially in terms of "crypto years". Yet, the project has not yet reached the "magical" 1.0 release. This talk is discussing what the language could look like reaching 1.0; and going beyond reaching 2.0.
What's new in Remix
We’ve been pumping up Remix with new tools & features for users of all levels. Come learn the latest Remix tricks & techniques. We'll cue up editor improvements, tool integrations (including Git), Remix shortcuts, and our new workflows. We’ll also demo our new interface for using Remix with proxy contracts. This talk will take your scratchings on Remix to 11.
What's next in EVM
What is the future of the EVM? This talk will include an overview of proposals to the EVM, many listed and some detailed. It will try to explain the likely hood of adopting them and what needs to be done to make sure they get adopted.
Alex Beregszaszi, Paweł Bylica