DAPPCON 2025: Shortcuts Kitchen- Cooking Complex DeFi Recipes in Minutes - Nenad Vitorovic

Transcript

Good. Well, hello everybody. Thank you for joining. I know it's it's rather late and uh it's an hourong workshop, but I think we can even make it shorter because uh really the the work that we're doing in ENSO is about making it faster to get whatever ideas you got to production to get them on chain. Um so my name is Nad. I'm Daryl at Enso. Uh this is uh the Twitter handle of of our project. So you can also follow uh the updates on Twitter. And before we get started with the workshop, I will tell you a little bit about what we're

actually building and why all of that matters. After after we finish that part, we'll dive into the workshop and uh it's something that will be very much hands-on. So there will be a couple of challenges that you will solve with Enso starting from something very light going to something a bit uh more complex. So um let's say this is you a developer and you have an idea you want to get something on chain but to get there if you want to integrate some protocols you would have to do some of those integrations manually in in the regular approach that we have. So that requires

a bit of solidity well sometimes maybe even a lot of solidity. It requires audits and of course it requires weeks or months of development and auditing work and all along you just wanted that thing to get on chain. Uh and we're trying to cut this uh cut this path a little shorter and we do shortcuts. Um, so for devs, what we do, we are a cross-chain intent provider, meaning that you can call ENSO's APIs and say, I have my user has this token on this chain. They want it to end up on this chain in that vault or whatever. And this is all you really need to do in

order to get a transaction that does a bunch of swaps, bridges it, and uh deposits it into the vault on your target chain. For users, this is blockchain shortcuts because users don't need to know anything about at that point and they don't need to do anything around bridging, swapping, and depositing for them. It's just one of my tokens will end up on the chain will end up in a position and that's the the quickest way for them to get there. So this solves developer experience and cuts development costs and also for users it solves the user experience problem like you don't need to use five

different tools to get there. Now we're going into the technical part of it and we're making this possible via four APIs. Four groups of APIs. One of them is about routing and that's what you will experiment with today. The other groups of APIs are tokens or positions. So if you want to move liquidity, well there are positions you're moving from and positions you're moving to. And when you have routing, so finding the path and tokens, the things you're moving, you also need a way to express how do you intend to move those things.

And this is where integrations come from. So this is all the all the dexes uh that are in there, all the vaults that are that are present. And uh this is how you specify exactly what you want to get. And there's a little bit of APIs that gives you information about wallets and and TDL. So for us today, the most interesting part is the the the routing part because that's where shortcuts come from. So it's practically translating this idea that you might have. You take a token, you deposit it, you borrow, you swap, and you deposit again. So this is what for example

looping. So this whole process of doing something with the token in a couple of steps we can actually translated into a single runnable transaction and it's actually u executing crosschain with the route API. So this is like the the smart routing that optimizes stuff. um we're doing swaps, but there can also be deposits and redeems. So these three operations mixed in a particular way will actually get your tokens from one position to another and ENSO uh actually collects these and arranges them in such

a way and chooses the dexes and liquidity positions that yield the best routing results. So it's it's practically the best output for the user. And essentially this is like a little visualization. The only couple of things you need to specify are the input token or your origin chain uh the output token or your destination chain. And these blue dots represent those little operations along the way. So it is constructed for you and you don't need to think about who to pick, where to swap, when to deposit, what to withdraw, what's the primary, what's the

underlying and so on and so on. So in that sense, this is well solving a lot of developer experience issues that we're facing today. And this is routing. This is as I said it does something smart for you uh by optimizing the path but you might want to get in the position where you want to control exactly what's happening along that path and you want to add more stuff. Yeah. Um I'm going to come back to this slide. So there's also the bundle API which is pretty much route API without that optimization.

And here you can also have different actions besides redeem and swap and so on. There's also harvesting. You can add fees to those routes. You can borrow from uh protocols, repay debt. You can of course swap because that's like the first operations many of us did. And when you're creating a bundle that consists of these operations, you can also include a route. So you have a pretty let's say static chain of operations and then you can say okay and so but for these tokens do your optimization magic get me the best path to to a desired token.

We good here? Any questions so far? Uh yes. So when you're when you're bundling these actions, uh for example, swap will give you the amount of tokens it swapped into and then you can do a reference. I need to show you the code for that and and we'll get to that in a second. Uh so you can actually reference, hey, I want the output of the third action in my list and and to use it as as the input of my current action.

Thank you. Yeah, this jiggles and that's that's the bundle API. So again, a lots of stuff happening here. And as I said, because all of this is crosschain, there's a bridge action. So in the middle of that bundle, you can say now bridge to another chain. And after the bridging is complete, follow up with these actions. So you can continue moving your liquidity on on the other chain as well. and we need to talk about actions. So there's uh a bit more than 20some and this is a credits roll. I'm not going to read them. They're in the docs. So so

you will find them. Uh but that was it when it comes to to the to the overview. Now for all of us who like to do stuff hands-on, you can scan this QR code. This is the the intro to the workshop. So it will give you the necessary links and uh instructions how to well get uh get started to to do the next challenges. How many people will would like to do the hands-on stuff? Two. Okay.

You don't have a laptop. Okay. Um All right. So let me join the party then. All right. So, this is the workshop intro. The challenges, the individual challenges will be released as as we go along. And uh yeah, you see my screen. That's the wrong screen, I think. Let me just um extend the display.

Can I get a little help here? Actually, I'm good. Found it. All right. So, you see what I see now. Good. So, before we get into challenges, uh first couple of challenges you can actually do perhaps even on your phone. Uh because uh there's there's no code involved in those. it can be uh codebased as well because in this uh workshop we'll use three different things. One of them is happy path. So this is a little widget that we built

that actually allows you to move those things very very easily and this is something that you can embed into app UIs for the end users. So when you when you check out this uh intro page you will see the the happy path. Then there's the SDK option or using the API directly and a little help helper tool that you can use. Uh this little helper tool, let me just show it. So this actually shows you uh exactly which chains ENSO supports and this is this is the current list and all of this is really live. So this is coming from our

APIs and you can uh you know search for projects that are supported with the with their respective versions of of their protocols and the chains they they're supported on. So this is sort of useful if you want to uh dive into the the supported tokens for example if you if you want to find what's the primary contract what are the underlying tokens and also query based on on these values. So uh for example let me let me pull out all the tokens all the positions that have USDC and as their underlying. So, I would just say um

underlying tokens, paste this address. I remove unis swap and there we go. We got all of those. So, it it's a little query thing that can be helpful when you want to interact with particular specific protocols. But we'll come back uh we'll actually go back into into the workshop. And to get started, first you need to get the ENSO API key. So to do that, there's this dashboard button at the top. And when you click it after logging in, you will get an API key. And I will need to get a new key after this workshop apparently.

And then you can use it somewhere. Um people who are following along all good? Yeah. Okay. So, I'll copy the API key here and I'll just uh start a terminal session and zoom this in. And maybe I just Yeah, much better.

Okay. So, I'll just say I'll just export this key in my bash environment. And after doing that, I'll copy the first command. Let me get all of these into one view. There we go. So, I'll copy the first example. And the first this first example uh will actually give us all the things that we can do with a version 3. So I'll just copy this curl and boom. You remember that uh credits role that we saw with the list of actions

where here here are the the actions that are supported for a v3. So you have borrow and then you have the exact inputs which is pretty much like a type system description uh how to interact with this protocol via ENSO. And at this point I would like to just say uh one important thing. So borrow looks the same with a and with all other borrowing protocols. So same parameters even though implementations are different. So you can think of this interface as a facade to many different borrowing protocols standardizing the way you interact with them.

Any questions so far? Yeah. This thing on. Oh wow. So these endpoints that we're hitting, do they generally return signable data or do they like expect you to provide a signer key or like is there a standard format for the response you get from these things? Yeah. Okay. So, so this is just describing actions that that you can take, right? So, there's nothing to sign here, but the um but I'm guessing that you're asking about something like this. So, let's check out how how the routes work. So, you would call the API. Uh this is via

SDK and what you get is a route with a transaction object. So, in there there's the the recipient of the transaction. There's the call data and all of that stuff and you need to send that transaction of course from your wallet. So you need to sign it. So so this is this is translating the intent this token to that token with possible bridging into call data that encapsulates all of that. And what about the case for like e signyped data or something? would it give you some signable message as opposed to just uh transaction data? So,

it just gives you the call data and that's pretty much it. All right, any more questions? Okay, so now that we've seen this and um I hope everybody got uh their API keys um you can choose either to work with curl raw curl or the SDK. I prefer the SDK. So let me set that up. Um yeah, let me Let me just set up a folder.

Let me zoom in a bit. There we go. Yeah, PM Cam doesn't have that. Uh, and now let's say let's open VS Code here. Okay nice. Get this out of the way. So, I'm just now installing the Enso Finance SDK. That's the the second instruction you got in there. Uh, since we're using EMP, it should be faster.

And there we go. We we got that. All right. And I'll just create a new file here index.js and we can get this going. So I'll just put up oops an immediately called async function because let's wrap everything and from he from here we can keep adding adding the code tell me if I can move on.

Yeah. Okay. So, if that was the intro, here's challenge one. You can scan it. And I'll switch to challenge one right over there just in case somebody need a scan. Here it is.

Assuming everybody scanned it, let's warm up with a little bit of crosschain swapping. So here you get to choose your own adventure. You can pick your favorite chain and your favorite token. And when we say pick a favorite chain, it has to be one of the chain and supports of course. So, we we couldn't go with just about any chain. Let me make this a little smaller. So, I'll copy this curl request. And there we go. We got a bunch of of chains over here. Again, the same chains that that you would find in the in the navigator. And then you would

pick your favorite token. And again, this is the API that allows you to get that those tokens or you can do it via SDK as well. So, um I'll just yeah, I'll run this one over here. And let's say I want to go on base because that's the only chain ID I know about her. Uh something happened here. All right. So, this doesn't really look pretty. Uh, to to make things easier, I'll I'll come back here and I'll just say, okay, we'll go to chain ID base and

yeah let's let's take USDC. So, I'll I'll copy this this address. I will need it for later. And I'll just paste it over here back in my code editor as a string. So that's USC. Now you might have picked a different ch different coin that that doesn't matter. And let's move this. Let's swap it into Barra. So let's move the USDC that we have to bar chain.

So for that let me just go over here and do another search bar chain. Here we go. And yeah, I'll just skip the address because I'll copy it here. So there's the the Barra token and of course it's the native token. So, it's got the E address and let me paste that over here. So, now what we want to do is actually uh create a new instance of the Enso client.

So, it's just new Enso client and we need to pass two things. Well, the base URL is not really necessary, but we need to pass the API key that we got previously from from the the dashboard. So, I'll go back there and let me yeah, I'll just copy it from here. And yes, I know this is like a big no no, but I'll paste it because this is a workshop and I'll reset it later. All right. Now that we have that, what would we need to do? Like this is a call for for discussion. What would we need to do to achieve this in in in you know regularly? What would be the steps?

Come again. Validation of uh yeah but without ENSO what would you need to do to do to achieve this? Yeah as a user. So so think of yourself as a as a D5 user you would need to bridge. So to bridge what would you how would how would your process look like? go to the bridge, connect a wallet, but which bridge?

Sorry. Yeah. So, so there is a little bit of thinking that that people need to do there. And I jumped straight into code. We'll come back to the UI later, but let's let's see how to do that with code. So, this would be get route data. And in here, I need to pass an object. And this is pretty much what we need to pass. So there's amount in and let's make it this much. Uh the chain in so we said base. So that's B A S E.

Uh destination chain ID. We want it to be on Vera. Now I need to look uh need to copy this one because I don't know it by heart. There we go. and the from address. Well, we need some sort of address. I'll I'll copy one later. Uh what we also need is token in and that's our USDC token out beer. And there's couple more parameters that that we need that we need to specify. Uh there are sensible defaults.

So I'm not going to specify all of them. Um, for example, yeah, we'll come back to that one. I want to to make this as fast as possible. So, let's just to find a quick address to copy to. I will actually, yeah, go to the examples here and just copy this one. This is Vitalik's address. So we can we can pretend uh we're him. And that's pretty much it. So I'll just say uh route is whatever we get from from this response.

And to see what's going on, let's do I'll stringify it and make it humanly readable. If I'm not mistaken, this is enough for us to to test it out. So, I'm going to do node uh indexjs and this should run it. Oh, all right. So, we get an API error because I forgot that when you do um when you do crosschain, then you need the receiver. So, so here I'm going to say well receiver and let's do the same address on beer chain that doesn't

really matter and it must be an Ethereum address. So now that we when we run it, it does some stuff. There's a lot of hex over here. That's the bite code that makes all of this possible. But here's the interesting part. So this will show you the route that is happening in there. So, so we it it does bridging via Stargate and it's taking in uh well this is the original USDC and uh the um native token and the token out is USDC right

and then when the bridging is complete we also need to do a transformation of whatever we dot on the output to the bearer token. So this is the the the the thing that we didn't express in the intent. So here we just said take token and transform it into into beer on bar chain. But there's also swapping that's happening after the asset gets bridged. We cool with that? We're not cool with that. Could you uh could you pass the mic, please? Oh, you got one. I just with the with the first bridge, you you started with an ERC20 and if you're going to wind up with an

ERC20 on the next chain, you're not going to have the gas to do the final swap when you land on the next chain. So, what would you do or what happens in that case? Um, let me ask you, what do you think? Well, I would think you have to swap first to native token, then bridge native token. Yeah. Then you then you have it. So I would expect to see swap first followed by bridge. Yeah.

Okay. Let's check out what these tokens are exactly. So the 833 that's that's our USDC and this is the native token that also goes to Stargate. And the token out is 549. Let's see what this is. So it is on Vera and the address is exactly what I copied here. So it's a USDC that we got after the bridging which got swapped into Barra.

Yeah, I'm slightly puzzled as well to be honest. Uh sir sorry. Yes. Yeah. And this is executing on Vera. So who's executing on the the swap on Vera?

Who's executing the swap on Vera? Um so this is not explicit over here. So so it's not naming a protocol. It's one of the uh dexes that are registered with Enso within the the aggregators that uh we rely on. So we could find that out if we took this and actually simulated a transaction. So we would definitely see what's what's going on in there. That's the best that's the best I can give you now.

Any other questions? Okay. So now that we saw that, let's see what's happening in the UI because where's my first challenge? Here it is. So you remember from from not there. Yeah, here we also mentioned there's there's happy path. So let's let's do the same thing visually. So here uh we're going to pick base and we said USDC right so there it is and we're going to take it to bar chain and we want vera token right so now when I

enter let's say 10 USDC uh what we have start is bridging it to USDCE and then swapping into Vera so it's pretty much the same thing. This is giving you a visual indication. So even if if you want to quickly check out how something would go, you can actually use this UI to achieve it. And of course, you can specify different slippage tolerance and and stuff like that. So this would be the way easier part that doesn't require any coding, but it's not repeatable. It's it's a manual process.

So if you want to do something repeatable or to create a UI like that pretty the the the route API that we just saw over here is pretty much all you need. Any questions? So this UI part uh this UI part this UI part is public. It's we created that and it's also an open source thing. So uh some projects actually built it in in their uh in their their UIs. So it's a solution that you can just paste and uh include it in

your uh interface. Yeah. So it's like plus this part that you Yes. Absolutely. So so this front end is calling all of those APIs that we saw in in VS Code. There was a question. Yes. So the question was if Enso has something to get user balances. So I'll just delete this one and get balances. Uh the only thing that you need to pass is well EOA address and uh yeah I deleted it. Let me come back and pick it up again

here. So in the examples over here, yeah, let's uh take this again and let me come back here. So the EOA address would be this and use EOA I'll set it to true and chain ID let's say one. So now when I run it oh but it didn't catch it and let's just console log it. So JSON

stringify balances null two to make it a pretty print. So the only thing we need to do is give it the address. Say that we want to use the EOA and the chain we want the balances of from and after a little while there you have it. So so you have like the complete information. What's the token? What's the amount? What are the decimals? What's the current price of the token? Um yeah uh what's what's the name of the token the symbol and uh you also get like the logo URL. This is live so these things happen.

Uh any other questions? Okay. Uh where were we? So so we saw that. Now what we we I I think we have time for one more example and then then some questions. So the second challenge would be to do a crosschain zap. So we we just saw a swap but what if I just want to enter a particular pool on a different chain. So if I if I have one E on mainet how can I enter curves three crypto three crypto pool and Uh here's three crypto. I'm going to copy the address. And of

course, these are the underlying uh for that one. And for this, I'm going to start with the UI first. So here I'm going to say I'm on Ethereum and I'll paste this address over here. And for some reason doesn't pick it up. Let me select the protocol. Yeah, I am.

Sorry, I got confused. We start with ETH. We want to get into the curve uh the curve pool. So we're here and the target token will be on base will be curve and will be tri crypto and this is why it didn't pop up because it's a different address. So now when I do that and say one e okay let's try 10 and there we go. So it would bridge it, deposit it into rep native and then deposit into into the curex. And again we can do this uh by hand practically with the route API or we can do

something a little bit different with the bundle API. So I don't plan to repeat writing the get route code again. I would like to do an example that actually uses those actions that I mentioned because we paid a lot of attention to them. Let's see why. Um let's uh switch over to something more challenging. Uh again, three crypto pool, but this time we have three tokens. How can we deposit them into into that one? What would we need to do regularly to to achieve this? So I have 10 D 10 USDC 10 USDT on mainet and I want to deposit into that three crypto

pool on base. Yes, this is a discussion point so everybody can just approve three times and deposit three times or or you could approve just one and deposit and and I think it will uh buy some of the missing tokens from the pool. That's that's a part of the the solution. Correct. But these tokens are on mainet and we want to put them in a base pool. Why they have to be br three time bridging and then after that three deposits if you want to deposit all three of these or you want to do some

swaps in between or or something like that. So, so if you have three tokens like this, the happy path widget actually doesn't work because it accepts only only one token. So, we would have to do something like uh using the bundling. So, so you might remember that I that I said you can pick a lot of different actions and put them as a as a sequence as a as a as a bunch of Legos. And who came to the stand today, you saw that there were Legos over there. So, so, so there's something happening in there.

And this what pretty much does, okay, this is a stupid example. It's got only one action. Uh, but you can put a lot of these actions and it transforms them into a single transaction that gets executed. So, I've got 20 minutes uh to create a bundle. Let's see how that that works. Uh, get bundle data. And let me just rename this one and move this away.

Um, so what we need to start with, uh, just a second. What's the first argument? I need my IntelliSense here. Uh, so the first argument are bundle parameters. So this is like the basic stuff. Chain ID. We're starting from that's um base. Did we say the second thing is from address? I deleted it again. Uh the third thing is routing strategy. Now uh in this case we didn't didn't talk about this one. Uh the routing strategy is actually super important because in some cases when you use this router option

that means that you're signing with an EOA. So some things are not possible. If you're using delegate, that means you're signing with a smart wallet. So 7702 and that that's what makes it possible to put uh borrow inside of this one, for example. So for some actions, you absolutely must use bundle and must use uh delegate as as the routing strategy. So I'll just put that in there. And yeah, you can there's also some other stuff that happens here. receiver. I'm going to put it there just for as a placeholder. And now the second argument is actually an array of uh an array of actions.

So our first action would be to bridge right and what we need to do is pick a protocol. So this is target because currently ENSO does bridging only via target. The next step would be arguments for for the bridging and that's an object. And here we have uh the token in u receiver primary address destination chain and so on and so on. Let me just think for a second if we need to start with bridging.

Yes, we absolutely must. And given we have 15 minutes, I'm fairly confident I will not be able to hit all those all those parameters. Uh so I will actually ask you guys what how would you like to use the following 15 minutes because I'm pretty sure you don't want me you don't want to see me trying to nail Jason. Yeah. Go ahead. is to get to start the questions from from now. Yeah, we can do the questions and we can solve them via code or docs or just verbally.

All right. It's it's fairly different from those examples. I'm wondering if Enzo can be used for like maybe less defy use cases like u maybe onchain voting. um set set up a context around it. So how do you see it? Um so basically having the same benefits as um you know using all these Lego Lego blocks to um build a voting application. Mhm. Um so personally I I work on at CL so we we are voting protocol.

Um, but I could think of other voting protocols that could benefit from from using Enzo, for example. Um, so you you could have um with an application that submits uh proposals or or creates questions. Yeah. Um possibly in a crosschain manner actually. Um I think it would be quite useful. Okay. And how would that voting work? Like I guess there would be a sequence that you want to automate as a single action for v voting. What would that consist of?

Okay, the quite clear specifics. I don't know if it's going to interest everyone here. Um in the case of clear, I could imagine a useful building block could be to create create a question dispute. um that requires some fees for that are going to be used to reward the the participants in that question who will vote on that question. Um so yeah, so there's a payment attached to the question. The question contains um some metadata and typically typically in the V1 it's on Ethereum on this chain. Um

but you could imagine you know an abstraction layer that allows um other applications on any chain maybe on base to send the dispute to be created on on arbitrum or on this chain. It would be very cool to do this with Yeah. And how do you represent disputes? It's um there's a JSON metadata that need to be uploaded to IPFS and then the IPFS C is part of the parameters of the of the function. Mhm. So theoretically I see that's possible as long as you have actions that are abstracting those mechanics that are that are

happening in the voting. Okay. So it really depends how you represent disputes, how you represent votes and if any of these actions can can work with that. And these are highly defy specific. So so I doubt that they're applicable. But the cool thing that's uh that's happening is that we're planning to open source the repository with these standardizations standards. So so people can actually register their own custom actions and then you can actually use them as as little Legos to to make those those chains of of actions and automate those voting. So it may be

possible in the near future to maybe in that repository and uh to add to like community contributed actions. Yeah, that's that's the vision behind it to make it community open for community to to extend uh as of deadlines. Uh follow our Twitter. Okay, thank you for the question. Could you could you just uh grab the mic please? Um, can the API key be in front end code or is it meant to be kept secret in the back end and do things through that?

Ideally in the back end. Yeah. Um, the the the the thing with the API key, I mean you are rate limited. There's no signing happening with that. And there's it it only serves to identify your front end that's doing something. Um, in case you have several front ends that represent your app, then you would need well to put it on the back end to tell apart which front end actually interacted with. So if that's important for you. Okay, cool. Yeah. But again, there's there's no mutation that you do to the data within Enzo. So from that

perspective, you might even keep it uh in the front end. But this is not the official advice. So the bridge you were using in the example is it a third party bridge or your own? Yes. So so this is a Stargate bridge. Uh and you might remember that when I when I was enthusiastic about doing it, I started with the Stargate protocol, the bridge action. And yeah, let's just take a quick look of how that looks. So, so you would set the destination chain token in uh a mountain in somebody asked the question, can I have dynamic values in these bundles?

Yes, you can. So, you can say use the output of call at one and this is the this is the call one. So, so you can actually pipe results of actions into subsequent actions. And uh so the actual question I was going to ask that was a quick question. So I see a receiver there. Is it the receiver of the funds on the destination chain? Yes. So and whose address is that? Uh sorry could you get the mic please?

Because this is live stream. So uh you can define it. So like let's say for example you have your own wallet you build an application and then that user wants to send the money to like another user for example. So you can literally set this you could set it to smart account you could set it to uh an EOA whatever you define and uh like if I want to bundle actions and do some additional action after the bridging uh it probably wouldn't be my EUA address would it? Uh yes it is. So well it lands inside of the ENSO account like the ENSO smart contract. Generally you don't need

to set that. You'll see like there's an option of like you don't need to set it. If you don't set it will go into the ENO smart uh smart contract and then from there you can decide what you want to do with it thereafter. But if you're signing with the NOA Yeah. Yeah. That's the point. Yeah. Yeah. So like ENT has got contracts deployed on all these different chains. The funds will land inside of there. Whatever actions you have after will be like all done atomically as well. We don't control that account. It's just like a intermediary contract to be able to bundle all these calls together.

So uh I could potentially take a look at this smart contract to make sure that uh only the stuff that I specified can happen to those funds, right? Yeah, exactly. I mean once you make any request to Enzo every by the way sorry for hijacking um if you want to cut me off you can don't worry um everything gets simulated twice so once you make a request we generate all the call data that you've requested to do all these actions we run it on forks so we run it on like replicas of those trains to make sure they're all pass itself so nothing should be executed without making sure that it would pass. So you can check

that and run your own simulation if you wish. So you could use we built an open source simulator called Temper that was used by Gonos's wallet, Gnosis Pay, H Gelato, Yarn, and Kwap. All all for free, all open source. You can run that on your side if you want. Thank you. Okay, thanks for the questions. Any other questions? All right.

There is a question. Yeah, by the way, really good job on the workshop. I like your pace and the overall uh you presentation. I got a question which is not maybe very much directly specific to the workshop but just generally since Enzo looks to be like primarily focused on developers and you're devil at Enzo. So I was wondering what were um and are the best practices for you you know in attracting the mind share of developers because we know you know there's a bunch of infra right now um and the attention is very much scattered everybody's fighting for developers. So what has been the most rewarding practices you guys are doing to attract you know the adoption and and the usage of of Enzo? It's a never- ending experimentation.

I don't have the best answer for for for any maybe there was something that you did that was like okay this worked. Um can I answer a bit? Yeah. We shipped two products ourselves. So we shipped a social trading product. We built a DeFi super app that builds some recognition in the space. Um then we realized all the problems that we have everyone else does and people reached out to us my language said how the did you integrate 50D5 protocols in day one like aha you all have the same issue here use our API the other thing that we found we're we're like the first mover advantage two people are now copying us to do the exact same thing which is really good for us they think it's not

but it's really good because they reach out to get people to use their API and was like, "Oh, but Enso does this. ENSO's been around for so long." So, if you can somehow get people to become competitors, it actually benefits you indirectly. The other thing that we done, sorry for hijacking again, um, is many applications. So, Versel, we copied Versel pretty much. The reason why Versel took off so well was they built many products themselves and just open sourced it. right now people can go to that and be like Jesus this Eno team you know NAD built it Demetri and our team built it kind of in a couple days but this is a whole product that people raise millions of dollar for and they've

just open sourced it um so that's kind of one gives more ideas and two gives more awareness of what you can build and yeah one is honestly hire a good BD as well um before I was doing it myself and then we hired a BD and that's kind of your part of every single conversation But I think the biggest part was building products ourself and showing how it can be used instead of a lot of these info products are talking about what it can do but nobody shows you what you can actually build with it. It's all theoretical in all words.

So this is the gallery of those products that we built. Dog feed dog fooding our APIs and figuring out how to improve both the the the interface developers have to deal with and and the way they work and uh how optimal they are. And I think that there was there was a couple of interactions with dev teams where they were like it's already done like in in in 30 minutes they would actually be able to integrate and so and and go along. Um for for some of these uh the actual heavy lifting the DeFi stuff was not that super hard. The super hard part

was the UI. So that that also speaks a lot. So my my point of view is do a good developer experience and show devs the power of it. That's pretty much what it boils down to from de from the devil perspective. The other sorry to the other thing we notic is we just build stuff right like some of our competitors they just talk blah blah blah blah blah we just integrate the protocol we send the protocol and be like this is a really interesting thing you know privy got acquired right yeah the founders really smart if you get in

a call with privy what he'll do is he will show you how to integrate privy in your application on the We do the same. So we add your D5 protocol before we even have a conversation and we get in a call and we show you how it works. And that's like, you know, compared to other people that just say, "Hey, you could do this." We show you on like within the first five minutes and you're sold in 50 minutes straight away. Okay, I'll leave it to you. Sorry. Thank you. This turned into a panel, which is also exciting. Uh, all right.

All right, we got two minutes. Time for one more question. Oh, there's a couple of questions. Yeah, technical one. I'm just doing the in get balances, but I'm not actually getting any balances and stuff. Did you call will help? All right. Any Yeah, go for it. Could you please name one or two examples of uh the bundles which are most popular amongst your clients and what types of entities these are? Is it like taxes? Is it B2C users like Yeah.

So, so the most popular ones I didn't do the research but looping is one that's fairly mentioned fairly often. Also rebalancing as well. So when you when you go to the docs here in the build section, there's a shortcuts library. So there's this uh smart routing examples and there's also the examples of um stuff people use bundle for. So you you you get staking pipelines. Uh you get leverage positions which is looping essentially uh you know stuff like that.

Um so you can explore what's what's in there. I don't know which one is the most popular, but you you can get, you know, the sense of the most common ones and and how to get started there. Okay, thank you for the question. It feels like Yeah, go for it. I I I'm not familiar at all with the um the cryptoeconomic side of the how the network um executes basically everything that we've seen in in code. I I've just saw that there are validators. Um so maybe from a maybe defensive point of view like how do I know that uh someone

is going to execute according to my specifications uh those actions? How would I know? How would I know if someone actually doesn't and what happens to them? Yeah. All right, Connor. The conversation. Um, so what you read about the validators is like the decentralized network. Only today we started phase one of the decentralization so people can like add to the network. How do you know what we respond is going to give you what you ask for? One, we simulate it. Two, we give you all the call data. Three, we give you each step by step. And we open sourced our simulator. So you can run that yourself

to double check or you can plug into tend API for example. The other method that we're doing whenever other validators come into play because we're the only people right now why we do that one just faster to market test idea blah blah blah. Um they will have modules inside. It's like a shared library of hey I want to inspect this call data for any delegate calls happening any approvals happening any transfers to unacount accounts that weren't asked inside of the request itself. So it's kind of like a checklist itself. I would say to be honest the safest way of doing this is simulate it on your side. Um like you can trust us because we've not

lost any money so far. Um but again you know the back end being hijacked is a risk right. Um but yeah there's we simulate you can run those simulations yourself and we don't we don't ever execute by the way just as you give me the cool data then I need to make sure before I execute myself. Yeah. Yeah. I mean a lot of people they we give you all the response data they use that to present to the users. Um there's a bit of trust element inside of there, but proof is inside the pudding. We're not going to take the funds, right? Um and you can check the step by step yourself.

Thank you. All right, we're a bit