One-day event for ZKP researchers, hackers, and builders. Learn about zero-knowledge proofs through laser-focussed lectures.
zkBeginner
zkTech
zkMath
Schedule
29 Aug 2023
Registration
Coffee and breakfast will be waiting for you - to get your day started!
                                        
                                            
                                        
                                        
                                            Key derivation in StarkEx
                                        
                                    
                                    Because StarkEx uses the Stark curve for cryptography, regular Ethereum ECDSA no longer works. We'll dive deep into how StarkWare and its clients solved this problem in StarkEx deployments.
                                        
                                            
                                        
                                        
                                            ZK and law for devs
                                        
                                    
                                    I will highlight the legal challenges of using ZK tech by devs. Privacy, scalability, security, and data integrity achieved with ZK proofs will generate legal conundrums that should be well understood before implementing particular solutions.
                                        
                                            
                                        
                                        
                                            ZKM: Turning Ethereum into the
                                            global settlement layer
                                        
                                    
                                    Presenting our zkVM and its potential role in making Ethereum the global settlement layer. What does it mean for Ethereum to be the global settlement layer?
Break
                                        
                                            
                                        
                                        
                                            Storage proofs
                                        
                                    
                                    How validity proofs combined with storage proofs unlock the true power of onchain vms.
                                        
                                            
                                        
                                        
                                            Putting the "Proofs" in "ZK Proofs":
                                            Formal verification of arithmetic
                                            circuits
                                        
                                    
                                    Writing arithmetic circuits for ZK proofs poses unique challenges for ensuring correctness. The style of building them is foreign to many developers, both in program structure and data representation. At the same time, their correctness is paramount to the security of many protocols. This talk will present some applications of formal verification tools for improving security of arithmetic circuits.
                                        
                                            
                                        
                                        
                                            ZK: Scaling ETH "infinitely" without
                                            UX & liquidity fragmentation
                                        
                                    
                                    By harnessing ZK, common bridges, shared sequencers & other cutting edge advancements, we can scale Ethereum using L2s & L3s while maintaining atomic composability and user experience, and avoiding fragmenting liquidity. Join us as we unlock the potential of Ethereum and reshape the blockchain landscape.
                                        
                                            
                                        
                                        
                                            Running Linux in ZK
                                        
                                    
                                    Presenting the work around running 64-bit RISC-V Linux inside a deterministic Cartesi Machine inside RiscZero proofs.
Lunch break
                                        
                                            
                                        
                                        
                                            Recent advances in pairing-based
                                            SNARKs
                                        
                                    
                                    We explain ideas from the past year and a half leveraging pairings to speed up SNARK provers; especially in the context of lookup protocols.
                                        
                                            
                                        
                                        
                                            Tip5: A hash function optimized for
                                            recursive STARKs
                                        
                                    
                                    In the context of recursive STARKs, standard hash function such as SHA3 and Blake3 are too expensive to arithmetize; and arithmetization-friendly hash functions like Rescue and Poseidon are too slow when evaluated on a CPU. Tip5 occupies the golden middle: it is somewhat arithmetization-friendly, but its design and performance are nonetheless more similar to standard hash functions than arithmetization-friendly ones.
                                        
                                            
                                        
                                        
                                            Halo2 applied to Ethereum ZK Rollup
                                            Equivalence
                                        
                                    
                                    Learn about zero knowledge rollup and Halo2 development.
                                        
                                            
                                        
                                        
                                            Zero-knowledge proof-based onchain
                                            private voting
                                        
                                    
                                    We describe an approach to onchain NFT-based private voting leveraging ZK-verified storage proofs. This is joint work with Aztec as part of Nouns DAO's private voting research sprint.
Break
                                        
                                            
                                        
                                        
                                            Evmmax: EVM modular arithmetic
                                            extension implemented in evmone
                                        
                                    
                                    This EIP proposes the addition of new optimized modular addition, subtraction and multiplication opcodes to the EVM. These support odd moduli up to 4096 bits in size. We will talk about the initial implementation of evmmax in the evmone.
                                        
                                            
                                        
                                        
                                            A deep dive into zkML
                                        
                                    
                                    Exploring the zkML landscape: Learn what approches, tools and applications are currently prevalent in the space and what challenges they are facing.
                                        
                                            
                                        
                                        
                                            Parallelizing proving in rollups
                                        
                                    
                                    In zero-knowledge rollups, Provers perform a vital role of computing the validity proofs responsible for enforcing the correctness of the zkRU. However, since proof generation times are non-negligible, sequential proving results in limited throughput of the protocol. Parallelization solves the aforementioned issue by assigning different Provers with the right to compute the proofs in parallel. The talk will outline the rationale behind parallelization as well as the concrete details of how parallelization will work in practice.
                                        
                                            
                                        
                                        
                                            Powdr: A modular stack for zkVMs
                                        
                                    
                                    We present powdr, an open source development stack for zkVMs. We go through some examples of VMs implementations in powdr and showcase the flexibility and performance of the framework as well as upcoming features.