DappCon 2023: How To Deploy A Solver? - Felix Henneke

Transcript

welcome everyone my name is Felix I'm a researcher at C protocol and today I will talk about how you can become a solver for a car protocol um my workshop will have roughly three parts first I will give an overview of what cow swap is what cow protocol is what a solver is um and maybe motivate you to become a solver the second part is about building a solver so I will try to do some live programming I hope it works um where I will basically show you a solver template that takes care of a lot of the

boiler plate of building a solver um and yeah I will just add a small dummy solver and show you how you can then later um yeah use that template as well to build your own solver and the third part will be about the steps that would follow so if you have built your own solver what are the steps to actually participate in the real production competition on car protocol so how to actually deploy a solver um let's start with cow swap um who of you has used cow swap before

um who of you knows what the solver competition behind cwob is more or less uh who of you has maybe already tried to implement a solver okay so only people from C protocol essentially and um okay and another question is someone here in the business of liquidity provision or somehow building a DEX and not necessarily yeah building a solver Okay no Okay so then yeah hopefully you'll

all learn in this Workshop how to go from knowing about the solare competition to actually maybe implementing a s yourself and um yeah okay so you all know C swap so I don't have to talk about that too much I mean it's just a yeah yeah UI for swapping um currencies and the UI looks really similar to what the competition does 1 in or um Unis swap but behind the scenes there's a lot more going on um so behind the scenes we are not um yeah creating directly a transaction from your swap um in intent but we collect intents so other people who come

to for example C swap but also I mean maybe use other means of providing us with their intent we collect it we um create what we call a batch auction from it so essentially we we create an order book with all the intents this order book and yeah some some additional information is sent to entities Rec call solvers um those solvers compete for providing the best execution to our users um and in the end one of the servers wins and that I mean what what yeah the the execution they chose then

actually transmitted on chain so there's a lot of stuff going on we collect intents and you probably have heard a lot about intents already on uh at Decon I'm not going going into detail on that part then there's the middle part um where yeah we have an order book send it to solvers and they try to find an execution or try to find to or try to fulfill those intents and the second part is what we are going to focus about so suppose we already have some order book um what does it mean to yeah provide us with a solution um how do we yeah choose the

best solution maybe and um yeah how it is then later ending up on chain is is not really the focus of the talk um okay what do we mean by bch auctions and what do we mean by a solution to bch auction and solers are then those entities who provide Solutions um so what what do we mean by a v option um what you should think of is an order book collecting intents of users who want to swap tokens but it's yeah I mean it could be just a really

simple order book containing only two intents to trade represented by Green errors in this case one user for example wanted to sell die and uh want uh who wants to buy e and another user maybe wants to sell e and buy car tokens um so we we collected the intents the solver gets those intents this order book and now what what is the solution and what TR sers try to find is yeah counterparties for those intents so they want to satisy those intents and one really simple thing a server could do is just pick one of those orders not all of

them just one of them and try to meas it directly using some balancer pool or whatever so that would be represented in magenta here one of the user intents so decides okay that intent I want to satisfy just directly by matching it for example using onchain liquidity using an amm Balan Unis swap or whatever or even private liquidity um this is what happens to some degree with competitors we just look at individual orders and try to match individual orders maybe using more complex route but um okay that's what the competition can do as well what is yeah special about car protocol is that

we have batching so soers can provide settlement or yeah can can try to satisfy the intents of Traders on our platform simultaneously so multiple intent simultaneously and and one yeah way to also satisfy maybe both of those trading intents is to close this third leg here and create a ring trade so someone selling East for cow or let's start here someone selling D for East someone selling East for cow and maybe some amm selling cow for d That's a way to also satisfy those two

intents but it's potentially more efficient because yeah it can satisfy both intents with just one amm inection so this is what what some other solver could propose and um yeah the the proposals of the solers can get way more complex just one example instead of settling directly those two intents by going from cow to die someone else could yeah propose a more complex routing because maybe the cow usdc pool is deeper than the cow die pool and then um yeah yeah swapping those um stable coins might be I mean frictionless essentially

um so some other server might might propose such route and what we then do is we collect after we have sent the solvers some of the order book they send us their Solutions then we yeah pick the best one and um this gets executed so we pick the best solution and yeah the the sober Who provided the best solution is also rewarded for that um there are some rules around what is actually allowed as a solution and also yeah I mean just I mean the the the most obvious would be I mean users sign an intent to trade where

they essentially say I want to swap die for we but um the exchange rate has to be at least as good as this so um and I mean the the yeah the the execution proposed by Sol has to satisfy that for example um one additional rule we have that um yeah um leads to more fair executions and also me protection that is not yeah yeah so easily done if you don't have bch auctions or it's um yeah it's a thing we have to want to enforce if we have bch is that there's one price per token so all users trading on the same token pair for example get the same

exchange rate which immediately makes um yeah sandwiching aex within car protocol impossible um and yeah also leads to some other nice properties with regards to MV protection um and there are some some more rules um more subtle rules which you can find in the in the documentation what we yeah yeah what what the the routing or the matching of the the server sensors has to satisfy to be a valid solution and then in the end there's still a problem of yeah choosing the best solution that's also a bit of a way concept maybe and um yeah the implementation is a bit subtle but really think of who provides best prices

or if multiple orders are involved it's not just prices but who provides most Surplus so in the sense of if you have a lot of sell orders who can provide more buy tokens um yeah compared to the yeah limit exchange rate they specified and that's collected over all orders and then who who yeah has most total Surplus or provides most total Surplus to users um wins and okay that's where the magic lies um finding routing that actually provides users with most Surplus and then there's sometimes a trade-off between maybe just settling one order can already yeah provide a lot of

surplus maybe yeah closing the ring trade is more efficient because you only use one amm and can can fill two trading intents maybe using more complex routing is better but that might also increase gas costs so there's also some yeah some inefficiencies introduced by more complex routing and yeah in the end it's a I mean mathematically speaking really complex problem there's no simple algorithm for for finding the best execution and that's why car protocol outsources this um yeah finding a solution to yeah this decentralized solver competition where every solver can come up with their own algorithm and yeah in the end we just

compare Solutions so we don't try to find a solution we just wait for you to send us Solutions and choose the best one um okay so that's how the yeah the the general idea behind the stare competition um and now I want to yeah go do some live coding of implementing a really simple solver and if you want you can also follow along so there's a GitHub repo for for those interested um where the yeah you can scan the QR or it's C

protocol SL solverus template minus Pi so it's a solver template implemented in Python where you can yeah where will show you where you have to add some some functionality to actually make it a solver but the yeah all most of the boiler plate is already there um and okay so let me go to that um G repo and show you how to how to proceed with building a solver um so this is the GitHub repo um call protocol solver

template Let Me Maybe make it a bit larger and okay so one thing is clone the repo um and after you've done it I mean you can either run it using yeah python directly what I'm going to do is use use Docker to run it so I'm essentially copying that command to build a Docker image of the code that is already in the repo I can run it yeah like anyone would would run a um Docker image and then we

yeah I will explain where to add some functionality for the actual solve so let's copy that and add it here so for me it's a bit faster because I already built it before so for you it might yeah fetch a python Docker base image then install some requirements and um yeah then um yeah you you have a Docker image you can run um and let me run it I mean okay then you can run it like this

here and let me um how was it called it's called test image um that's it

okay um so what this does is it starts an HTTP server on some port and um to that server we can now send order book Jason's and hopefully by the end of this Workshop it will also return something um um okay let me briefly show you some of the code structure so to just give you a really rough overview so this um yeah Docker container starts a server which has a few um end points so yeah checking for

health um getting notified about results of auctions or how how the auction we sent was ranked but what is most important to us at the moment is this solve endpoint so using that solve endpoint we can receive a Json containing the order book and maybe some additional information some meta information information about um the state of some um yeah Unis pools for example and then what this does is um yeah it um passes the request into a bch auction object and um so that's yeah we won't change that uh today and then it

potentially solv something so let's comment that in um and then at the moment it just Returns what we call trivial solution so it says no orders matched and um that's it and then it returns that thing um and okay let's let's save that and uh rebuild the docker container and run it again so we have a yeah um yeah this HTTP server which processes adjacent called some solve function that

function at the moment is not doing anything that's what we're going to fill and then it creates adjacent file that is returned as as solution of the BET option problem so what we're going to do is we we're going to fill in some simple method for the solve so that it actually does something with the order book um and yeah then return yeah the solution in in in the correct format so okay to repeat what you have to do is look at this solve endpoint Implement something for the

solve function and then convert it to the correct format to um yeah to yeah to the correct solution Json format and there are some yeah I'm I'm yeah going to try to implement a really simple solver now just just a dummy solver um feeded some test instances and see if the solution that it returns makes sense um show you how to run a local test environment that already colle let yeah fetches correct or the the actual order books from um yeah that that are also used in

production feeds it to our solver and then okay we can see what it returns locally um and um yeah that's I mean the goal for this um live programing session um and okay so there's already a lot of additional code here um yeah won't be able to explain all of that but there are a lot of utility functions you can use um to yeah to make writing the solver a bit simpler um what I'm going to do now is try to write a really simple solver that just tries to I mean just goes through

the order book looks if there are two orders in the opposite direction that can be matched directly with each other and if that's the case return that a solution otherwise return nothing so um this self is an order book instance um and okay has some Fields what we interested in now is orders let's store that in orders and what we're going to do now is Loop through those orders and try to find a so for order I in

orders so this is not the most efficient way to do it but just to um yeah to give you an idea of how you can work with orders how you can yeah try to create a solution um okay so we have yeah we are looping through all pairs of orders and now we want to try to find a match for that we could for example um use this yeah order I type and maybe explicitly ask is the buy token uh is the buy token of order I equal to the sell token of order J is the sell

token um or and yeah and and vice versa um what we can also do is use to make it a bit faster to use some yeah utility functions already contained in the code um to see if an order can be matched so there's a match type addition functionality that yeah you can can apply to two orders um and the result is somehow um an enum that tells you can those orders be matched can those orders be matched partially only so that should

be uh is it a match is a order match type hopefully oh let me check uh order match type and it's both filed hopefully um and okay so just a really simple cow finder if ERS can directly be matched try to find it and just for

debugging before we add more um yeah code on how to actually yeah construct the solution object that's just try to run the server with that code and um print allow moo um let's see okay and and now we have a server that does something at least prints a mo if if there is an order that can be matched and now we can feed the test instances those how to feed test is also contained in the in the GitHub repo so

let's just try that out um let's rebuild our Docker run the server and now we can look at the GitHub repo and it contains somehow yeah a command to just curl it some auction instance also contained in the gabo so I'm just going to copy that it's a really small um yeah order book instance that is somehow designed to be easy that contains two orders that can be matched directly and hopefully if nothing went

wrong the code will actually produce a moo will still retain return the trivial solution the EMP solution we didn't change that yet but it's just at least detect that there is a potential C okay so we have our web server running we try to feed it um or the and there's weight order match type you have

what ah okay a match type so um I think it's it's here or order or match type [Music] um okay hopefully that works otherwise um yeah I mean there's

also um pull requests on this GitHub repo for yeah for for two simple or one one server that essentially does what I'm doing here and another one that just tries to match an individual order to a Unis for pool but let's go back to the code um and let's try to run it again um and now let's feed it the request um what it Returns what we see here it returns I mean I also print the return so it's adjacent but it's yeah contains

yeah it's not an empty Json but it contains no orders no prices no amm and so on um so it yeah returned the empty solution and um here we should see a move okay because I did this inefficient um double Loop it finds a moood twice um so at some point okay after the first one it should just return so it only finds one move um okay but then okay when after we found a move we can yeah actually construct a solution now that matches those two orders where we have to specify what are the amounts that are exchanged between

the orders what are the um valuations of the different tokens um that um yeah Define exchange rates and yeah let me let me yeah maybe I just copy it from from from somewhere to make it a bit faster and I I mean go through the code and what it means um so what this does now is okay

after has found the cow uses the execute method of order I and J and just sets buy amounts and sell amounts to the order or to the amounts of the matching order so that has to be done for for both orders um so there is one part that is important for the solution servers return to us that they specify which orders are executed and what are the amount s that yeah you propose to execute um and the second thing is that you also

have to specify prices that's not so important in the case of just a single cow um because yeah they just trade one to one but if there's a more complex I mean maybe a ring trade between users or um yeah yeah more orders being settled it's important to actually set yeah the correct valuations for the different tokens and what this code essentially does is okay token a is the sell token of the first order token B is the buy token of the first order and then you set this yeah the values for this dictionary self prices

for the different tokens for token a token B and set it to yeah in this case is the sell amounts of the different orders which yeah if they are matched one to one Define the exchange rate um and that can be coded or is encoded using prices um for example like this okay and there's already return here so we don't need um okay now we have implemented some Logic for after we found the cow how exactly are which orders are matched and

how exactly are the amounts these orders trade um and because we checked that the orders actually can be matched we know also that limit prices are satisfied um um yeah so that should result in the end in a valid um yeah for the solvers you write you probably have a more complicated logic at that point and um this solve method is where it goes next step would be to actually return that solution so we are still I mean we're

calling the Sol function so yeah they the batch object is updated there are now prices there are orders who that are executed with certain traded amounts and now we um I mean maybe rename this solution and now we have to fill some of those dictionaries in the Json with the actual things you want to do let me maybe first remove some of the things we don't need for now um but and okay let's keep the amm but we're not using any amm we're just

matching two orders direct directly with with each other and now we have to yeah turn that yeah the information in the batch object into a valid Json and those orders and prices are dictionaries um yeah let's yeah create those so for order in in batch orders if order point is executed so I'm I'm looping through all

orders now and what I'm doing is I'm creating a dictionary and that contains uh order ID as key and contains um the order as dictionary as value um yeah not going to go into detail on what the specification of the return format is I mean you can can look it up in our documentation um but yeah okay so orders is is a dictionary where we have keys or IDs and then using this

yeah utility function we can create a diction or the correct format from the object and for prices something really similar happens it yeah due to the values being stored in a slightly different format it's uh um yeah slightly different or let's maybe so we Loop through all prices uh Ed prices which is a dictionary so we Loop through all items in that so we have the key value Pairs and what we do with them is we take the key and make it a string

as as yeah key of this price dictionary and then contain uh convert the value to a decimal in string format um um so unfortunate or fortunately um the repo already contains lots of functionality around converting to the correct format so that you don't have to fiddle around with the yeah different representations as as okay so I guess I have to import that as well from somewhere oh no I have four no okay so that should

hopefully produce a correct Json format so let's rebuild the solver server and try to feed it the the instance from before it should find a cow should print a loud moo but also return some actually valid yeah solution that um yeah contains those to all us and matches them okay let's

see let's just send the same small example test instance um contained in the report internal server error okay ah okay yeah I actually should have imported that from somewhere um let's see so I'm not sure from where from let's do it like this um okay now when I send

the um order book to the solver it returns something um which looks like this so it's a Json containing orders that are contained in the solution and okay some some meta information on the orders but also what we call executed amounts so the yeah the actual amounts that you specify as a solver um this order to trade okay so we have built a really yeah simple small solver and um yeah one thing so how much

time do we have okay one thing we we can now try out is um run some of the infrastructure that cow protocol runs of chain locally to fetch the order book from from yeah from car protocol send it to our server then um yeah return a solution to our local version of the of of the order book and yeah see how this local server responds um and for that let's actually I can let that server

run what we're going to do is what is next in the GitHub repo connect to the order book and what I'm going to do is just run a yeah a Docker container um with exactly this um uh yeah this command here you can so let me copy um and okay there's no end file so this um yeah this Docker container uses as input yeah some environment

variables and at the moment so let's let's copy the sample uh environment variables so copy do n sample to. n and let's also have a look at and okay let's let's start the server it should start now and let's have a brief look at what the uh what is contained in this environment variable file um it contains the URL of the local solver I'm running so it's okay just um Local Host on Port 8000 it contains a URL for an

order book what I'm using here is the order book for the staging environment or test environment on uh gsis chain to make it a bit easier and and cheaper to try out stuff and um since it's a yeah test environments instead of swap. cow. um you can submit orders at barn. c.f so there's not that much traffic so you can also submit orders yourself and there's not so much noise so you can observe how your solver handles the your own orders you submit and yeah okay some some other information about yeah notes and um so the rest is not so important

um okay we have the server running we told it to send auction instances to this yeah to to some URL on some port and what we should see on our um solver server that we implemented is that it receives instances of of yeah of of the book and um yeah so you see I mean receives an instance every few seconds but never finds a cow because at the moment there are I mean we can we can look at the order book the order book on on this Dev environment on gnosis chain only contains four

orders and none of them can be matched in a cow and if they could probably some of the actual sers in production would match it so it um would wouldn't be there for long but okay what you see here is that at least our server yeah receives um yeah the order book sends something in return and what you also see is so I mean we we get those solve post requests but we also get um post notify requests so responses from the from yeah from the driver component or from the from the AUD component that tells us what happened to our solution in ranking and because we didn't find a

cow we always get rejected because we only sent the empty solution which is expected but now you could yeah I mean submit orders to yeah to the order book via b.c. F and um yeah potentially yeah submit orders in a certain way to actually yeah create a call create something that our server can also find um so in principle I mean we don't really have the time for that now um but yeah if

you yeah now go to this um testing environment b.c. um so there is really yeah a test environment but you can actually trade real tokens there on on gsis chain and if I just I mean do some Trade West to gno um I can confirm the swap I can sign it this is not a cow I mean it's just one order so to have a cow you would all maybe have to spam orders on the um West gno pair now um but you what you can already see is that

hopefully um if you look at the yeah this um order book component is that now there are five orders in the order book so before there were four now there's one order added and um maybe at some point okay the trade happen so now we at some point it's it should go back to four orders in the order book um but yeah I mean that's that's one way to try out your server locally where you already use the real order book but you yeah I mean you don't actually send solutions to to us or and what you send is is never executed but it's just to try out your so with actual real order

books and gnosis chain is yeah I mean there you can also easily submit your own orders and try around um um or try out some stuff you could also I mean if you change this end file use the order book from Main net and use some inferior node to um yeah to to fetch blockchain data to to let this a book run and then test your server with yeah with main net within main net order book Okay so

that hopefully helped a bit to give you an idea of how to implement a solver just from the technical side so start with the order book and um um start with a template with a python template fill in the uh we can switch back to the presentation um so the main things is fill in the solve method with some something that you come up with that is potentially more yeah more efficient or better than what the competition does so you can actually win the solver competition convert it to the correct solution format and yeah um that's already a good start to get you

running but what are the next steps um what I would recommend is that the next step is to contact the core team it's not strictly necessary but um for some of the next steps it is so I mean some of the contact information is on on c.f um a special mention goes to towards This Server telegram group where some of the production servers but also lots of people interested in writing solvers but also people who to maintain or develop uh dexes other dexes amm who want servers to integrate their liquidity so lots of lots of people in

their telegram Channel you can ask questions if you want another good place to to go is is Discord and um yeah so contact the core team the next uh thing is also I mean um probably don't have to tell you but the next thing would be more testing um one thing is um you can actually look at what the does so I mean we have an API for yeah for various things but one thing you can do in the API is actually look at um Solutions sent To Us by all the

solvers so if you have a yeah transaction hash of a finalized settlement you can um use our API to get um yeah information on the server competition and for this particular um transaction hash we I mean there's some information on orders and prices and so on but what's probably interesting to you is that there's an entry for solutions for this auction 10 solers handed in a solution and so they ranked by best solution comes last so then you see which solver actually

executed well which Sol had the best exec ution you see what call data they actually submitted to chain and okay that's public anyways I mean it's it's on the blockchain but um one interesting thing is that you can also look at what the runup did and what call data they provided so you can try to learn from what the competition does what type of routing they use or um they specialize on on on cows like like in my simple solver or um yeah so servers are free to do what what they want and there you can get an overview of what they do um so that's okay for that you don't

need to contact us but one really useful step um is what we call Shadow competition where you once you have a server that is somewhat reasonable you come to us and say Hey I want to try out my server then you give us a URL of some web server where we can send um yeah auction requests so those solve post requests um using really the production order book you send us back your solution it gets ranked compared to all the other servers participating in the competition and um yeah in the end you can see what would have happened so we don't actually execute anything um so

it's relatively risk-free um but that's a really yeah yeah uh natural next step after you have tested your so locally um one other thing that at that stage you should look into is um yeah what yeah what we summarize as bidding strategies or revert risk the mechanism we use for rewarding solvers is based on yeah it's an auction mechanism and um so it's based on how much you are better than the

competition and you can yeah for example also say that things like if you win you want to get paid at least this much um what is noteworthy is that if you revert so if you propose a solution it wins but for whatever reason it uses so tight slippage tolerances that it can't be executed on chain you will be penalized so there's a monetary penalty for not providing a solution that can actually be executed so at that point you should be yeah be aware of revert risk use bidding strategies where you

say okay I hand in my solution that provides lots of surplus but due to maybe the risk of not executing I want to get paid as least this much to make up for it if I win so yeah and at that point it becomes a bit yeah um yeah you have have to invest a bit more brain power into how you communicate to us what you want to do with your solution so it's not just which orders get matched to what but also yeah um yeah it's it's really an auction where you bid for getting the right to

execute another thing that is noteworthy is that there are some rules I mean I mentioned two rules like limit prices of the orders have to be satisfied so the intent has to be satisfied and all users have to trade with the same price on the same token pair there are some rules where we don't know yet how to formalize them into our smart contract and for some rules we don't even know how to necessarily formalize them even in in some offchain component um so we have some social consensus rules where that I mean that we don't strictly enforce before you send us your solution so we don't filter out your solution based on it but yeah if we see that you are intentionally um providing worse prices

than you could to our users um then yeah I mean you you can get penalized as well so um having a look at some of the the soft rules of our competition um is something you should do after you've tested the yeah the the hard Rules by I mean submitting Solutions and seeing if they get ranked um okay that's I mean probably not not a lot of news to you that you should do more testing but what comes after you have tested enough um how to actually deploy your solent production um what we do is we require a

bond from solers um why is that I mean solers get access to um funds in our settlement contract so for example we collect fees in our settlement contract from users to cover execution costs and yeah potentially a malicious solver could try to steal those fees so we have a mechanism to prevent that which is you provide a bond and if you misbehave we slash um it is decentral in the sense that if you actually are able to provide that Bond yourself I mean you can just participate I mean it's not no one can yeah the the cow da has to allow your solers into the

competition but okay it's a high barrier to entry I mean 500,000 you see 1.5 million cow tokens most servers don't do that or almost all servers don't do that what we also have is already existing bonding pools so one bonding pool maintained by um gnosis and another bonding pool maintained by the cow and what you can also do is try to um yeah make those bonding pools except your solver or vouch for your solver um but then the Bon cool can decide on additional rules and what for example the cow da bonding pool does is yeah it requires some light kway c um because our the cow funds are on the

line if s misbehave um they also have to show that they provide some value to the competition so we don't or the the yeah there's no value necessarily in having lots of servers who don't do much so like I mean my server wouldn't be added to to any bonding pool because other servers can do that as well so um what you typically would have to do is um yeah tell us that you want to join us we add you to the shadow competition and see okay can you actually win the competition sometimes you don't have to be super competitive but I mean you have to show that there is some value in you participating um and then you also I

mean yeah we we test you a bit more in in in this Dev environment for example before you we move you to production um and okay some some other restrictions as well so I mean you're rewarded for winning auctions but if you join this cow Dow bonding pool some of that reward will be locked for for some amount of time okay but that's somehow yeah after you set up your solver after you've tested it enough again contact the core team and try to be included in one of the bonding pools the simplest approach probably is to yeah try to be included in the cow bonding pool and um then yeah that includes additional

restrictions okay just to Briefly summarize um what I talked about okay I talked about what the solver competition is so solers try to match user intents as good as possible who matches it best wins um I talked about how you can build your solver starting from a template and the essential part is you only have to Define that solve function um but okay what you put in there is somehow there there's the magic and yeah that can give you competitive advantage and then I also talked about what the additional steps are to

production and now we have a few minutes questions and there's a microphone going around do you find that the majority um of the solvers that win the competition is it one or two or three solvers that are just far ahead of the competition or is it really quite well um spread distributed um yeah good good question at the moment we have around let's say 10 to 15 servers who participate the I mean just last last

week the I mean the sver who won most auctions won about 20% 25% of auctions so there are sers who win significantly more than other servers but it's not like 50% and yeah the server who got most rewards in the sver competition so rewards are based on how much you improve upon the second best um that sver won about um 10 to 15% of auctions so it's not just about who wins most auctions but also about who can actually provide most utility to users so the marginal utility provide upon the second best question okay how many bonding

pools are there currently at the moment there are two bonding pools one by the cow and one by gnosis um yeah we try to um get more s us to to put up a bond um but yeah it's it's a large barrier to to come up with the funds but um yeah I mean some servers indicated that they would also um create new bonding pools but at the moment they're just two perfect thanks hello um I know y made their own solver to make it easy to trade their

vault tokens and so my question was would that logic be in this solver here or part of the cow swap hooks or where those other kind of defi interactions happening to help trade these more complex um I think I mean you so I'm I'm not sure maybe I should refer the question to the to the backend people because uh I mean y y did it before we had hooks so potentially it's it's possible to do it differently I mean what I showed you is just this there are orders and you execute orders what you can also do is we send you some amm and you can say okay I'm I'm picking that amm and I want to trade this much tokens but there's

also a thing that I didn't show which is called interactions you add to the settlement and there you can yeah essentially include any call data so you can also yeah use um yeah other or yeah call other smart contracts for example and do other things besides just transfers of of ec22 but if you have further questions there are people in the back who who know all about hooks any further

questions um yeah if not then um yeah thank you for your attention I hope I could convince you to start searching for better prices as a solver so our users don't have to thanks