Safe Labs: Building Enterprise Grade

Hello, now you'll have to endure me for another 20, 30 minutes on the stage, but I'm super excited to talk about this topic. It's been something I'm obsessively thinking about for the last three or four months now, and this talk you'll see a little bit about not just what Safe Labs, or SAFE, we're building products next, but our methodology in getting there, how we're making these decisions macro and micro level, and what values are sort of informing us to make those decisions. So, just a big picture, right, like a recap. The total crypto market, back about three trillion, there's a trillion in transaction volume in, say, smart accounts, there's 60 billion assets across all EVM on SAFE, and we've come quite a far way from the magic internet money from a few years ago, to kind of just put this in perspective, I saw a very interesting tweet from Token Terminal on Twitter, right, where it put together side-by-side some of the crypto protocols and existing like centralized ones, and you can see the 60 billion assets stored across EVM on SAFE, that's a pretty significant achievement we've carried through over the years. And, where this is all leading up to, right, it's, we've gone past the billions, we're now in the era of trillions, we're talking about the trillion dollar on-chain economy, and it will be powered by SAFE.

We spoke a lot about a trillion dollar security, for example, from the Ethereum Foundation, and I often think about what does this world look like, or what it should look like. In my head, it's when a student in Bogota, let's say, and a Fortune 500 company, they both are using an institutional-grade or enterprise-grade software, self-custody. They have the same level of user sovereignty, digital sovereignty access, they have selective disclosure of privacy, they all have the same thing, but their purpose is very different, and that's the one trillion dollar on-chain economy, for me, that looks like. But this year, we've had a big hiccup, right, it was a bit of a reality check, like self-custody is very much, I would say, under attack. And it's not just the attack itself, but it's how we are being attacked.

If you look at the core principles, right, like how we are built upon, like we have privacy, censorship resistance, transparency, openness, the attacks are basically taking advantage of what our core pillars were. Our core pillars are being essentially used against us, and that's concerning, because when we are going through the, when we have a vision of a trillion on-chain economy, and this is important, because when the attackers weaponize our core pillars, right, our foundation shakes or quakes, and our mission stalls, essentially. And we need to re-look at the foundation itself before building greater structures on top of it. And this is where the realization comes more like, it's time to evolve and fortify. So let's talk about like our cypherpunk values, right, does anybody recognize this ban?

Sorry, safe against the machine, right? Yes, yes, that's accurate, there'll be a t-shirt about that. It's one of my favorite bands, if you haven't heard, you should absolutely listen to it. In the wake of the incident, I found myself chatting with hundreds of people in the industry, and what dawned upon me is, they all had very valid viewpoints. Crypto, again, I repeat, it's an industry with very strong opinions, but what dawned upon me is, there's like two polarizing camps.

On one side, you have the cypherpunk values, right, like the grassroots, where we started from, and we know like self-custody, privacy, you know, cypherpunks must code, et cetera, and this is just one side of the camp. And on the other side, what I see is, when I talk to more traditional, like, you know, surveillance, you know, compliancy, log everything, audit everything, and expose that information, work with regulation, both are valid. In the wake of the incident, I felt like they had very sound approaches to the same problem, but the principles were rather competing with each other, and I didn't find that there were enough people building bridges between them. So I want to make this simpler, actually. We're in Berlin, right, so I have to use, one, a music analogy, and two, I have to put a DJ console up there.

So this is my way of simplifying the problem. So on the left track, you have the signal, the base of decentralization, as you may call it, which is the cypherpunk side, right? On the right side, you have a very big harmony, which is the enterprise. And this little thing in the middle, the crossfader, basically, you flip it to the left, you get the signal from the left track, and then flip it to the right, you get the signal from the right track. What that means is that you're making a trade-off, so I call it the crossfader of trade-off, or a zero-sum crossfader.

And it's the same thing, it's just not the philosophy, because the way our philosophies are also reflect in the products that we build, and I find that when our mission at SAFE, which is to build easy self-custody or secure self-custody, right? That's an interesting trade-off we have to do. Why not make self-custody easy and secure? And then how do we do that? And I had this realization that the problem was not the philosophies themselves, it's the framework that we operate in.

It's this console, it's more specifically, it's this crossfader. So at SAFE Labs, we fundamentally reject this crossfader. We reject this notion that you have to compromise one over the other. So what this brings us to this is, we really thought about how we should actually build an opinionated product going forward, which is basically preserving our Cypherpunk values, but apply the enterprise-grade rigor. We call it the Cypherprice.

There was no playbook, so we had to write a playbook for this, and that's what we're doing, and had to coin a term. And Cypherprice has quite a ring to it, let's say. So Cypherprice is our playbook to scale crypto to a trillion-dollar vision while preserving our core values. I would say this is easier said than done, but we don't shy away from taking on the big problems and the challenging problems. So in principle, how this could look like, this is just a very simplified version.

So we have to map where our core values are, how our architecture should be, where we actually establish our trust anchors with the community, our users, and ultimately, how do we have this pragmatism to go institutional-grade, enterprise-grade, the scale, essentially? How do you preserve what we can, and where do you monetize, where do you not monetize? And taking an opinionated approach about what we build, not just at the product, but even at the micro-feature level. So we often hear, I don't know, is anyone wearing a Don't Trust, Verify T-shirt? Oh, you'll find them, right?

Like, we're at the right conference for that. For us, this is more than a slogan. This is a first principle. But what does that mean, actually, right? And before we get into that, I had a workshop with Ethereum Foundation.

I really sketched this thing out very quickly in the morning just to kind of emphasize a little bit on how we apply this Don't Trust, Verify principle in practice. So a very oversimplified version of a transaction anatomy. You have a payload, which is an intent you will sign, and it introduces a state change. It's that simple, right? That's the heartbeat.

That's the anatomy of our entire crypto industry. It's humans doing transactions or people doing transactions on introducing state change. And just within that anatomy and life cycle, there are so many different things that's going on right now. We add transaction checks, you decode, you simulate, you introduce a trust layer, you have to introduce a verification layer, and you want to have clear signing, et cetera. And then ultimately, you commit that transaction on the blockchain, right?

And what's happening here overall is that, especially this year, that deep diving into some of the more simpler parts of or accepted parts of architecture is that there are gaps. And the way attackers think also is that they know where the gaps are and they start to kind of penetrate right into that gap and then take advantage of the process. And our architecture and how we build has to be very, very intentional into closing these gaps. So, for example, this slide, it shows a little bit about how we re-architectured or redesigned the very heartbeat of our product, which is the transaction flow, for example. There's two layers to it, right?

There is the left, that's the trust layer where a user trusts the safe platform where we can scan to blockade and we run a simulation with Tenderly. But what's behind the scenes that's going on is there's like a hundred rules that we work with Tenderly and blockade scan. So there's always a trust layer. With trust also comes a lot of responsibility, obviously. But what we have changed is the one that you see on the right side, which is we have this verification proof.

So as a user, you may actually decide, even though you trust us, you can verify us. So this is what I mean by don't trust, verify. How should that reflect in practice, in the feature, in the product? And you can verify these proofs with third party tools, not relying on a safe platform at all. So where does this lead us, right?

Like we talk about self-custody and we started with making self-custody easy and secure and that got us quite far, I would say. And then what's next for us requires a little bit more. I would say we're making self-custody secure in our product. Like in Wallet, we are investing heavily into educating our users in what a secure setup should look like and how it could look like and help guide them to that thing in the first place. I really liked one of the panels earlier.

There was an opinion about what is the purpose of a signature? It's to authenticate. And the responsibility of a signature is too much right now. If you actually have on-chain policies, if you set up your accounts, things really well in the first place, the responsibility of a signature verification, it's lowered and very narrow. We're making self-custody easy.

For example, this is our dashboard, for example, what started off as SafeWallet, which is managing storing assets. We're helping people activate assets using self-custody as the foundation. You can see like SafeWallet is DeFi complete. You can bridge, you can swap, you can stake, you can earn. The point is that you can activate these assets very freely, but all based on self-custody.

We're making self-custody verifiable. What does this mean? And we have a mobile app. So this is our new mobile app that's going to be launched very soon. This is not just another DeFi wallet app.

Its primary purpose is to be your secure signing companion. It is a signing companion first, a signing app first, and a DeFi wallet later. This is one of the ways that we reflect into our roadmap. We're making self-custody extendable. We have launched a developer portal where you now have a way to access our API platform, event service, transaction service, webhooks.

You can configure a lot of this. What does this mean is that you can not only build on smart contracts, but utilizing a lot of our fundamentals that we expose by our infrastructure, you can extend it and customize it and build more complicated or more broad problem solving products. And lastly, making self-custody enterprise grade. This is a product that we launched recently. It's called Spaces.

This is what it could look like essentially in the very near future. We see people that manage hundreds of safes or thousands or tens sometimes. And it's because they rely on it for various reasons. And we needed a very specific product that we want to build for them. Ultimately, what does that mean in the future?

We're looking at multiple networks being end-to-end encryption, webhooks, getting stock to compliancy, on-chain roles, policy orchestration. These are terms that you've heard. And these terms that don't get mentioned much when we talk about grassroots and cypherpunk and self-custody much. And this is essentially where we're heading. I like to call this the safe labs.

There's a place where you can forge cypherpunk ideals and enterprise grade rigor. It has to happen because that's what unlocks the power of the trillion dollar on-chain economy. And with safe labs, the cypherprice pack is coming. And if you like this mission, please join us as well. Thank you.

Questions? Yeah, we have one question here. You mentioned that your goal to have a student in Bogota using the tools and resources. How are you going to facilitate that, that they're aware of the resources and tools existing? How are we going to make them aware?

I think first thing is make it accessible, make it available and accessible. And I think I like at SAFE, one of the things we haven't done and we will be doing a lot more is speaking about what problems it solves, what and who it solves for and what it can do, for example, and really speaking the language of the user and the problem they are speaking. And this is something we intend to do a lot better, but that's what we intend to do is to kind of speak their language and unlock their problems. And this, you can expect that from us in the coming future. Yeah, enterprise pragmatism.

Yes, that's a good point. Often I find that when we start to architect a lot of our products, essentially, we are very much serving a certain user segment, right? We are, I remember this notion like not so long ago, someone told me very strongly, if you're building in crypto, you build for crypto first. And I say this quite often, when you build for everyone, you're building for no one in particular sometimes. And you have to know what you're building for.

And when what we're building for is essentially an enterprise grade, it's the scale. It's thinking for scale, but also there are certain specific elements that makes that scale happen. And it could be as much as visibility into what the policies are, who sets the policies, for example, and who's transacting, ease of access. It can be, it can permeate in various different layers. But the point is that when you design something, you're not excluding that scale aspect of it, not just building for a certain simple user segment, for example.

I hope that answers your question. Yes. That's a question. You showed that you want to create a second product, basically on the designer functionality. Is there like a way to use basically double signature verification, such as like using a QR code or so to automatically validate the transaction data?

Because it looked like it was still like a visual check, right? Where you have like a string of maybe 30 digits that you have to control. How can I envision that? Could you repeat that just a little bit louder, please? Sorry.

If you have a two interface logic with a new product that you're developing for like a signer and verification of the transaction data, is the user having like the interface and what you just showed, like, is there a way to automatically verify the data designed in this process where, for example, you scan a QR code that automatically detects if the data is matching? Or is this a visual check of the digits that are seen in the call data and call hashes? Well, that's an interesting question. We're very much in this early stage of actually asking those questions, but also how much of that problem do we have to solve? But ultimately, like if I if you remember the slide that I showed you, the gaps, it's there is a gap in the signature verification process and the signature process between even though when the transaction is viewed and when it's signed, we want to air gap this as much as possible.

But this air gapping is it's so much more than have just providing a prescribed experience. What we see is enterprises, again, the question about what is that enterprise pragmatism is what we see with safe is that a lot of people are setting up a bespoke architecture. They want the custom policies. They want their own on prem. Sometimes they want their own architecture.

So when they introduce a device, a hardware device like a phone, for example, to verify and the key question that we are asking is the same is how do you close that gap? But it starts with a question, I think. And this is very much the right time for us to even hear from people like you that that this is an important question, actually. So stay tuned, I would say. We have time for one more question.

Hey, you said one of the kind of the first principles was verify, don't trust. Do you see a future in which this could change? Because verifying is oftentimes very cumbersome and kind of a difficult journey for everybody. Do you see a future where you might say, hey, we'll actually work on some other. Yeah, I love that question.

And it's one of those foundational principles I try to like keep it warm in my head is what aspects you want to trust and what aspects you want to verify and what is your verification means. But the important thing is actually not not just having a trust layer and a verification proof layer, but we know it's our ecosystem that's so opinionated. What stands very true is users care about having a choice rather than a prescription. And people want to have choice about what they can do and what they cannot do, for example. But ultimately, we can be opinionated, we can be loosely held opinionated, we can prescribe.

But I don't think we can we should restrict to a large extent. And I think this needs to reflect even in our core ethos is like build, build modularity, modularity over monoliths. Right. And that should permeate all the way to the end user. But I think the most important thing is designing for choice.

OK, all right. Yeah.