Anchorage Digital Workshop I Prasanna Gautam

workshop. Um talking about our uh visual sign uh framework uh today and um this is a framework we just open sourced like an hour ago. So uh we've been doing it in uh little bits and pieces but um before that it's worthwhile to explain like how who who Anchorage is um and and how we how we ended up building building this framework. Um um so first um so Anchorage is a uh institutional uh crypto platform, right? So we we also operate a a um a federally chartered uh bank in the in the US.

Um we have uh regulatory clarity in uh multiple jurisdictions. uh Singapore in in particular. Um and we also operate a self-custodial wallet. Um as we have built uh more and more uh interactions for for various blockchains, what we found was that we constantly had to uh take data that was coming uh in raw uh transaction form uh via wallet connect or or via like other other avenues and convert uh convert that into something uh our our users can can see. And our users are other institutions.

What what that means is that they are the largest institutions in in in the world. They could be the largest banks in the world. They could be sovereign wealth funds. They could be large venture capital firms, your foundations, you know, all of all of those sorts of things. So we had to build something that was clear to the user.

And one of the primary goals of the the company from the beginning has been to um to make sure the user always knows and understands what they're signing. And that's what drove us to build this framework as an internal tool inside Anchorage. Um and I'm Prasana by the way. I I lead research uh uh for for protocols uh over over uh at Anchorage. So it's open source framework.

It's chain agnostic. We want to build it uh build these transactions in a way that is human readable. Currently only one wallet supports it because we haven't really told anybody else about it uh in a in an integration uh kind of a way and this is this is really the first time we're we're really presenting um this as a um open source project that we want to build in the open. the core core problem like these are really the uh big problems right so we have u the user risk and we also operate all the signing all of the assets are are being um protected by a hardware security module uh that uh our our clients use um and also we we we were getting a little bit frustrated that the ecosystem wasn't coming up with a crosschain solution and we thought we had to we had to step in and and build something. So, quick quick show of hands like if you would if you went to a DAP and you saw this uh this as your uh as your as your screen would you sign for this?

Like looks pretty harmless, right? It's like fun times, whatever. But now you scroll a little bit further and what you see here is by clicking this you grant us a perpetual uh irrevocable license to own your soul. And in many many cases like by just signing a a blob you just don't know what you're signing. you're you could be signing up everything and many people in fact do like especially in retail who uh do not know what they're what they're signing and many people get rugged and they never come back to crypto.

Um and this is since this is a Ethereum conference and our um you know this is this is DAB developers like we want to ask you do your users know what they're signing and would you like to have more control over the semantics of what they're signing right that's what we're trying to provide and another one um over here which is uh does this look familiar at all this this transaction um or or the or those four four characters or four four bytes up up there. That's that's the transfer that had uh $1.9 billion lost or by bit, right? If you're if that's what you're looking at and you cannot tell between uh a $1 billion transaction is just as big on the blockchain as a $1 transaction, right? You cannot just like know, you know, like uh there are no trucks moving the money around, right?

There it's it's exactly the same pledges. And all things considered, it's it's actually one of the most common uh um type of uh call data in in Ethereum. It's just every ERC20 transfer like uses this. Um, and yet we don't really have a way to to um to clearly show that even if you're using something like safe. Um, so how does um visual sign work at a at a high level?

We initially built it for our own needs which was we only as Anchorage we only trust hardware and what that means is that all our users who are in a forum only trust the hardware that has a secure enclave and that's iPhones. So the problem was that every feature we were releasing we would have to uh wait for app store to approve it. So that was actually blocking our product velocity. So we needed a generic way to express any blockchain transaction or even really any transaction including our uh our operational things. So we built this framework so that we could actually support u EIP77 uh EIP712 uh eventually uh EIP730.

We have mechanisms to parse APIs and and all of these uh types of things and we turn that into a visual representation. our back end uh or our HSMs turn them into visual representation and then um you can you can uh endorse it and and approve on the phone. The other thing is also we can actually express a lot of like really rich uh transactions uh with this with this UI because we are displaying it on a uh mobile device. Um so you know not everybody else can do that especially hardware wallets that are uh um building this and so we have we have built this framework to be decoupable. Um here's here's um a transaction uh unis swap transaction rendered into in our app where we are able to decode uh this is a little bit older version before we wrote the the the new framework but the ideas are the same.

you're able to collapse, create this uh detailed view that start out collapsed so that you're not overwhelming the user with too much information. But if the user wants to uh they can expand it and actually like know exactly the the uh information they need. And I'll show you in a in a little bit what that looks like. Um what are the ways to integrate? Um you can parse the AIS directly but the problem is that um uh because of various historical reasons especially in Ethereum people oh people pack a lot of a lot of information into uh these uh u u 256 um like it's it's I forget how many bytes it's 32 probably um and um there's just a lot of meaning there and there isn't a really good way other than to have a programming language to to express that.

Um and and that's why we are building this as a product basically for DAP developers to be able to express um express what um what exactly the to the the contract is doing and we're doing it in a decoupled way so that if you are a aggregator, if you are uh um something that needs to have a call data to another contract, you can look within uh within our registry and and not have to like communicate with all the all the DAPs that you might ever interact with. Um why not use clear sign, right? Um that's a question we we got from the beginning of the project. We we didn't um we we actually have an adapter for clear sign. um we could ingest the data for for clear sign but we decided not to build everything around it because we found we couldn't express all the things we needed with clear sign as much as we could by literally giving you an ability to uh put your um interface uh solidity interface and just and just use that right so that's what we are building as the primary way to to um to to use this but we could we could work with the foundations to also ingest clear sign if that's the if if if as a DAP developer that's what you have invested your time in um talk to me and and and I can make that code available it's not it's not quite ready yet um but uh um yeah so so these are a couple of limitations uh I wrote this like a few months back so they may have added a few more things but uh but fundamentally you're looking at a static JSON versus a full programming language and it's it's completely different.

So, this will always be leakier than um if we've already done this. And yeah, I want to show you a little demo of u of how this works. Um I have recorded a video too, but uh I think just streaming the data might actually be faster. I'm just going to show you the video. Sorry, I had to uh I had to restart my workstation.

Um so um this is a a previously recorded video um of um also this um this runs in a uh trusted execution environment in in turnkey

adding solidity to uh to add a new contract on visual sign um Ethereum. First of all, I actually

Yeah. So, so turnkey actually operates this. What I'm demoing um over here is actually a developer tool that I that I wrote for um for running it locally. How you would in how you would integrate with your your wallet is uh we have a wallet integration guide too that I'll show at the end is by verifying that this reproducible binary that you can build and verify locally and run it locally. uh this um this exact uh same uh binary is uh is what turnkey key is running and you can decode it and display it on before your users can sign so that you actually know what they are signing um and um I have a CLI tool it's it's running exactly the same code the the uh back end would use and uh there's a output format called human that just shows it as a tree format so that it's easier to read um by default it's a it's a JSON format um that that your wallet can can integrate with but I um also wrote a AI JSON parser too um over here and uh the I still have like seven minutes I can I think I can actually show you the um the actual solidity uh interface flow um so you can ignore that for now uh my if my IDE loads.

Uh oh, no. Okay. All right. I'll just I'll just give it give it some time to load. Um but you Yeah.

So this is this is a very simple way that like I was able to integrate uh ERC20 and every contract that needs to interface get any information about ERC20 they don't have to go and reimplement this like you if you are uh unis swap developer you start with this uh this um um this uh pasting your interface inside this uh solidity um soul macro and you immediately get types and you can use that uh to to implement a visualizer over here. So can basically read the first four bytes and then start uh start start going through how to integrate that. I'm not going to go too too deep into it. Um um uh it's it's it's uh it's it's relatively simple once you once you uh look at some of the some of the semantics of it. Um and um yeah, I'm happy to take questions.

Uh we have like five minutes. Yeah.

Oh yeah. Um which which annotations? These uh static annotations.

Yeah.

Um there's some stuff that you get automatically. um um the the AI JSON stuff I uh that was one exercise of like just automatically doing it. So what I um what I have for for that is um what I wanted was like how can I go from a JSON AI and just give you like some some defaults right like which is like this is what you can get maybe maybe a vast majority of uh DAPs that's good enough if you're not doing some crazy gas optimizations um and then maybe like some individual components you will have to do some like additional parsing um and and that is the kind of thing that we are we're like very early stages of designing that API and we would love to get some feedback on on how that how that looks like. Uh um so yeah we we're I'm not I'm trying not to be super prescriptive yet till we get more feedback from from devs. Um so so the solidity to conversion conversion to type um is we have enough samples that I feel relatively confident that you can probably look at what I've implemented with uh um so with something like uh uh uh unis swap over here um you can probably um uh uh see so I have unis swap and morpho because they were uh complex Um and uh so you can you can do uh you can do something like uh over here um a lot of there's just a lot of boiler plate I'm not I'm not like super happy with but uh I also don't want to over overengineer it before there's like uh actual usage of it.

Uh but yeah, a lot of lot of this stuff is like truly additional boiler plate that eventually we we might just be able to like automate out and create some kind of Rust macro or something like that for you. Yeah.

Yeah. I think I think if you solve this it can be very useful because you know everybody gets to sign transaction they don't know what they're signing can make it visual and make it like understandable.

Yes.

I mean that's a game changer.

Yeah. Yeah.

Yeah. That's Yeah. Yeah, that's what that's what we're trying to do where where I think we have a pretty good um UX, right? So, at least it renders on on on our uh devices and uh we believe developers can kind of figure out a lot of the ergonomics uh parts of it. Um I think we have enough of a framework there.

I would love to work with more more devs on on on it. Yeah.

Cool. Thank you.

Thank you.

Sweet. Any any other questions? Any Oh, yeah. Oh, yes. Yeah, we have the bug we have the bug bounty.

Sorry. Um uh yes. Uh and of course, this is not, you know, like we're we're offering bug bounty. Uh we're we're offering $10,000 for uh I think five different uh uh uh prizes uh across two two tracks. Uh we have strategically important uh uh um contracts that we have uh picked out.

Um ideally you know we can we can discuss on you know we can figure out some way to like kind of divide up the work so that not everyone just picks unis swap. Um but um and then if you are working on some interesting projects that we should consider um um we can we can also talk. We also have our ventures team over here. Um we can we can definitely discuss about like you know if you're bootstrapping a company that uh you might be you might want uh any venture funding and you want to you know bootstrap it with visual science for so day one you are actually fasttracked for institutional support that's that's also something we can we can discuss and that that would probably go into like bottomup track um that we're offering prizes for. Cool.

Thank you. And uh yeah, some contact contact information and uh um yeah, some some couple of couple of things. If you're if you're if you're building um wallet uh client too, I have a reference client implementation um that that's pretty lean um too. But yeah, cool. Thank you.