██ Applied ZK in Kusama                                                                          
                                                                                                          
         ▓▓▓ Hacking OpenGov for privacy                                                                  
                                                                                                          
         Let's explore ZK applied to our favorite Kusama feature, governance!                             
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                   1 / 15 
                                                                                                          
                                                                                                          
                                                                                                          
                                             About Me                                             
                                                                                                          
                                                                                                          
                                                                                                          
         Founder of Virto                                                                                 
                                                                                                          
                                                    Passionate about:                                     
                                                                                                          
                                                       •  🐦 Kusama                                        
                                                       •  🔓 Open Source                                   
                                                       •  🔒 Privacy                                       
                                                       •  🌐 Decentralization                              
                                                       •  🦀 Rust                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                   2 / 15 
                                                                                                          
                                                                                                          
                                                                                                          
                                          About Virto                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
         "Web3 CTO as a Service"                                                                        
                                                                                                          
         We are the tech ally of founders who want to get into Web3 but don't know how.                   
                                                                                                          
         Our focus: Kusama as a simple to integrate Web2-like backend with all the tools founders         
         need for their project to succeed.                                                               
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                   3 / 15 
                                                                                                          
                                                                                                          
                                                                                                          
                                          The Problem                                          
                                                                                                          
                                                                                                          
                                                                                                          
         ▒▒▒▒ Real organizations need privacy                                                             
                                                                                                          
         Current OpenGov:                                                                                 
                                                                                                          
            •  All votes are public and                                                                   
               traceable                                                                                  
            •  Membership is always visible                                                               
            •  Voters can be coerced                                                                      
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                   4 / 15 
                                                                                                          
                                                                                                          
                                                                                                          
                               OpenGov Quick Overview                               
                                                                                                          
                                                                                                          
                                                                                                          
         ▓▓▓ Understanding the foundation                                                                 
                                                                                                          
                                                             Key components:                              
                                                                                                          
                                                             Referenda: Manages polls and           
                                                                   lifecycle                              
                                                             Tracks: Different governance           
                                                                   paths                                  
                                                             Voting Pallets: Implement who          
                                                                   votes, on what, with what              
                                                                   weight                                 
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                   5 / 15 
                                                                                                          
                                                                                                          
                                                                                                          
                                   Communities Pallet                                   
                                                                                                          
                                                                                                          
                                                                                                          
         ▓▓▓ Our gateway to privacy                                                                       
                                                                                                          
         Current state:                                  Perfect for privacy because:                     
                                                                                                          
            •  Permissionless creation of DAOs              •  Flexible membership model                  
            •  NFT-based membership                         •  Extensible voting mechanics                
            •  Public voting                                                                              
            •  Open vote counting                                                                         
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                   6 / 15 
                                                                                                          
                                                                                                          
                                                                                                          
                                       Privacy Levels                                       
                                                                                                          
                                                                                                          
                                                                                                          
         ▓▓▓ Different needs, different solutions                                                         
                                                                                                          
         Level │ Membership │ Vote    │ Count     │ Use Case                                              
         ──────┼────────────┼─────────┼───────────┼─────────────────                                      
         0     │ Public     │ Public  │ Public    │ Current OpenGov                                       
         1     │ Public     │ Private │ Public    │ Board decisions                                       
         2     │ Private    │ Public  │ Public    │ Voter protection                                      
         3     │ Private    │ Private │ Encrypted │ Maximum privacy                                       
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                   7 / 15 
                                                                                                          
                                                                                                          
                                                                                                          
                            Level 1: Anonymous Voting                            
                                                                                                          
                                                                                                          
                                                                                                          
         ▓▓▓ Public membership, private votes                                                             
                                                                                                          
         How it works:                                   Circuit proves: "I am a member and cast          
                                                         this vote"                                       
            1. Member generates ZK proof of                                                               
               membership                                                                                 
            2. Submits vote with proof                                                                    
            3. Public counting proceeds                                                                   
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                   8 / 15 
                                                                                                          
                                                                                                          
                                                                                                          
                           Level 2: Hidden Membership                           
                                                                                                          
                                                                                                          
                                                                                                          
         ▓▓▓ Private membership, open counting                                                            
                                                                                                          
         Key innovation:                                 Circuit proves: "Voting happed                   
                                                         off-chain, here's the vote"                      
            •  ZK-friendly merkle tree of DAO                                                             
               members kept off-chain                                                                     
            •  Member can proof she can vote with                                                         
               the given conviction                                                                       
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                   9 / 15 
                                                                                                          
                                                                                                          
                                                                                                          
                          Level 3: Encrypted Counting                          
                                                                                                          
                                                                                                          
                                                                                                          
         ▓▓▓ Maximum privacy with homomorphic encryption                                                  
                                                                                                          
         Homomorphic counting:                           Perfect combination:                             
                                                                                                          
            •  Votes encrypted with HE scheme               •  ZK: Proves valid encrypted vote            
            •  Tallying on encrypted values                 •  HE: Enables private counting               
            •  Decrypt only final result                                                                  
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                  10 / 15 
                                                                                                          
                                                                                                          
                                                                                                          
                                  Anonymous Proposals                                  
                                                                                                          
                                                                                                          
                                                                                                          
         ▓▓▓ Using pallet-pass for ZK dispatching                                                         
                                                                                                          
         Process:                                                                                         
                                                                                                          
            1. Generate ZK membership proof                                                               
            2. Validate transaction comes from a                                                          
               DAO member                                                                                 
            3. Submit referendum from community                                                           
               origin                                                                                     
            4. Proposal appears without                                                                   
               attribution                                                                                
                                                                                                          
                                                                                                          
                                                                                                          
                                                                                                  11 / 15 
                                                                                                          
                                                                                                          
                                                                                                          
                              Virto's Developer Tools                              
                                                                                                          
                                                                                                          
                                                                                                          
         ▓▓▓ Making ZK accessible                                                                         
                                                                                                          
         The challenge:                                                                                   
                                                           #[zink::circuit]                               
            •  Circuit development is complex              mod membership_proof {                         
            •  Unfamiliar syntax for Substrate                 #[message]                                 
               devs                                            fn verify_member(                          
            •  High learning curve                                 &self,                                 
                                                                   #[private] member_id: Field,           
         Our solution:                                             #[private] path: [Field; 8],           
                                                               ) -> bool {                                
            •  ink!-like DSL for circuits                          merkle_verify(                         
            •  Familiar contract syntax                                member_id,                         
            •  Seamless pallet integration                             path,                              
                                                                       self.merkle_root           12 / 15 
                                                                   )                                      
                                                                                                          
                                                                                                          
                               Implementation Roadmap                               
                                                                                                          
                                                                                                          
                                                                                                          
         ▓▓▓ From concept to reality                                                                      
                                                                                                          
         Phase 0: Developer Tools                        Phase 2: Private Voting                          
                                                                                                          
            •  ink!-like DSL                                •  Vote commitments & reveals                 
            •  Integration tooling                          •  Level 1 privacy                            
                                                                                                          
         Phase 1: Foundation                             Phase 3: Advanced Privacy                        
                                                                                                          
            •  Extend communities pallet                    •  Homomorphic encryption                     
            •  Basic ZK membership proofs                   •  Levels 2 & 3 privacy                       
            •  Anonymous proposals                                                                        
                                                                                                          
                                                                                                          
                                                                                                  13 / 15 
                                                                                                          
                                                                                                          
                                                                                                          
                              Real-World Applications                              
                                                                                                          
                                                                                                          
                                                                                                          
         ▓▓▓ Who needs private governance?                                                                
                                                                                                          
         Corporate Governance:                                                                            
                                                                                                          
            •  Board vote confidentiality                                                                 
            •  Shareholder privacy                                                                        
            •  IP protection                                                                              
                                                                                                          
         DAOs & Communities:                                                                              
                                                                                                          
            •  Anonymous whistleblowing                                                                   
            •  Sensitive discussions                                                                      
            •  Anti-coercion protection                                                                   
                                                                                                          
         Public Institutions:                                                                     14 / 15 
                                                                                                          
                                                                                                          
                                                                                                          
                           Let's Brainstorm Together!                           
                                                                                                          
                                                                                                          
                                                                                                          
         ▓▓▓ How can we make Kusama governance private?                                                   
                                                                                                          
         Discussion topics:                              Your ideas are welcome:                          
                                                                                                          
            •  What privacy features matter most?           •  Novel privacy mechanisms                   
            •  Which use cases should we                    •  Integration approaches                     
               prioritize?                                  •  User experience improvements               
            •  How do we balance privacy with               •  Governance model innovations               
               transparency?                                                                              
            •  What developer tools would help                                                            
               adoption?                                                                                  
                                                                                                          
                                                                                                          
         Let's hack governance together!                                                                  
                                                                                                  15 / 15 
         Connect: