C++ Ethereum and Emacs

Lefteris Karapetsas presents on C++ Ethereum and Emacs.

Golem

Piotr Janiuk presents on Golem, a P2P distributed computation network running on top of Ethereum.

Solidity, Vision and Roadmap

Dr. Gavin Wood and Dr. Christian Reitwiessner present the vision and roadmap of Solidity, the smart contract programming language.

Looking at the Ethereum IDE - Mix

Dr Gavin Wood presents on Ethereum's IDE - Codename Mix.

BlockApps STRATO

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.

Augur

Dr. Jack Peterson presents on Augur (http://www.augur.net/), an open-source, decentralized prediction market built on Ethereum.

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.

Blockchain Model Canvas

Blockchain Model Canvas

Casper

Ethereum's Vlad Zamfir presents on Casper, the PoS blockchain architecture for Serenity release.

BTC Relay

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/).

DApps Framework

Ethereum's Konstantin Kudryavtsev presents on Embark, a DApp Development Framework built by Iuri Mathias.

DappStore

Tim Coulter of ConsenSys (https://consensys.net/) presents on the DApp Store (http://dappstore.io), a platform for sharing Ethereum based DApps.

Digital Identity

Christian Lundkvist of ConsenSys (https://consensys.net/) presents on digital identity.

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.

Ether.Camp

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/

Ethereum & WebAssembly

Ethereum's Martin Becze presents on the Ethereum Virtual Machine (EVM) and WebAssembly

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.

Gnosis

Martin Koppelmann Presents on Gnosis (https://groupgnosis.com/). Gnosis enables you to make predictions on all kinds of events.

IPFS

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: HitFin

Patrick Salami presents on HitFin (http://www.hitfin.com/), a bilateral trading and settlement platform for over-the-counter derivatives.

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: Metamask.io

Aeron Davis presents on Metamask, a bridge that connects the web of today with the web of tomorrow.

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.

Maker

Nikolai Mushegian presents on Maker (https://makerdao.com/), a contract system which creates and maintains the Dai Stablecoin.

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.

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.

Mix

An introduction to Ethereum's IDE Mix.

Shh! Whisper

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...

Registries

Niran Babalola of ConsenSys (https://consensys.net/) presents on Regis, a platform for building and deploying registries into the Ethereum network.

Slock.it

Ethereum's Christoph Jentzsch presents on Slock.it (http://slock.it/), an IoT/Blockchain company that allows users rent, sell or share anything!

Swarm

Ethereum's Dr. Daniel Nagy and Viktor Tron present on Swarm, the decentralised, incentivised file storage system.

Standardization

Vitalik Buterin, Dr. Gavin Wood, Fabian Vogelsteller, Nikolai Mushegian and Christian Lundkvist discuss standardisation in the Ethereum space.

Tokens

Simon de la Rouviere of ConsenSys presents on tokens and standards on the Ethereum blockchain.

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.

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.

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

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?"

Building Augur - Lessons Learned

Scott Bigelow discusses the experience building Augur, and the lessons they've learned.

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.

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!

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.

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.

Ethermint 2.0: Cosmos SDK + EVM

Chris Goes presents his talk on Ethermint 2.0: Cosmos SDK + EVM.

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 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.

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.

Enuma

Antoine Cote & Philippe Camacho from Enuma present their progress after receiving a Grant.

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.

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.

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.

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.

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.

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.

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.

PIET

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.

Status Changelog

Jarrad Hope from Status gives an update on their Changelog.

The State of Plasma

David Knott and Kelvin Fichter give an update on the state of Plasma.

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.

web3j 4.0

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.

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.

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.

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.

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.

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 [1], and invest the shielded money pool into a risk-free DeFi application to earn interest [2].  The mixer complies with Vitalik's interface proposal [3]. 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. [1] https://github.com/barryWhiteHat/miximus [2] https://zumzoom.github.io/analytics/uniswap/roi.html ETH-WETH pair [3] https://hackmd.io/@HWeNw8hNRimMm2m2GH56Cw/rJj9hEJTN?type=view [4] https://ipfs.io/ipfs/QmWYTeggKeL8xBitA8uQWAaNDWfFrUHXAxBXkvmnisdDw7 [5] https://eprint.iacr.org/2019/455.pdf

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.

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.

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

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.

Building a Formally-Verified DApp with the Reach DSL, today!

In this hands-on workshop, we introduce Reach, take participants on a walkthrough of an example program, and guide them through implementing a basic DApp on their own. Reach, a new domain-specific language for decentralized applications, provides automatic solutions to the key problems faced by blockchain developers: ensuring the smart contract is consistent with client-side software, verifying the DApp is trustworthy, and abstracting over different blockchains. We then take a guided tutorial consisting of an example Reach program that implements a formally-verified two-party wager DApp. We explain the structure of the ~50 line Reach program and the structure of the ~50 line JavaScript frontend, and take a deep dive into properties that Reach formally guarantees. Participants will then work through a series of exercises implementing a different DApp with a similar structure to the sample program. They will leave with concrete experience using Alacrity that will enable them to build their own DApp. Prerequisites: Experience programming in JavaScript, have Docker installed on their machines to install the image of the Reach compiler and demo. It is recommended participants download and install this image before the workshop at: https://bit.ly/ReachIsTotallyAwesome. Experience with formal verification or stating DApp properties is NOT required.

Building Mainstream-Ready dApps

Matt Slipper speaks about building mainstream-ready dApps.

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.

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).

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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/

ethers.js - A Complete, Simple and Tiny Ethereum Library in JavaScript

The ethers.js library provides a complete, easy-to-use JavaScript library for developers to create dapp frontends and backends, Ethereum frameworks, tools and wallets.It provides all the APIs and utilities needed to query and connect safely and securely (optionally infrastructure-free) to a variety of backends, create JavaScript objects representations of  smart contracts and their state, sign and manage transactions and format content for display logic and parse user input.This talk will quickly cover many of these features, provide examples of common tasks, and demonstrate a few less-obviously-dangerous, but easy-to-make mistakes  (with solutions).

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.

(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.

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.

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.

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 2 - What’s next for GSN

Liraz Siri speaks on what's next for the Gas Station Network.

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.

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.

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.

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.

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.

Janus Platform

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.

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. 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]

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 From Phase 0 Testnets

Preston Van Loon discusses lessons learned from Phase 0 testnets.

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.

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.

Mary Maller

Pair-based SNARKs?

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.

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.

Mapping finite state machines to zkSNARKs

Fabrizio Romano Genovese speaks about Mapping finite state machines to zkSNARKs.

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.

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.

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.

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.

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.

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 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.

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.

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.

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.

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.

Supersonic: Transparent SNARKs from DARK Compilers

Benedikt Bunz presents Supersonic: Transparent SNARKs from DARK Compilers.

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.

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 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 challenge of implementing Solidity stack traces

Debugging is an unavoidable phase of the software development cycle, and the most frustrating and productivity wasting part of developing smart contracts. The essential tools that a programmer would use to debug code manually in a mature platform are missing or unstable in Ethereum or are unstable. These are easy debug logging (e.g. console.log) and stack traces. In addition, smart contracts development presents extra challenges, like testing code and smart contract code being written in different programming languages. In this presentation, we'll shed some light on how stack traces work in other platforms and the challenges we had to solve for building them for Solidity in Buidler. These include identifying the code behind each contract address, identifying the functions in the stack, recognizing Solidity's compilation patterns to improve error messages, and how to display them from your JavaScript tests.

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.

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.

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.

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

Using DAOs to Make Decentralized Protocols Actually Decentralized

Luis Cuende gives his talk on Using DAOs to Make Decentralized Protocols Actually Decentralized.

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.

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!

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.

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.

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.

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.

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

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.

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.

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.

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 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.

Decentralizing Infura

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.

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.

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.

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: Cryptoeconomics

.

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

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-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.

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.

EVM Tracing in Geth

Geth comes with a variety of ways to analyze the execution of past and constructed transactions. In addition to the collection of built-in tracers, users can submit scripts in JavaScript or Go which hook to the EVM, receiving minute events such as "opcode executed" or "entered new call frame". In the workshop, the audience can follow along a summary of basic tracing, commonly faced problems, as well as an introduction to the more recently shipped features and how to write efficient tracers.

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.

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.

Geth Team AMA

.

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.

Herodotus Workshop

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.

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.

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 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.

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

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

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.

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.

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.

Little-known Web3.py

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.

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.

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.

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.

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.

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.

Remix Rewards

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.

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-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.

Skiff

.

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.

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.

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 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.

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.

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

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 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

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

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.

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.

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

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

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.

Dapple Dev Workflow

Learn how to explore, develop, test, integrate and maintain your dapps with the Dapple dev toolchain.

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.

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.

Formal Verification for Solidity

Christian Reitwiessner & Yoichi Hirai speak on Formal Verification for Solidity.

Formal Verification of Smart Contracts

Yoichi Hirai gives their talk on Formal Verification of Smart Contracts.

Going From Analogue to Digital wth Otonomous

The Future of Digital Assets and Exchanges on the Blockchain

How to Develop Advanced DApps Using Embark

Introducing Embark 2.0; What’s new, and how to develop & test advanced DApps

Imandra Contracts Formal Verification for Ethereum

A presentation covering Imandra Contracts, Aesthetic Integration’s cloud-based formal verification system for Ethereum.

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.

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.

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.

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.

Making the EVM Scream

How I got the EVM interpreter from where it was to where it will be in the future.

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.

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.

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.

Mist Vision and Demo UPDATED

Alex Van de Sande reviews Mist's vision and previews a demo.

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.

Parity's Innovations

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.

Parity’s Launch

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.

Prove It – Blockchain based KYC

Igor Lillic reviews blockchain-based KYC processes.

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.

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.

Smart Contracts in Java

David Roon gives his talk on Smart Contracts in Java.

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.

Solidity for Dummies

We will explore the basics of the Solidity contract language using examples.

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.

Testing Ethereum Consensus

Ethereum tests overview and integration instructions for client developers.

The Browser-Solidity IDE

Christian Reitwiessner gives his talk on the Browser-Solidity IDE.

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

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 Raiden Network

Lefteris Karapetsas gives his talk on the Raiden Network.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Casper the Friendly GHOST: A correct-by-construction blockchain

Vlad Zamfir presents their talk titled, "Casper the Friendly GHOST: A correct-by-construction blockchain"

DappHub

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.

Dapp Development using Remix, Mist, and Geth

Yann Levreau and Rob Stupay give their talk titled, "Dapp Development using Remix, Mist, and Geth"

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.

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.

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.

Designing IoT Frameworks Using Ethereum

Shuang Liang & John Gerryts give their talk titled, "Designing IoT Frameworks Using Ethereum"

Developers, Developers, Developers – Ethereum for all your networks!

Péter Szilágyi gives their talk titled, "Developers, Developers, Developers – Ethereum for all your networks!"

Development Frameworks

Andy Milenius, Conor Svensson, Yann Levreau, Jack Peterson, Piper Merriam, Nick Dodson, & Iuri Matias discuss Development Frameworks.

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.

Ethereum Protocol Testing

Dimitry Khokhlov gives their talk titled, "Ethereum Protocol Testing"

ERC Identity

Fabian Vogelsteller (author of ERC20) will be talking about his new work on standard functions for a unique identity for humans and machines.

EthJS: Precision Ethereum Javascript Architecture for dApps

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.

EVM-C: Portable API for Ethereum Virtual Machines

Pawel Bylica gives their talk titled, "EVM-C: Portable API for Ethereum Virtual Machines"

Evolving devp2p

Felix Lange gives their talk titled, "Evolving devp2p"

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.

Formal Verification

Phil Daian, Everett Hildenbrandt, Yoichi Hirai, Loi Luu, & Reto Trinkler discuss Formal Verification.

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.

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.

Intro to Casper Implementation

Chang-Wu Chen gives their talk titled, "Intro to Casper Implementation"

Intro to Solidity 2017 Edition

Hudson Jameson gives their talk titled, "Intro to Solidity 2017 Edition"

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.

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.

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.

Introducing Rholang!

A correct-by-construction concurrent smart contracting language. We give a basic introduction and show a translation of ERC 20 token contract into Rholang.

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.

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.

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.

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.

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.

MetaMask: Dissecting the fox

Aaron Davis and Frankie Pangilinan give their talk titled, "MetaMask: Dissecting the fox"

Methods for deterministic parallelizing message processing

Martin Becze gives their talk on methods for deterministic parallelizing message processing.

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.

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.

Oyente: Development update

Oyente: An Analysis Tool for Smart Contracts. https://github.com/melonproject/oyente

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.

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.

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.

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.

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.

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.

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.

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.

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

Show and Tell

Virgil Griffith gives their talk titled, "Show and Tell"

Sikorka – Proof of Presence for Blockchain Applications

Sikorka – Proof of Presence for Blockchain Applications

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.

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.

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.

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.

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.

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.

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”.

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.

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.

Towards a Permanent ENS Registrar

Nick Johnson gives their talk titled, "Towards a Permanent ENS Registrar"

USCC – The Underhanded Solidity Coding Contest

João Gabriel Carvalho, Richard Moore, Martin Swende, Nick Johnson discuss USCC – The Underhanded Solidity Coding Contest

Web3.js 1.0

Fabian Vogelsteller gives their talk titled, "Web3.js 1.0"

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.

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.