Welcome to Eth to E to E to E to E. Hello everyone, my name is Bian Placencia and I'm a software engineer in the privacy and scaling aspirations team at the the foundation and today I'm going to talk about scaling semaphore. So let's start with what is semaphore. Semaur is a set knowledge protocol that allows users to prove their membership in a group and send messages such as votes or feedback without revealing the their identity. This means that the messages has are not linked to the identities and semaphore also provides a mechanism to prevent double signaling which means that you cannot successfully verify the same proof twice.
Sema for works offsh and on EVM compatible chains and right now it also works on rust. So yeah there are some use cases for semaphore and I'm going to mention a few of them. So there is supas the supas project it was used at defcon. It was used for ticketing for the event and also the word project which is for proof of anonymous proof of that you are a real human and also paywise which is a project for anonymous voting. Here is a link to a list of projects other projects using semaphore so you can check them out.
The first comet for SEO was in 2019 and the first release was in 2020 and after that there has been a new release almost every year and the last release was version 4 in 2024 and that's the current one we have now. Sema for version 4 introduces two new main features. One is related to the identity schema and the other is related to the new Merkel tree which is called LIN incremental Merkel tree which is an optimized incremental mer tree. The semo for identity is a andsa public private key pair and also a commitment. Now with the these identities you can generate signature which which is generate and verify signature which is great right before people used to use CKP.
So now you can do it out of the box. The lin incremental maker tree is the new data structure we are using for the group operations and this is an improvement over the incremental tree that was used in version three and this has two main improvements over the incremental tree used before. there are not zero hashes no more zero hashes it this means that before if you had if there were let's say three members in the tree you there will there we will create the zero hash for the four members so that the parent hash can be created so now this is not needed anymore since right now what is done is that the parent will have the same value as the as the child if we don't we won't create a new one to create the parent hash. And also the the depth is dynamic now which means that before with the incremental macro tree you needed to add a static depth and let's say 20 or 30 now it will grow over time. So it's dynamic.
So it depends on the number of members will be the depths and if there are more more members the the depths will increase but dynamically you you don't need to do it to do it since the beginning. There is actually a paper about it. You can go to the CK repo and read the paper. There are benchmarks. You can see like the algorithms there are sele codes and everything.
So please check them out if if you are really interested in that. And this is an example of an incremental tree and a incremental maker tree. As you can see the incremental tree will always will always have a power of two number of elements because of the zero hashes. It doesn't matter if you have three, four, five members. You will always have a power of two elements.
And that's not the case for the incremental tree because it depends on the number of members and there are no more zero hashes. Here here is a QR code with all the information related to the semiforese research. all the data structures we we were considering and everything related to EDSA why we decided these things and everything. So go check check it out if you are interested in this part. In the semur documentation there are some benchmarks for version three and version four.
And in general as a summary version four performs better than version three. I'm going to talk about scaling semaphore for mass adoption now and right now semaphore is stable. It was audited and it has always been audited and it works well. It was used at defcon and a lot of applications use it. But for thousand of user is fine.
It will work on browser but with million of users you will need to use the server because the browser won't be able to fetch all the members and recreate the tree and generate the proof because the tree will be big and then your UI will become unresponsive if you do that. So a possible solution could be web workers but it's still not a good user experience. So that's why we have been working on this because since it's stable now we can focus on mass adoption because it works. There are some key challenges for mass adoption when we were considering this and one was the lack of crossplatform support. For example, there was no support on native mobile, Staret, Stellar or Cardano on other ecosystems.
And another was we all that we always want to make sure that proof generation and verification are as fast as possible. So, so we were also we have been also doing some things in this for this point. And another thing is that to generate the proof you need the mer proof and in the UI it was almost not possible because as I was saying for millions of members you need to fetch all the members and then gener recreate the group and it was not possible because it's the user the the UI and I'm going uh also talk about what we have been doing for this. First we created the SEMA foration 4 specification document. We created this so that people can developers can easily implement SEMA for on other ecosystems and they can also better understand the project and you can check check it out here in this QR code also.
So we implemented semma for rust. The idea was to support native mobile and now it's you can generate and verify semaphore proofs with frost and also it's supported in mobiles and now the semaphore proofs are interoperable across JavaScript solidity ROS and native mobile. This was a collaboration with PSC research and mopro teams to create this implementation. There is also an ongoing research and development to optimize sema for regarding proof generation and verification using NOR and this is a collaboration with Aztec and is being implemented by the hashcl team. There are some interesting benchmark you can check them out in this QR code in this link and they have been opt optimizing the code and they are also have been doing some research implementation with recursive proofs.
So I'm very excited about the results. So I will be talking about it when we have more results. There is a also an ongoing research and development for to benchmark private information retrieval to have faster client side Merkel proof generation and this is a collaboration with the PSC research team. So there are some benchmarks now and you can check more information about this in this QR code and I will be talking about more benchmarks in the future when we have more benchmark but there are already interesting benchmarks so far. You can learn more about semaphore on the website documentation.
You can also go to Telegram to ask questions or join the disc discussions there and check the GitHub. Thank you very much and this is all my information. Thank you. [Applause]
Automatic transcript — names and jargon may be misspelled.
