Session 6 - Semaphore Protocol

Transcript

My name is Via Proencia and I'm a software engineer in PSC at the the Foundation and today we're going to talk about privacy with Sema for this is the structure of the presentation. We are going to start with what is Sema for. Then we are going to talk about some use cases. We are going to talk about the sema for text stack the architecture of CK applications and protocols and also some sema for the main sema for core concepts and we are going to talk about the circumc circuit diagram of semaphore, how to use it and how to use semaphore and also the architecture of a an application using semaphore.

Let's start with what is semaphore. Semaphore is a ser knowledge protocol that allows users to prove their membership in a group and send messages such as vows or feedback without revealing their identity. This means that messages are not attached to identities. This mean that they they have no link and semaphore also provide a simple mechanism to prevent double signaling and it works offsh and on EVM compatible chain. So you can use semaphore offchain on a web two application on is also compatible with any EVM compatible chain.

These are some use cases. See can be used for anonymous feedback, anonymous voting or anything related to anything anonymously that you want to do inside a group. And some example of projects there is a link to all the projects here but some examples are the supas project that we are going to use at defconet and we use it before and defcon and it's a ticketing platform and also the work project is for pro anonymous proof of personhood and also the perise project which is for anonymous voting.

This is the sema for text tag. There are some circuits with cirere and the smart contrast are with solidity and also the front end with javascript typescript and the pro system that we are currently using is crossing and you can get that by with circom and snarjs. you will you will be able to to have it. This is the flow of a CK application. All the C application will have a similar flow. The user will interact with the front end the user interface the application and we'll generate the proof there. The CK proofs are should al

always be generated in the user's device in the browser in the browser or mobile and then the user interface is going to talk to the smart contracts or the web to back end to verify these proofs. So that should be the right way to do it. The proof should always be generated in the front end in the user interface and verify it in in the back end and or the smart contracts. Here we are going to talk about the architecture of CK applications using circum andjs.

So first we have the circuits. We have the circuits here and with the circuits and using the circum compiler we can get the wasome file which we will use it after in the front end and then using scenarios you can install it globally in your your computer and using scenarios you can get the ck file and then also generate the solidity verifier. Then we are going to use the wasm file and the ck file to generate the proof using snarjs in the front end. This should always be in the front end to keep privacy and anonymity. And then you will use the so verifier to verify the

proofing the smart contracts. So this is the architecture of any CK application using circumst. So it's the same for all of them. All of them should have this under the hood even if you see it or not. So the architecture will be the same and actually similar to tunar you will study that later but it's very similar to it won't have the was ck file but it will have a JSON file to represent the circuit and then it's very similar.

These are the semaphore core concepts. In semaphore we have identity, group and proof. The identities are in the DSA. I will talk a bit about it now. And then groups are created with linenc which is the binary m tree and incremental make tree we are using we created for semi version 4 and the proof which is created with cirjs and also grow system as proving system and that's the ck part.

So the ck part is in this package in this part of the concept in the protocol. You can read more about this this topic and more in depth in the in this link. This is the SEMA for version 4 specification. The SEMA for version 4 identity consists of any DSA public private key pair and a commitment. So you can create and verify signatures out of the box. So you will have the private key and then a public key and a commitment. So you will you will use the your public for for people your what you

will use more is your commitment because that's the public value and that's what we will add to the group. So the public key is for you to know that exists and is still public but your identity publicly will al always be your commitment and you can find more about it in the documentation the seer documentation the identities section. The identities can be created this way in the front end. For example, you can it should be in the front end because the user will have their private key and all the the the private data. So it should be in the browser on the their mobile and you import the sema for protocol identity package and you

generate the identity this way. This way is to create the random identity. So there is no value in the in the constructor store. And then if you want to create the deterministic identity to generate the same the same every time with the from a secret value, you can create it this way. And and then to export it, you can export it using the export function. And then you can also import it this way to use the same identity after to save it somewhere and then import it from there. So you see it again the groups. So the groups are like

anonymity sets. They are binary merries in which the leaves are the identity commitments. And groups are to represent a group of people for example. But there are some other applications with group. Groups can be credentials or something different. But most of the time groups are people with their identity commitments and groups can be created offshine with the JavaScript library or onchain with the sema for contracts. So with the JavaScript library is this way this side and you import the package and then you create the group this way. You add a

commitment to the group and that will add a lead to the tree because what is happening under the hood in the groups is a binary mer tree specifically which is an incremental optimized incremental mer tree and then you can remove a member this way. You can add the index and then remove that member at that specific index and also update the member and you add the index and also the one the member the identity command you want to update the new one.

And in the contracts you import the semif contracts library and then you can just use the interface and import it in the constructor and then create the group a group this way call it this way and you can call all the other functions the same way. The lin is the data structure for group operations that semifor version 4 which is the latest semifor version is using and this lina is an improvement over the incremental tree that we were using in version three. So we were using a normal incremental tree which is a merkel tree

that you can add remove elements in an efficient way. So we created the Lina MT for this latest version to have a better performance and the key improvements of the Lina MT over the incremental tree are that there are no more serashes. So if you have studied a bit about the incremental tree and you will know that and also the mer tree you will know that there are some zero hashes. So when you need to create a parent of a leaf and then you don't have a sibling to hash it with so that you

can create the parent then you will create a zero hash a zero hash to represent that there is nothing there and then you will create the parent this way. So in line empty that's no longer needed since right now what we do is that we send the the same leave to the parents and then that's what we did so that we don't have more space in unnecessary space and it's actually more efficient too because you don't need to calculate the hash that hash and also it supports dynamic depths now because before you will create the incremental tree with specific tree depths and you will say okay my tree depth is 10 and now with Lina MT you don't need to do that you can your tree

will grow over the time while you add more members to the tree so you can find the paper here in the CK kit or organization like org like the website of c kit you can find the paper the n empty paper there this is the way this is a representation of incremental tree and also the lin. And as you can see here, the incremental tree, the number of lift will always be a power like a power of two elements because you need to hash all of them to create the parent hash. And so you will always have a power of two elements even

if you have zero hashes. And with LINT, this is different. You don't need to have a power of two elements with zero hashes. You just do what I was talking about before. You just for example in this case you just send the same value to the parent and then you hash when it's necessary when you have a sibling to hash and that's more optimizing in terms of performance and space too. Those were the groups and there there's also the CK proof part because after creating your identity and joining a group users can anonymously prove that they are members of that group and also send messages and these messages can be both feedback or any other text message.

And to generate the value proof we also need the scope and this scope can be used to prevent double signaling which means that your message or your cate proof won't be verified successfully twice. That's what double signaling means. So with the same scope you will prevent double signaling and with different scope you will have multiple signaling. So you will be able with if you send different scope you will be able scope is like a number or an identifier for the proof. If you send a different one then you will get you will be able to have multiple signaling and I'm going to when I explain the

circuit part you will you will see why. So first with the concept and then you will see why this happens and how you can learn more about the proofs in the documentation too. the proofs section the CK proof can be generated offchain with the JavaScript library and then they can be verified both onchain and offchain so in JavaScript you can just import the package and then this is the scope let's say in this case we are using the root so that we that's the identifier of the proof and then this is the message and this is the

way to generate the proof. You just call the generate proof function and you send you add the parameters and then you can verify the proof this way just passing the proof and then this will return true or false whether it was successfully verifier verified or not. And also in the contrast you can validate the proof too. In this case in the contrast there are two functions one to verify the proof which which will just verify the proof say if it's true or false but then there is also a validate proof function that will save the nullifier which is another concept we will talk about during the circuit explanation and it will do something else for the to

prevent double signaling. So this this why it's called very validate proof in the in the contracts and then you can just call call it this way just validate proof you send the group ID the ID of the group and then the proof let's talk about the sema for circumc circuit the diagram this is the the c the circumc values and then we will this is the

circuit to generate the mer proof this is this can be seen as the proof of membership. So using the mer proof of the merke proof of membership you can generate the root calculating the index you can think of this as the when you have the list of indices we will do that in the circuit. So you can see that you can think of it like there is a list of index indices but in real life it's just one value and then using this indices and the siblings you can calculate and the length you can calculate the the mer fruit and then you

will have it here that's a public value because we want to check it after in the contrast or in the back end and also there is this secret private value and uh the secret is not exactly the private key. This is part of the identity. This is not exactly the private key. This is generated from the private key, but it's still a secret value. So it should be secret. That's why it's private. And then with this secret value, we with baby dip tube, we generate the public key. And then this public key this is a point two values and then we hash them and we generate the identity commitment.

Then then and then this identity commitment which is your public identifier we will use it to calculate the maker fruit with the siblings and the indices. And there is also this public value the scope and the scope is the one that we will use to prevent double signaling and the secret with the scope we will hash it using posidon. Poseidon is used in the circuits in most of the CK circuits you will see if they will use posidon because it's more efficient in circuits.

So that's why because it's a CK friendly hash hash function and then we hash these two values and then we get the nullifier and the nullifier is what what is used in the contracts for example or in the back end if you have a web two application is what is used to prevent the double signaling. So if you send a proof with the same nullifier that's why it's public because you need to check it. If you send a proof with the same nullifier, it means that you already if if your nullifier is safe in the contract that there was a successful verify proof with that and you send a proof with the same notifier, you should be if you able to to verify it because it's like you already sent a proof and

it was verified. So you shouldn't try to verify it again. And and then there is also this constraint here which is the message said dummy with the message dummy square. This is actually needed in circum but in you wouldn't need that. So in actually the circuit the architecture is exactly the same. There is a semifor implementation and is exactly the same except this dummy square because that's not needed and what that we needed because when you send it's actually message is actually a public input signal. When you have an input signal, if you don't in the

circuit, then the circum compiler will optimize your circuit and then it won't create a constraint with that. Then if if we don't create this dummy square, people will be able to generate to send different messages with the same proof. So and then you won't be able to verify that this message is a task to that proof. So that's why this is needed in circum and in this is not needed because nor will we always hash will always create a constraint for the for the input. So that's why it's not needed but in circum is always needed. If you have an input and you don't use it you should create this dummy square. So this is the the architecture of the circuit. This is

semaphore protocol in circuits just that. So to start using semaphore you have three ways three main ways you can use the CLI the boiler plate or you can also install the packages manually. So when you use this methods, this means that you won't need to to do anything with CK related to Case or anything related to the artifacts. So you won't need to do anything because you will have everything under the hood.

So you will only you will only do what what I show before like importing the packages and just using the functions. So everything is abstracted. When you use the CLI, you can create a new project this way. You can just use npx and call this and in this case it will create a a full full app with ethers and then you can also install the CLI globally and create the project this way. And there are different templates. There is one with for just contrast with hard hot and one for

full app with ethers and full app with the subgraph protocol and then there is one for contrast foundry and there will be more in the future and the CLA can also be used to fetch group data. If you want to know about a specific group some you want to know some information you can just for example use sema for get group in sepoleia let's see which groups exist there and things like that there are a lot of different things you can query there using the CLI here is the way you can access the CLA more documentation here there is also the boil plate which you

can fork or you see as template here. There is a button here to use it as template and create one from scratch and you can check the live app here. This the live demo and you can check it out to see the flow of an application. You can also install the packages manually and you can find all the packages here in the main repo and you just import install them and import the packages and use the the package directly without boiler plate or template.

I'm going to explain now the architecture of SM for application. So this is how you should build SM for application if it's onchain or offchain. I'm going to explain onchain which is with contract solidity and and also I'm going to explain offchain which is with web tool in a back end like NodeJS for example. So this is the architecture of a decentralized application using SEMA 4.

You will have your contracts and then you will import the contracts package of SEM for with the contracts and this contract will emit blocks that you will read to do some things in the front end. So this is the contracts part and then you also have the offchain part because that's the onchain part. Then you have the offchain part and in the offchain part you have the front end and also something to send transactions which can be a re layer or a back end that you create for the transactions.

And why we need that? Because we don't want to link Ethereum addresses to the identities and the proofs. So I mean we don't want to link the Ethereum addresses with the transactions to the CK proofs that the user created because we will know that this user this Ethereum address created this proof. So this guy proof. So we want to use a re layer a re layer or also a back end that's also fine. You can create your own back end. Then in the front end you will use the identity package because you should always create your identity in your device and and then you will use the group package because every time you generate the proof a CK proof you need

to recreate the group in the front end so that you can calculate your mer proof and create the CK proof because as we saw in the circuit we need the mer proof so that we can create the root. So then we need the group package to create the group and regenerate the group and how we are going to get the identity commitments using the logs. We fetch that. There is a package to make it easier like a a package with ethers and another with a subgraph. So you will just fetch that data and generate the regenerate the group in the front end and then use that to create the with the proof package to create the CK proof.

And then this data package is what we use to interact with the contracts to fetch data from from the contracts. And that's the architecture of the central application. So no circuit here. No, you don't need to take care of that CK artifact or CK part. And similarly the offchain architecture is like you will have the same things in the front end but instead of fetching data from the from the contrast you will just ask the back end because you will have all the data in a back end and web to server and then in the back end you

will just you will do all the group operations to add members and do everything and then this proof package in the back end is to verify the proof because you can verify the proof onchain or offchain and then in this case this proof package is to generate the proof and here is to verify it and there is the database to save the data. So in contrast we save it the contract but then in web two we need a database to to save the data that will interact with the back end. So this will be the way for a web two application.

You can learn more about SEMA 4 in the main GitHub repository like the in the organization in general and also in the documentation and you can also join the telegram chat and ask any question and here is the website you can check it out and see projects and past presentations and things like that more information. So thank you Thank you very much. Do we have any questions?

I think that that was super clear. Thank you very much. I may have one question on the group because I thought at the beginning the group was like a group of people but it's actually like one person have one group or multiple people can share the same group. >> One no a group is the the group will have multiple people. Yeah. And actually you shouldn't have a group of one person because there won't be anonymity there.

It's just one person. Actually, the group should have as many people as possible so that the anonymity set is bigger and is more difficult to identify things >> and people are assigned randomly to a group or you can choose which group you can >> for example. Yeah, you can create the group as you prefer. It's very open for people to adapt it to their application. For example, one easy example is that in this meeting we have many people and then we can create a group of people that are in this meeting and then you will all send me your identity commitment from the sem identity and then I will add this all this identity commitment to a group and this way we

can for example send feedback about the presentation and say okay I would prefer this I like this and and this way that's a simple That's actually the boiler plate is a feedback app. It's very simple. >> Okay. Thanks. >> Hi V. Thanks for the insights but I still cannot relate it to a practical terms how exactly SEO is applied theoretical. I get the concept but if you can share if you can shed some light

on it on the practical aspect of it uh be it with an example that would be really good. >> Mhm. Yeah. So actually the boiler plate is very is an app that that works and is actually real and for example want me to like the life or the code or like like more like the concept >> I can go to the boiler plate and show how everything is connected >> in the section. Uh people ask like can we dig deeper into one project like zoo pass and how we use semaphors uh is it

also good for you like is it something you want to ask? >> Ah yeah that would be better. Yeah. >> Maybe we can. >> Yeah. So >> see a project so that we can you know relate with more >> some point. >> Yeah. So going into a real world project will be like explaining the project will be more difficult because projects usually have more than semaphore. That's why they usually integrate semaphore for specific features but they have more than that. So the easiest way to understand it is with a project that only use is only using semaphore. In this case like the bullet we try to make it as simple as possible in a way that

is it can be seen as a real world application but at the same time it's just semaphore and easy to understand. So I can go to the boiler plate and explain that and see if it's easier for you to to understand how it can be used and I'm going to do that. I'm going to read more questions. So that's the same and and with supas you prove that you have a ticket and that is that you can enter the event is mainly for that how fast is the proof generation with where it is generated.

So it's generated in the front end in the browser. So how fast I'm going to send also can you >> or are you seeing the same presentation? No, no, no. We see your >> Okay. And let's uh there is for the time you can go to the documentation and their benchmarks are here. So you can take a look at the time comparing version three and version four. So why version 4 is faster improve generation and things like that because of the new tree we are using. And you can check benchmarks here, but you can

also check benchmarks in here. So you can hear anymore. Is it me or >> uh I couldn't hear what you said. Mali, >> can you repeat one more time? Mali, no you cannot. >> I think they said that they they can hear. >> Okay, probably she also cannot hear me. Okay, let me just >> Okay, >> we also >> Oh, sorry.

>> Oh, yeah. Go ahead. >> Uh, we have one more question on the chat. Should I >> Yeah. >> Yeah. I'm gonna explain it. I'm going to answer this and then go to the bait. So here in this website in this benchmark seps dev website you can run functions and you will see the time and also version four and you can generate it in your in your device and then yeah you can actually generate it in phone. So that's why some most of the projects that use SEO for in real life the fish but also because they for can be used in phones. That's why we in

supas we have it in phones so you can use it and because it's very light and optimized. So that's why that's something that people like about about seven for a lot. That's benchmarks. And let me go back to the questions. So that's related to proof generation and is generated. Yeah. So this example is the type. So let me go there. [Music] Okay. So here is the boiler plate. You will have the contracts and the front

end as explained in the architecture and in the contracts you will have this is a feedback application. Let me this is a feedback application where you generate your identity and yeah let me go through the app first. The boil plate is a feedback application that in a way that everyone can join a group because the group is open in this case. Everyone can join a group and send an anonymous feedback. So we won't know who sent what. So then you create your identity. You have your private key, your public key or commitment. And then

these are the users and then you join a group. And and then after you join a group, you should be able to to send a feedback, an anonymous feedback. Then this is interacting with the contracts. Yeah, you the so the group has 51 now and then you will be able to since you're part of the group, you will be able to to send something.

Yeah, you should be able to and it should appear here. Yeah. So, it's here and that's the flow of of this specific application and how it's created. The application is interacting with contracts. So we have the contracts here and we create the group here. The group that will

contain everyone and then we will be able to add members to the group. So that when when you create your identity and you join a group, this join group is called this function. So you are added to the group and then when you send the feedback what what is happening is in the front end I'm going to show that now but in the front end you will generate the proof and then it will call this function the the send back function send feedback function and then you will be able to to verify the to validate the proof. This is the proof and then organizing the proof here and then you will be able to to validate this proof and using this

group ID because it's just one group in this application there is just one group but you can have many groups because in this case it's just one open group but in let's say if in this class we have different groups because we want to get feedback from organizers but also from students or we can create different groups depending on what we want. And actually we are talking about feedback here. What you think about something or whatever you want to share but we can it can also be voting. So you can vote on proposals in a group. You can add a proposal and people can vote on that. So what what is the interesting part part

here is that in a group you can prove that you are part of the group. So it means that no one outside from the group can vote or can send a feedback. So that's the cool part. And this is a contract. So it's simple. So that's what is happening. And let's see what happens in the front end which is the what is happening in the browser. And here you will create your identity in the browser. So you create your identity this way in this case is not nondeterministic identity and then it will save your

identity in the local storage in your computer in your browser you will have your identity there. If you go there you will be able and you go to identity displays you you will be able to see your identity the private key and there are different ways you can do that. This is an example for an application but people should take care of the way they set the identities and you create the identities. Then you go to to the the group part that's the first page you saw this the first page the the rel the one related to the identity. Then you go to the group page which is this one. And then here

you will get your identity from from the local storage and you join the group this way. Well, this is to get the information. Let me go to the right part. It's always easier to find it. [Music] Yeah. So, you can call it here to join the group and then let me find the right.

Yeah, because you can check you can use different things here to you can use the pre layer or the back end. So these are all the ways. So you shouldn't need all of these. You just need you just pick one. You're going to have whether a back end and you are going to use this API or you are going to have this or or any other re layer. For example, we are we have this open sampling one or the Jato relayer. that you can choose the one you want and this way you join a group. This is the second page and in this case with the API in this case with the relayer you call the function and this will generate the

transaction and add the member to the group and then yeah this is the UI and when that's fine when it was created using the API it was added using the API or the every layer then you will be able to see the third page which is to generate the proof and it's the same you will use all these options. Let's go for the one that is faster like the API but you can also use temporary layer which is better and it's actually back end too but it's easier

and then you can just send the feedback and what where what you're doing here is to calling an endpoint I'm going to go there now but is to send the the proof so that it can it will be verified in the contracts you will the back end how you how you can join the group. So what you're doing is interacting with the contract and just calling the join group function we we saw in solidity generating a transaction and then in the feedback app you will have a transaction

too but this time is to validate the proof and then calling the send feedback function we saw in the solidity smart contract the the other function then we will call this function with the parameters and the proof because the proofs the proof was already generated in the front end. So that's related to the API how is interacting with the contracts. Is it clearer now like seeing this flow? Because this is the most common flow in superass. You will have the same because you need to create your identity. You need to be added to the group and you and then you will use that to prove that you are able to enter the event because you are of the event. So

you already were added to someone that can enter the event. So it's the same. So in in world it's the same. You have your identifier and then you will be able to prove things because you are already there in the group. And pair wise for example is for voting is the same. There are groups and then you join that you want to vote on specific pro specific round and then since you are in the group you will be able to generate the proof and send your vote. So it's like that and yeah examples >> another example >> sorry before giving any more any other

example I think we have two questions because I >> okay in the chat >> no no no Aust and also Ari you did but >> yeah uh okay I have a question I think that I didn't understand what identity commitment uh is. So do you mind to explain explain it in more detail please? >> Yeah. Yeah. The identity commitment is actually like your public Ethereum address your address your address your Ethereum address you know have you used that? Have you interact with

do you know like private key and public address in Ethereum like a normal wallet? >> We cover weak one. Yes. >> Okay then. Great. So it's the same. So you can think of it the same way. The sema for private key is like your Ethereum private key and then the sema for commitment is like your Ethereum address which is public. So you can think of that the same way. uh how can we generate that uh identity or address in simur because I think that it's not uh safe to share your your ethereum address in a public uh chain

>> it's safe it's safe you can it's public so you can share your public address it's safe so you their commitment is public so you can send it and because the proof when you generate the proof Proof the proof are not attached to commitments. So no one knows the commitment that sends specific proof. So that's fine. So it's public. No one can do anything with your commitment. They can only do something with your private values. wish what was the other question

>> I think on the chat um yeah if the information is stored on the browser site uh how it's not compromised you know social identity or data as per client server architecture something like this >> yeah that's um the identity. So the question is that if it's safe to save the identity in the browser, right? So if that's the question, it's not the best way or if you do it try to hash it or do something the best way but that's apart from the semifer

protocol. So in some of our protocol we have the identities the group and the proof but the way you manage your identities that's a part and you should do something about it. Every project will do something different. Some others will do something similar but they do their they have their own solution but the best thing will be to have a wallet like we have for Ethereum addresses. So we have that to save everything and it's more secure. So that will be the best option to have a wallet with the identities. So that would be better. But for now, PRs usually save that in browser or they also ask the users to download the private key so that it's

not saved in the browser is and they can save it wherever they want and things like that. But there are different ways. But yeah, for sure saving it in browser by default and just showing your private key in the browser is not the best way. But for the boiler plate that's fine. Every application should take care of that. There is another can the inputs be can the input. Yeah, the inputs can be anything that is a hash or of something. For example, if it's you can save the videos or images in a server or somewhere and then hash it and then use this hash for that so that it's an identifier of your scenes and then yeah

they can also be images or videos by using hashes. Any other question? If you have actually after the class more questions, it's fine. Feel free to tag me in Telegram or yeah, let me know. I can answer everything >> maybe >> in the chat too. link to chat or maybe telegram if anyone want to try uh and

use you know people ask how we can um find beginner examples so maybe we can share the you know >> the GitHub link >> um actually in the yeah we can share it in the chat I'm going to share the link actually the presentation too in the chat and here We can see all the projects. There are a lot of projects here in the first page. You will be able to see these projects and but there is a list of projects using SEMA 4. You can go through them and take a look at the code too. But actually most of a lot of these projects and a lot of real world

projects will integrate semaphore but we will will have a lot of other things in their architecture. So that that's why it will be more complex to understand the big project, right? So you will probably need to go to the part that they are using SEMA for. I'm going to share all these links in the chat. >> I believe we don't have any other question. Uh >> uh >> you have >> here maybe I'm sorry um I have one more question um do you think that uh we can use simfort for a digital identity

systems or is not possible >> yeah you can yeah you can you can for sure yeah >> and how can we apply it uh how can it um I don't know how to say is but uh more like that how can we apply SIM 4 because in digital identity we need uh well more exactly in self sovereign identity we need the triangle of trust the issuer the node uh the the issuer and the identity holder and then lastly the verifier soap for how can or where where

sim of work can help in this system or I don't know if you understand >> yeah so people have used it the identity part for to manage the identity just the identity of the holders and that's one way just using the identity part of semaphore for the holders and then with the with this um You can actually also maybe have a group instead of people credentials like have every credential can have an identifier and then you will add this identifier and then you will

prove that you have a specific credential by proving that you have the private key of the identifier of that credential. that can be an example but it can be used in different parts. It's not like semaphore is for something specifically and it cannot be used in any other way. It can actually be adapted to something and something that some protocols have done actually self protocol is using one of the circuits that is using the one for lin and it's actually using lin and some protocols like identity protocols what they will do is instead of using

semaphore directly they will just use what semaphore is using the lengt we created for semaphore and they will use that because they don't need other parts. So that's also fine. You don't need to use the full protocol. If you don't need it, you can just also take some parts. >> Okay, thank you very much. Uh right now I think that I would like to build uh human oracle with simur. I maybe is it's possible or not?

Um yeah I don't know depending I don't know maybe a word protocol is using stemma for so probably but depending on what you are going to build exactly I will need to see details but probably everything related to groups yeah you can use them for probably everything that contains a group of something except people credential whatever Do we have any other questions?

>> Uh, yes. Hello. Can you hear me? >> Yep. Um, just a small question. Um why do you think that semaphur uh is better than attributed attributes based encryption like even if I if I even if I understand of course all the points but do you have an opinion on on that attribute based encryption? No, I don't I don't know that. So, I don't know. >> I don't need to take a look at that to know.

>> Just in short, it's also a way of encrypting data and people who can decrypt are only the one that are specified by attributes. And this is also a way of building groups. So, it just made me think of this way. >> I need to look for that. So, what what is the name? It's I think you add it in the chat. >> Yeah, I will share it in the chat. Okay. >> Okay. Yeah, thanks. Yeah, thanks. Yeah, we always we are always looking to find the most optimized ways to do it and actually if since we need to have it optimized for contracts, circuits and also front end and back end. So it's difficult to find a way to to have groups in all these environments and in

an optimized way. So that may be the answer why we are not using something different because we have experimented some things and yeah so I will take a look at these two but we have tried different ideas and and since they sometimes they are not optimized for circuits sometimes they are not optimized for contracts and that's why we don't choose something else because in onchain most of the time when you want to represent a group of something you will use merries So yeah, so I will take a look at that but that's probably the answer because we need to have performance on chain pron and circuits.

So having a good performance on all these things is difficult. So that's why sometimes we don't use other ways to create groups. But I will take a look at this specifically. Maybe this is more optimized in browser and back end and things like that. Because that's what happened before with other ideas. Ariel, did you um think about your

question now? Sorry. What? >> Uh Ariel was trying to formalize his thought, ask a question and I just wanted to ask him >> like uh your mic is closed. What about now? Oh, perfect. Hello again. Thank you for the session. I'm thinking in a kind of reputation system for students and learners like us. like, hey, I want to prove that I was part of this specific

cohort, but without telling you what cohorts I was part or maybe like, hey, I want to tell you that I win that I won some hackathons without revealing which hackathons or or which technologies for example. uh the the the use or or the the the the use case I mean that I'm thinking right now is for recruitment processes where you want to avoid like hackers for example in North Korea or things like that you want to to prove that you have a track record that it's already verifiable and the different projects and company and organizer could create these kind of groups

but but I'm not like sure like if you can demonstrate that you already part of different groups with reing which groups yeah you can and there I was opening this project because interre was kind of like for like anti-c which is kind of related but uni is exactly that it was a it's a project that was develop it's a project developed by PSC too and is is not maintained anymore but it was it was maintained for long time and it's exactly that. So you can take a look at

this project. >> Got it. Thank you. Yeah, it's exactly that reputation system and it's actually using semapur. >> Uh we have one in chat. >> Yeah. Trying to build a system where people can be able to speak on social. Okay. Yeah. So yeah, that's actually possible. Yeah. With semaphore by default. That's one of the main use cases.

Mhm. Hackathons or give grants for using the technology. So we we actually were part of we have been at a lot of hackathons and we did that but not now. Now we are we are maintaining sem and we are not adding new features. We are just maintaining it. And if a team wants to integrate it, we help them if necessary and we give support and we will add only things that are necessary for teams. For example, for example, recently it was necessary to for a team to be deployed on on Nosis chain and then we will deploy there. If

you want it in specific, if many people want it in specific networks, then we just deploy it on that networks and and things like that. But we are not going to hackathons to for Seapur specifically right now. But we did that a lot for a few years. Yeah. Open source contribution is welcome. Yeah. Yeah. We are maintaining it. So yeah is any open source contribution is welcome and to improve something to add

something specifically. Yeah, for sure. >> That sounds perfect. Uh I believe we don't have any other questions. And um thank you for today's session, Vivian. It was really amazing and you answer all of our questions. Thank you very much. And if you have any questions, I believe um like Vivian shared for contact, you can ask in the group chat too. And thank you very much again.

>> Thank you very much for the invitation. I'm going to share all the links and feel free to ask any other question in the chat too and tag me. I will answer as soon as possible always. >> So >> thank you very much. Thank you. Yeah. >> Take care everyone.