 I'm Geoff Lampert. I'm from the Privacy and Scalings Explorations team in the Ethereum Foundation. And I'm going to talk today about Interrep, which is a project we've been working on. It's in the identity space. So, a brief introduction to what we do. There's lots of projects in the trying to bring identity into Ethereum. And they tend to have some identity source and build it up from the ground. Our approach is a pragmatic approach where we build on the identity that we already have in our digital lives. And we bring that across to Ethereum so we can have an established identity pool and we can integrate that into our Ethereum applications. So, yeah, very much a pragmatic approach building on the identity sources we already have. So what we aim to do is build a bridge from existing digital identity sources to Ethereum, integrate with providers of those identity sources and then privacy is very important to us. So, we build on the semaphore framework and integrate with that. So, those building blocks will come together to form the basis of an application. So, identity. We spend a lot of time in our social networks. Some people more than others, but people spend a lot of time on their Twitter accounts and building up, putting a bit of our personality into those accounts. So, every tweet you write is a bit of humanity that goes into that tweet that represents you. And we build those up in our social network accounts. Some people spend a lot of time on that kind of thing. Even if you're not into social networks big time, we still have digital identity in the non-Web3 world. We have things like government IDs and driver's licenses and all that kind of stuff. So, yeah, our real world human identity is reflected in those digital sources. So, that's what we try and build on. But we need to recognise that those digital sources also are vulnerable to civil attacks. So, we need to, yeah, filter out the bots and kick them out. So, they're the kinds of things we're trying to do with Interrep. So, let's take a look at what the Interrep Lego block looks like in an application. We have everything rooted in the blockchain. Interrep is the Lego block on top of that that provides the identity module. And the Lego block on top of that is Semaphore and your application hooks into Semaphore. And with all of that, we get the identity layer in Interrep. We get the privacy layer in Semaphore and we get the blockchain providing all the guarantees. Interrep will integrate with those identity sources like our social media accounts and those kinds of things. Now, Semaphore relies on the idea of groups. You form pre-existing groups and the Semaphore application will use those identities in those groups to verify the kinds of things that your application is doing. So, Semaphore is a privacy layer. So, those groups, the group membership is guaranteed but never revealed. It's never revealed what the underlying Ethereum account is. So, we'll talk a bit more about the details of that a bit later but that's an idea of what your application stack is. It's really just a bunch of Lego bricks all plugged together. The kinds of identity providers we've been linking with so far are these examples, Twitter and Reddit and GitHub. So, what we'll do is an OAuth verification on your Twitter account, for instance, and using that we'll link it with an Ethereum account and never reveal that link but we maintain that link, that Twitter handle is always reflected in that Ethereum account. And it's easy for us to add new providers. It's really just an OAuth verification and some rules about what's a qualified account or what does it look like a bot, does it not, does it look like a human. We can also integrate with other providers, we could use email as an identity source and this is useful in some cases, not in others, maybe it's not so useful for Gmail accounts but even Gmail has some barriers to entry so, but if you've got like a .edu account, email account then that's a fairly good guarantee that there's a human behind that account and a reasonably good guarantee of uniqueness. So, we can use those kinds of sources and integrate with those. Government authorities are good in that, the government makes sure you only have one driver's license, for instance and there's a strong guarantee that there's a human behind that driver's license. So, we can integrate with those kinds of sources and it also includes the people who don't use social media. So, that's another approach we have. We can do things like curating groups of users that might rely on personal knowledge of the individuals involved so that's also a strong way to guarantee humanity. Other ID projects, we can integrate with those and we can integrate with on-chain sources like use things like NFT ownership, that kind of thing. Now, a bit about semaphore. So, with those identity sources we create a group, we put someone into a group. Now, semaphore relies on these groups. So, semaphore groups are membership sets so there are guarantees of, once you're in that set, you're expected to be, anyone can expect that identity to have a human behind it. And with semaphore, it's a generic framework in which members in that membership set can signal on a topic and that can be applied in multiple ways but an easy to grasp example would be a DAO that has votes on proposals in that situation. A signal is a vote and the topic is a proposal and semaphore will guarantee that anyone who votes is a member of that group and they can only vote once. And all of that is done with privacy. We don't know who is voting in a particular direction so it can support secret votes but it still maintains strong guarantees of membership in that set. So, the semaphore framework gets used in lots of ways but the group membership part of semaphore, plain vanilla semaphore has its own group management but what we do with interep is semaphore outsources the group management to interep. And then interep itself is basing its identity groups on, for instance, on Twitter membership and GitHub membership and so on. So, the way that works is users will prove their membership in that social network identity source. So, that will form a Twitter group but we subdivide that into tiers which basically represent a level of confidence that there is a human behind that ID. And as we know, Twitter is riddled with bots. So, we will just apply rules to filter out those bots as best we can. We won't, we're not going to say it's perfect but we'll get pretty close, good enough for most applications. The way we do that, for instance, with Twitter is we'll have a, we have some criteria that we apply ourselves. With Twitter it's a fairly high bar to get in gold status. You'd need 7,000 followers. With 2,000 followers you'd be silver, with less than that you'd be bronze. But we also link to botometer and that will do an assessment of your Twitter account. And for most people that's going to, that's going to give us a score on how much botometer, how confident they are that you are not a bot. So, most people with a bit of history in their Twitter account and a few followers will be able to get in silver or gold just using that botometer score. You can, you can try, you can join a group and on our website and assess your own status there and see if you can get into one of those groups. The link will be in the, in the later slide. But yeah, so the way we do it is, is we'll, we'll do that evaluation, give someone a score and then assign them to that, to that, that level, that tier, bronze, silver or gold. And that, yeah, so applications will be able to choose what level of confidence they, they require. Some applications will insist on a strong guarantee of humanity, but they're going to be working with a smaller pool of, of people who can qualify for that. So some people, some applications will want a large pool of people to draw on and they're not so, not so concerned that we strongly guarantee humanity as long as we do some filtering to kick out the bots. So that would be a bronze level. We've interact groups because interact is managing those groups. If you join a group, that group can be used across multiple applications. So you can join once and use it in many applications and effectively you've got a sign in that will be workable across multiple applications. And the advantage of doing that in a privacy setting is that we have a large privacy pool. So the nitty gritty process of, of joining a group, the user will come to a sign on screen. Sometimes it'll be a step just before they go into use the application. Sometimes it will, it can be done well beforehand. Someone can join a group and then they'll keep their identity and use that to kind of log in to work with the application. So whichever way that's done, first step is to prove the identity with the provider. That might be like Twitter, OAuth or GitHub OAuth. Having done that, the application will do that assessment, assign the user to a tier, gold, silver, bronze, and then invite them to join that group. So the user will do their Twitter sign on, say, okay, you're in Twitter gold. Would you like to join this group? They click that button. And then the next step is they link that with an Ethereum account. So the user will sign a message with their Ethereum account, which guarantees that they own that Ethereum account. It also prevents that account from being used again, so they can only join once. And the Twitter account likewise can only join once. So having made that link, we have, we return a semaphore ID. The semaphore ID provides that guarantee that that Twitter handle is represented in that semaphore ID and that can be used from there on in the application without revealing that link of who the actual Twitter user is behind that account. And neither is the Ethereum account revealed in the actual application because we're using semaphore IDs and it conceals that. We can also work with on-chain sources of proof of humanity, if you like. Some of those are pretty strong guarantees of humanity. And I'm thinking there of like Solburn tokens or Po-Apps, like the Po-App you get from your DevCon 6, with your DevCon 6 ticket. That can only be owned by a human, right, because they're only giving out tickets for humans. So that's a pretty good indication that that account has a human behind it. It's certainly very hard to, very resistant to civil attacks. So yeah, so we take a slightly different approach with on-chain groups behind the scenes, but they end up as a semaphore ID and work the same way in your application. So the kind of applications we work with that we have in mind for InterEP, private voting, I talked a bit about this before. Yeah, membership of DAO, for instance, and we can guarantee membership, guarantee that there's a human behind that, a human in that group, but never reveal who that human is. Social networking we think is a promising way to apply this. And some of our sister projects in privacy and scaling group are working on this. We'll hear some talks in DevCon about that. But yeah, that's another place where privacy is important, but also humanity, proof of humanity is very important. We have anti-spam applications like the rate limiting nullifier, another one of our sister projects. We can do things like fair airdrops and civil resistant forces. So if you want to put some anti-civil properties into an airdrop or a faucet, InterEP can do that kind of thing. So to close, we think a pragmatic approach to identity, building on our history that we all work on in our existing digital lives, taking a pragmatic approach to use that, bring it across to Ethereum. We can build up, we have an existing source of identity that we can build on. We don't need to build it from the ground up. We don't need to discard those relationships we have in our social networks. But we don't want to bring along the surveillance opportunities, the opportunities for misuse and abuse, and we can build applications that respect personal privacy. So our Ethereum accounts can be used for more than just financial transactions. We can start to extend it into the social realm, bring along our social relationships, give them a human context, and make our accounts more credibly human, and our applications in the Web3 world. So the links, that QR code is to our Discord. You're welcome to come there and ask questions and find out more. You're also welcome to come and hit me up. I'll be hanging around a lot at the temporary autonomous zone down on the ground floor, which is the PSE's little hub. You're welcome to visit the application, interrupt.link, and you can sign on there. Get yourself signed up with a semaphore ID. See what your Twitter status is. Maybe you have to work on that. We've got documentation links. We've got our code open source. You'll find all that on those links. But yeah, please come to the Discord and ask questions. If you will come and ask me in person. So thanks for all that. The QR code on this slide is the Discord for Privacy and Scaling. We do lots of cool applications in the zero knowledge space. So you can join that Discord and ask questions. Check out our job openings if you like building cool applications for privacy and scaling and check that out. And on that note, thank you.