██ 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:                                                                            
                                                                                                         
            •  Judicial decisions                                                                        
            •  Academic peer review                                                                      
            •  Grant allocations                                                                 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!                                                                 
                                                                                                         
         Connect:                                                                                        
                                                                                                         
         📧 daniel@virto.team                                                                             
         💬 @olanod:virto.community                                                               15 / 15