AXELAR VM

Transcript

foreign and we're here at interrupt Summit in Denver we're uh axler announced axillary VM here at the event this week and so we're gonna learn more about that understanding what it is and how can help developers build better cross-chain applications before we get started make sure to hit the like button hit the notification Bell And subscribe to get notified when I go live every week and remember that none of what we discussed here on the interrupt is investment advice my guest Sergey coming up next right here

[Music] hello how you doing hey good how are you yeah thanks for doing this yeah in this very special kind of live setup yeah um uh yeah it's always weird to be away from my home studio so I hope this works and uh it looks like we already have people in the live stream so congratulations on this event awesome yeah no thank you it's really impressive um a lot of people have been asking though if we've been organizing the event so so it's uh yeah the naming Collision is kind of funny but um yeah we I really enjoyed it I thought uh it was like good quality of people here and what was really interesting is that like it really feels like being here everything

that you know I believe is as far as like the multi-chain future and The Interchange is really sort of coming together at this event and the narrative that the event is uh is really pushing forward it sort of aligns with that um what were some of the big highlights for you yes I think for me it's been actually really surprising to see all the different ecosystems come together yeah and talk about interoperable future right so I think over the last you know a few years or the last bull cycles we always see a lot of talks from different layer ones different software Stacks you know like the stack is best the stack is best and so on and so forth and we should continue to innovate on those things there's still a lot of work to be discovered but I think understanding the problems that the developers in the

industry has towards the or right now that everything is super fragmented yeah that actually creates a lot of friction for the developers it creates a lot of friction for the users and we as an ecosystem if we want to scale like that has to be solved right yeah and that's that was really the core objective of this conference is to get everybody together and say look like you know we can talk about the same you know thousand developers has been shuffled from one ecosystem to the other but at the end of the day our job is to grow right and understand uh you know show to the people the power of the technology behind blockchains um and that means actually working together on um some common problems what were some of the big trends that were discussed here at the event yeah so a lot of the talk has been

around um kind of basically how do users interact with different different blockchains right so you know just now we had a panel um across different layer twos right and uh in there the question is well you have you know if you use them as a as a token across all of these different uh layer twos to power gas but what does it mean for the users we just still have to like bridge that eth from the main chain to like your Layer Two right uh kind of a flip the wallet switches and things like that so I think a lot of the talks about how do we abstract the way the user complexity so there are things like account abstractions that you know a lot of developers are talking about um and uh yeah kind of Build The Better applications using those Primitives yeah I think a counter abstraction is is a

really interesting primitive that is really needed and yeah there's been some amount of account abstraction through wallets like like um Argent uh you know in the last couple years but I mean these were just really the the beginnings I think of what account abstraction can be right I feel like with a crown abstraction the idea is the the the outcome is really interesting essentially sort of you can tokenize an account right you you can you can turn an account into sort of an a non-fungible asset that can be transferred it can be you know uh you could be sold right like you could have a company that holds assets and that that those those accounts would hold several assets and they would be sold to someone else like how do you see account

abstraction really you know sort of turning on its head the idea of the wallet and like this thing where you have private Keys you hear that private key and then yeah yeah I mean you know you're probably still going to have some notion of a you know private key somewhere right because that's that's what gives you the ownership right yeah any type of identity that you have in a blockchain um but I think the the point is that how do you go back and interact across all of those different chains right like do you pay gas in multiple currencies right how do you interact with one ecosystem versus the other and so um I view account obstruction as a server a step forward for the users at the end of the day right do you think that in the end doesn't it also diminish the um

the importance or the sort of some of the security uh assumptions we have our own keys because with account extraction you could essentially have like as a user it just as a basically as an individual right you have an account you could have you know several Keys sort of in a sort of personal multi-sig managing this account and so therefore the individual security of any one of those keys and like storing the seed phrase like it sort of diminishes the importance of you know key security not that key security is not important but like you can sort of spread that risk across different keys in a way that's not necessarily possible now yeah so no for sure right like I actually view that the credit security policy around accounts is something we still have to innovate around a lot a lot right so for instance you go to you

know you go to your bank account okay maybe you set it up there's all kinds of security deposits that authorize a certain number of transactions that you do right certain volume of transactions that you do per day or per week right if your account gets compromised there are various ways to recover it right so we don't have any of that in the blockchain because there's one wallet you know you lost it you're kind of done right uh and so by yeah effectively programming a lot of security and access control policies yeah in those accounts we can create something that's uniformly used by the user across all the different ecosystems gives them better security but also gives them recovery if things go wrong right and that cover it could be because you set up your own like you know multistig or uh kind of key splitting it

could be because you collaborate with some entity that may be providing like a you know backup recovery if you don't touch your wallet for like a month right and in an emergency situation yeah so you can actually code very interesting like policies around those things now yeah no I think it's yeah I I think that in the next cycle in the next three or four years like account abstractions is going to I mean for one I think it makes uh asset custody just so much easier for users right I mean the the opportunity to build really interesting sort of things like this right where you actually abstract the account away from recovery and ownership and like these sorts of models will just create really unique and interesting products for users for for companies for like any type of

um yeah any type of person or a company that wants to interact with crypto have products that are going to enable them to do that depending on the use case you know the amount of assets you know the the value of those assets Etc and adjusting for risk so yeah I'm pretty bullish on that uh for sure on that whole front um yeah so we last spoke in in September uh Lots has happened since then so maybe it's just giving a brief update on like where XLR is at today and you know you know obviously like you've announced the VM uh here this week but um since uh since September yeah I'm in high level you know last year the network has gone live with uh connections with all kinds of different chains right so we connected over 32

networks throughout the stack everything from a lot of evm chains a lot of Cosmos chains they're all interoperable you can send messages back and forth you can send assets back and forth you know processed you know over 1.8 billion I'm gonna cross chain uh cross chain volume like hundreds of thousands of requests have been served and uh we are working with a lot of developers to think about how to build future chain native applications right so leveraging things like account abstraction leverages things like you can pay you know on one chain uh or submit your transaction one chance to execute it across multiple different systems so I think as we've been building I think we're just covering that there's a lot of infrastructure pieces that are missing right it's not just about you know interoperability protocol that you use underneath it but it's actually the

whole interoperability stack that needs to be built right yeah so the last you know six months in particular we spend time both think it the network layer what has to happen but also what are different services around the network that need to be instantiated to enable experiences like we talk about here and simplify the developer build outs across multiple ecosystems this is something where we've seen a lot of problems where as a developer you know first you got to pick chains right this is like a hard problem on its own yeah and then you think about how do you actually build on the on all of those chains how do you deploy your contracts how do you manage them across all of those environments so still a lot of fragmentation still a lot of kind of complexity that has to be abstracted like what what is the

what is the most important uh uh thing that needs to be abstracted if it's not account abstraction and what are some of the pieces of the puzzle that still have to get built in order for the developer experience to get better and yeah I mean the first one which is you know pretty Elementary and it's getting solved right now but the notion of having like interchange native tokens right so right now a lot of the tokens you know you issue in them one chain then you maybe you pass it through one Bridge maybe another Bridge you get like wrapped versions of different chains users are just completely you know fed up with all that experiences right so um you know through the actual stack we'll build things like interchange tokens where you can just go and deploy a token it's available across multiple chains right away it has you know mint

and burn functions which are kind of a pretty secure you can have all kinds of additional security uh checks on top of it and really have like a uniform token that has one representation you don't need to wrap it into any other formats it can be displayed very easily in the wallet and then you can like sum up the balances right of all the different uh chains that the user has this token on and just play like one number yeah so I think that's like as a building block something um you know we've seen um kind of a lot of demand for and we try to automate a lot of it is the idea here because we talked about this last time we talked about the fundability right you know problem with bridging is the idea here that tokens would be instantiated or like they would be

deployed on XLR and then axillar offers the security guarantees to then deploy them on other chains like it sort of initiates on XLR yeah so the token is not actually deployed and actually we think of XLR as kind of connectivity tissue but actually will allow you to instantiate and deploy that token across any other chain that you want and actually we'll connect them all together so they function they function as one so you can think of it as like you know you know like your C20 format right it's pretty simple there's a transfer function and a couple others and uh we extended with a couple more functions that allow that token to be chain agnostic right so you can send it around so when you so practically speaking let's say I'm launching an application I have you know I want to have my token on

ether and in the IBC ecosystem or maybe on Solana right I I deploy I mean like there's like a there's an instantiation event that happens on axlr those those tokens would be native tokens on each of those chains that's right uh in an axlr acts as the I mean they sort of Ensure fungibility between them so that you don't need to have a rap token exactly okay that's really interesting and you can extend that right like so today you deployed it on you know five chains and tomorrow you want to have access to five other chains you can extend that without again creating this additional fragmentation right so they'll still function as one so you can expand and Shrink them as you want okay and so as you're moving tokens between say chain a to chain B axlr is asked is acting there as you know the

I mean essentially sort of burning that token on the XLR layer and ensuring that over on chain B it it it gets minted in the same way that say like IVC words yeah so the token still kind of gets burned and minted on the edges right on the chains that will connect but they actually used as the at the station layer right or verification so right you know you send your token on that what we call is like a Gateway right on the source chain yeah and actually will verify that has been correctly burned and then authorized authorize the corresponding action on the destination chain so it's all just message pass it's all just message all right that's really cool yeah and so how do you how do you think about stuff like you know because obviously where this starts becoming complex is when you have

multiple standards so in in Cosmos and ethereum for instance that I'm pretty plugged into you know they've mirrored each other's the rc20 it's the ics20 and the 721 and over on both chains other chains are going to have I'm not like super plugged into Solana but I you know I imagine that that token standard is totally different and so so for nfcs as well uh do you guys do like you know standard compatibility between those chains so that the messages actually do get routed and yeah yeah that's a great question that's actually one of the core you know uh Services of the excellent Network provided it's what we call as message translation right so uh if you send a message from an IPC or

Cosmos chain that has its own kind of a packet format how do you then translate it in a packet that can be executed on evm chain right or a move chain or something else and so the network itself has all these translation properties at the core so it does them like efficiently uh in a in a secure way and uh from a developer's perspective then you don't have to think about those things right so you build you know in solidity like using whatever erc20 standards you like yeah if your token needs to transfer or needs to go to a cosmos chain the Excel network will take care of it right so you don't have to think about and then on Cosmo side you receive it or some other user receives it they interact with the way they like right because it's encoded in the format

that's accessible to that ecosystem I mean that's a lot I mean that implies a lot of a lot of Integrations and and also you know there there may be token formats that I mean nfts and sort of regular tokens are yeah you know pretty standard but like some chain might think I don't think about regen for example yeah regen has a token standard that they you know issue their carbon credits with I think probably there's something equivalent on ethereum yeah maybe Solana doesn't have that sort of thing right like so how does that so then when you're deploying say you've allowed that deployment you know as a as a as a developer I just wouldn't be able to deploy it on Solana or would you you know also encourage sort of building those token standards and other ecosystems so that we have

better standardization yeah no great question I mean that's exactly you know kind of back to the point why we we announced kind of the launch of the actual virtual machine right just to enable developers to kind of customize and extend you know things we can do or other teams can do around the axle or stack right so if there's a certain chain that has a different format um all you need to do is kind of write certain translators to that chain and then automatically they'll be able to kind of speak with the language that's familiar to all the other chains okay right so excellent can use as a as a uniformal kind of translator language almost like a Google translate right like you put one language on one side you can translate it to the other language that needs to be sent to to the

other chain um so we'll do some work of course around standardization right and helping uh the standard spread but with the actual virtual machine going forward developers will be able to to do that themselves okay well let's let's talk about it let's let's get into this axler VM so there's two parts to it there's the amplifier and the Maestro so yeah let's break that down yeah so those are what we call as like services that we want to launch with uh you know as the as the VM goes live and the basic problems we're trying to do to solve with that a kind of the need for connectivity across different Stacks right so you know right now a lot of connections are done at the network layer so there's validators kind of register to vote on events from certain chains then certain routing packets are

being enabled and then you can send packets back and forth across them how do you extend that to support more and more ecosystems and you know previously you would have to write like a module on the network layer upgrade every validator it um you know it's a pretty pretty delicate process right and so with the actual virtual machine effectively you'll be able to code those connections yourself and make them feel interoperable with you know with the rest of the XLR stack right so um suppose you know there's a connection to like a Solana that you want to build and maybe that connection actually leverages different Technologies like zero knowledge proofs or like clients you can plug them in right but the cost of making one connection to the actual Network you get to Route your package to all the other ecosystems that have been

interconnected through the stack okay so that's what the the job of amplifier is effectively you know help you amplify the work that you could do as a developer to build a connection to make sure it's not a one-off connection between A and B but it's really one-to-end connection where one connection can access and different ecosystems okay can you give me like a practical example of how an application would use this because yeah it's not fully you know I don't have a full mental model yeah so this is not uh for applications but this is more for like core protocol developers that are building layer ones on Layer Two okay right so as an example you're building your own chain yeah okay based on whatever rust language and some fancy consensus optimization logic yeah you want as you go to market you want to have connectivity with other ecosystems

you want to make sure that developers and users can bring liquidity over bring stable coins and things like that right so you know how would you do that um you effectively want to build a connection and so you can go and then instantiate this connection with the axle Network to make sure that as you go to market right as you keep on building your stack information in and out of your network can continue propagating right so this is a kind of a service that not something like adapt developer would use but uh you know kind of consensus or protocol developers roll up exactly okay yeah um interesting yeah just realize we're on the right on the wrong mic setting but that should be fine stuff sorry put it back on normal there

all right um okay so as an application developer or I mean as an app chain developer uh or roll up I mean like this is where it gets because I mean like an application is you know a settlement layer and potentially all the way down to consensus right so like sure you're what you're saying is this is not for smart contract developers but like applications that are building as a sovereign execution environment or settlement layer yeah or or if you're just building you know your own layer one or Layer Two right or roll up layer like a lot of them are actually you know some of them are application specific but some of them are general purpose right so we have you know the case things we have optimism we have you know arbitrum all of those are you know layer

twos that a general purpose and they still want to have connectivity right and so how do we allow them to do that in an easy and efficient way and so that's what the the kind of the job of an amplifier is on the network effectively okay and so then effectively so let's say I'm building my layer one I don't know it's like some D5 yeah one right like as a Cosmos app chain uh I want to be able to leverage liquidity from other ecosystems I would use the amplifier to deploy my you know a contract that would allow other chains to interact with my my applications exactly okay with all of your applications right so kind of right now the way the connections are established

across different chains is we we deploy this notion what we call as a Gateway right Gateway is a smart contract you can think of it as a router and so for me as it goes to one chain it goes through this router right and so in the same way you build in a new layer one you can deploy one of these gateways on it you can deploy you know corresponding Gateway on the axle Network and that establishes a connection between your chain and Axle Network but because axillo is serve a hub it has many other connections once you go through some governance process then your packets can be routed to any of those chains okay and like does does this I mean is this similar to this notion of outposts that a lot of chains in the cosmos ecosystem have been

talking about I mean essentially sort of building outposts on on other chains right like uh I guess I'm not quite what is an outpost well an outpost is like sort of so Mars for example they have this notion of outposts where like Mars orchestrates uh message passing between I think they do I mean between the contracts that are deployed on on different Cosmos chains and they offer I think they also have like a like a liquidity backstop um so that you know all those different uh sort of you know liquidity positions on other chains can can leverage in case there's like an issue or something like that is that the vision here or or is it is it more than that I mean for the amplifier itself kind of its core job is

to make connections right and make sure those connections are as secure as possible so at least you know what you described um I think it's uh it's sort of an application leveraging those connections right so like Mars is probably like relying on you know IBC or some other yeah yeah protocols um and so yeah the question is when you don't have IBC available right or other protocols how do you instantiate the connection to begin with so I would say it's kind of a lower layer primitive at the networking layer at least the sort of the the amplifier and that you know Master is slightly different so there's a question I wanted to ask later but I'm going to ask it now which is well I mean IBC is becoming more standard outside of you know the quote-unquote cosmos ecosystem right so there are implementations of IBC uh that are at

least being built or maybe even deployed on near and Solana and like Avalanche yeah and then you know it's possible also with with one slot finality to do um or at least in theory I've been told it's possible to do one uh IBC on ethereum um you know what what kind of role does how does axle's role evolve when you know there's essentially you know pretty pretty uh widespread adoption of IBC or you know it could even be that like the entire evm space has its own interoperability protocol you know Cosmos has IBC and you know you necessarily you don't necessarily need to deploy on every ethereum role because you can just do one and then your tokens will be able to to move and your

messages will be able to pass without yeah uh deploying on every single chain yeah so I think there's a big difference between a pairwise protocol that connects A and B and utility of interoperability in the space right so kind of the way we view axler is it's a service network right it provides various Services one of them is connectivity you know can talk about like amplifier which is like helps you with the uh interchained orchestration and Management Services like that and there are various services that need to be instantiated across the stack to make sure the applications can actually talk to one another to make sure tokens can be deployed across different environments and so on and so forth so we think of axiller and like the network around is really a full stack there's a network component to it you can instantiate connections to the actual

Network any way you want this is ABC you can plug in IBC right if you don't have IBC you can instantiate external validation if you have zero knowledge proof you can instantiate that right so um we are kind of a protocol agnostic for pairwise A to B and with trying to think about what are the network services or services on top of that where they have been built to actually then enable developers to interact across all these different ecosystems right right so you know one example across the VM chains we talk about account abstraction but today if you're using like any of the bridges anything else you have to have tokens on all the chains you have to flip your wallet back and forth the fungibility problem is not solved yeah it's not just something real but also like the wallet experiences and the developers don't know how to build

those types of uh you know wallets or account abstraction Primitives so how do you allow developers to submit transaction one chain that gets executed across five different evm Stacks today right you can't do that right and so there's like a service on top of the network like a gas service that we deploy that you can pay you know in a token on one chain and then your transaction will get executed across multiple different Stacks multiple different chains so it's over a step forward towards the account abstraction across all those different stacks and so that's how we always think about what are how would developers interact with these things developers not going to interact with the IBC I can tell you that yeah it's a low level protocol yeah the devil is not going to interact with you know cgp which is the kind of protocol that we built to interact with

um across different chains developers want much simpler apis they want much simpler experiences right and uh and that's what we're building um effectively through the stack what where's the wallet signal is because yeah I even mentioned the issue one of the biggest issues in crypto is wallet fragmentation asset fragmentation across the wall it's like I've got like six different wallets yeah and then on top of that maybe like one on my phone that's not the same seat as the one on my computer where in this you know entertain future where axelr plays a significant role in allowing in probability between different state machines um where does the wallet sit does it does it sit on axillar I mean like do

the tokens sit there or do they yeah it's not it's unclear to me there yeah so I think to me like the the reason the wallets are very fragmented is because you did not have interoperability infrastructure to make a chain of Master quality right yeah um so I think now with cerebraxo and a lot of the other interoperability Stacks that have been built you can actually build a wallet that sits you can Define change the one and set it on right you want to set it on the theorem grade you have a main maybe a count on ethereum but that wallet can interact with its you know kind of a versions on other chains right so you can have Smart contracts that are still representing your account right through account obstruction paradigms they can all talk to one another and from a front-end perspective be displayed as

one unified account for the user right so I think for me to instantiate these walls it will effectively have that have to come down to two again layers that have to be built one is this layer of account or cross chain contracts that represent your account across different ecosystems and then while it serves it Aggregates all of that in one way another and just displays it in a uniform way for the user and the user can submit transaction from any of these accounts and there's they actually function as one right so um I think a lot of the wallet architecture is going to be rebuilt over the next few years right um you know leveraging these paradigms yeah what what role do you think things like NPC uh uh you know will the end how will

MPC be integrated in in this paradigm yeah so I'm in NPC I guess you know for those that denotes like multi-party computation protocols right you know basically you can think of it as a kind of a you know either multi-sig right or other types of things yeah and so the question is uh how do you manage all these different accounts I think back to the account abstraction question um and the way to manage it by setting up multiple keys that could have different policies associated with them to execute these actions right so you know if you want um authorize your transaction from multiple devices and serve certain NPC or technology could come in to help you co-sign transaction across your phone maybe your desktop maybe like a ledger

device it's submitted as one transaction on chain and then it gets uh propagated you could have a secondary policy on that uh you know account through the NPC that deals with recovery right so if you lost your cell phone but you have two other devices you want to be able to instantiate a new phone so you can run through like NPC protocols to create another key um or you know if you lost two of your devices maybe then you want to call I don't know some entity right yeah for your friends that may have kind of an off-chain backup uh kind of shards from this MPC protocol to help you recover so so yeah I think MPC is a server Key Management technique that you can use around these walls to help instantiate them and but that's that

could still work with um yeah it could still work across different say State zones that are leveraging their leveraging axle are to ensure their token token compatibility across chains yeah yeah okay um yeah something that came to mind now is um yeah so this is mostly built with cosmoplasm yes the the M itself yeah yeah so it's a kind of a hybrid between cosmoasm and some Unchained consensus logic right so so far axillary and a lot of its building blocks have been built kind of by coding the interoperability functions at the consensus layer right so you can use it as a you know there's a finality Gadget what we call there's like a Nexus routing module that we're

that we have there's like a multi-party sign-in module that we have and so some of these building blocks actually need to be sort of composed with Cosmos and layer to enable interoperability to be extended further right and so it's a it's a stack where certain functions from cosmosm get will be extended to the consensus stack to enable for better efficiency so is it is the XLR VM essentially like Cosmos and VM but modified with hooks what Hooks do the underlying consensus or consensus yes interesting okay huh okay sorry I'm just like this is bringing up a lot of different a lot of different things so um this is a little bit what uh Cosmos and

VM is attempting to do I think to some extent right like they're trying to abstract away all of the cosmos module components and then I have hooks into consensus directly uh I mean because I'm off topic a little bit but uh yeah um and so so developers Bill applications in Rust like as they would on any other Cosmos and VM uh that's right yeah just leveraging the hooks if you need to uh but but again like yeah the the role of the actual VM is not that you build an application on top of it right uh it's there's actually two Services one is making connections and the second one you know we haven't talked about it it's what we'll call as an uh interchange Maestra to help you to help you deploy and manage your application across multiple chains okay

so there's no SDK or anything like that I mean essentially like you're you're providing contracts that people can provide contracts there is actually sdks that have been built so Cubist is one of you know our actual Partners that's built in nsdk on top of it to make it even simpler to deploy and build those uh kind of interchange native applications so um yeah kind of the security itself and the management piece comes from the contracts uh but um you know you certainly always have usually as an SDK to interact with those contracts on top of it and make it even simpler okay so tell me about this Maestro uh which is kind of like kubernetes for web three I think yeah you just drive it yeah so one of the problems uh as I alluded earlier has been that developers

don't actually spend a lot of time coding the application logic in The Interchange if you want if they want to be deployed across five or ten different chains they spend you know 70 80 over their time managing their deployments yeah how do I put my contracts on this chain how do I set up you know governance around it what does my upgrade path look like oh let me get some gas to actually you know pay for this stuff oh then I have to have a wallet let's back up this kind of a yes and so and then you repeat this process 10 times across all the change that you want to do but it's the same process yeah right uh and so kind of the idea for the master has been well how can we make it easier for developers to actually you know deploy their entry

chain tokens across multiple chains or build their application right and so again it's going to be you know a set of service contracts that are built on the axle Network you can think of them as deployment templates right that will help you take take you know byte code of your contract set up its configuration which change you want to deploy them on you want to have a great path for them do you want to have admin Keys behind them how do you want governance uh to look behind them so you can specify it in the configuration and then I'll just get you know pushed on all of those different chains if we automatically interoperable so you don't have to think about how do you connect another you know excellent Gateway how do these contracts talk to one another so it'll be all under the hood in terms of the orchestration setup

and the yeah the analogy that I make is sort of kubernetes for web2 been doing that where you write your template how you want your application to be instantiated across different you know databases application servers storage servers and things like that and then kubernetes helps you manage and deploy that and so in the same way kind of the the the master will help you deploy across different uh you know web free Stacks okay so again coming back to an example let's say you're Ave yeah right like Ave is on a bunch of different evm chains maybe at some point they're on other other execution environments yeah um then they would instead of having them manage all these deployments they

would have they would use the Maestro actually Maestro to deploy this you know their contract sets across all these different chains that's right um foreign does it also do Trends I mean like so if they were if they were also doing it on I say like a cosmosom Zone yeah they would also have to have a cause of Muslim contract written it actually doesn't do the translation into byte code for the other environments yeah so we don't but actually you know sdks like Cubist actually will help you with that okay so that you can write in a uniform like language right and from that language it will kind of serve a Cubist uh Cubist yeah yeah um yeah it's kind of a you know pretty pretty cool SDK that the guys are building right so that's the whole

problem has been you know how do you create a uniform you know uh application that can talk across multiple different um you know virtual machine Stacks right and so um yeah so we don't you know we want to do that directly we'll help you at the at the network and layer to translate the packets if you have contracts it needs to be deployed you know a layer on top of it that you can build and what chains are supported today for for deployments uh yeah so um right now it's good uh kind of the virtual machines Gone live on the devnet which supports you know all the chains on the devnet environment and then from there we'll kind of migrate to the test net and made that from there and you know and it'll be available on all chains right it doesn't get deployed one or the other

effects with everything that's supported by the XLR stack as it goes live it will be available but you have launch Partners I mean I know there was a bunch of launch partners that um yeah that were but this is just for the for the VM deployments or yeah so the launch Partners uh is specifically to help build connections across those ecosystems using the the amplifier Technologies right so you know like uh bass you know like ZK sync a bunch of uh you know Stellar um they're all need to have connectivity right and so kind of using the VM layer that connectivity can be instantiated uh simpler okay and and you get I think there's template contracts also that are part of this this VM like what are what are those

contracts for and like what how can developers leverage them to simplify their workflow yeah so depending on again like the different product right so for the amplifier those contracts would be like a universal server router contract right so basically once you build a connection from your chain to the axiller again you want to make sure that the packets can go to other chains already interconnected so you need to enroll with these like router contracts okay so this is like the router that routes those tokens that's right that's right tokens and messages right so that's one example um the second example would be like let's say you want to deploy your uh cross chain token right so it's maybe your C20 token uh you want to set up I don't know admin keys because you want to be able to kind of control I don't

know supply of this token right or be able to issue more of these tokens yeah so you can go to the acceler you know template contract you say these are my admin keys I want to deploy this contract on chain X Y and Z you know you invoke a transaction on it it gets deployed there the admin keys are set up there and then you know when you need to let's say upgrade or execute a command then you can come in you know sign a transaction the admin Keys uh outside if it gets kind of a propagated and executed across the across the different chains okay with with up with things like upgradability I can see where um like for instance yeah you know there's some there's some Cosmos uh contracts on say Juno for instance Cosmos contracts they leverage uh a dow to do their contract upgrades

because with a cosmosm contract you can have like an admin key they just use a dow admin key and then the Dow decides um how those contracts get updated if you're managing multiple deployments across different chains where would that governance have like how would you know you could have the governance on one chain but could you leverage uh sort of a a dow key to to manage this this upgrade deployment through axelr yeah exactly right that's one of the goals is that your your management or your functions that authorize you know upgrades could be executed on like one place yeah and then you can propagate that information across across other networks right um so yeah okay do you guys have like

template contracts also to facilitate say you know Community voting on different on different chains stuff like that yeah I mean we don't have those templates yet but one of the things we have done was actually opened up you know a grants program right a five million dollar grants program to help developers build those template contracts right um so you know we'll work with a lot of teams and uh uh to to actually think about what are the functions that they want to help you know manage and across these different stacks and it will provide some fun then it will work with the developers too to build this uh you know kind of a kubernetes in a decentralized way across the community what kind of things do you hope to see you know the developer community be like what what's what do you think is like

the low-hanging fruit that developers could be building anybody who's watching you know might want to get some of this grant money yeah no I mean I think governance is actually I think is a pretty cool use case right there's been a lot of like talks recently about like swap governance right and how that has to happen and uh you know what is the kind of great paths there and things like that um I think managing serve nfts is another pretty interesting use case primarily because there's no kind of nft standard across different ecosystems so you know everybody has like their own thing people are trying to standardize a little bit but it's still very very early right so figuring out like what is my you know interchange native nft platform slash management needs to look like I think is a pretty low-handed fruit as well yeah that's really cool I

mean it's a it's a pretty neat stack yeah yeah um how do you guys think of Mev uh uh we talked about this a little bit last time but is that you're thinking of all there um yeah I don't I guess I don't remember exactly what was my thinking uh when this whole class but uh I still believe probably consistently that nav has to be solved at the edges edges meaning like at the application layer yeah right um so yeah I mean I think the the reality is that kind of with more and more chains with more and more components with more and more asynchronicity across all of these different components if you want to have some type of order slash fairness it has to be so as close to the application as possible yeah right so you know

instantiating that at the edges is where I think it has to be done okay so you don't think that people will start building contract templates to mitigate Mev at the axillary level or I mean you can do that right like so because we have actually like a multi-party signing at the protocol layer you can use like a multi-party um you know kind of um threshold encryption techniques right uh to encrypt blocks of data you know decrypt them in a um in a consistent way across them people want to do that like sure yeah uh I mean I the thing with cross chain movie I think it's right now it's a great research problem right it's not something we have seen too much of I think we're still at the phases where we're building out these interesting applications that

actually have you know good throughput good user experiences right with significant volume where MVD is actually a problem so we should continue doing research I think around those topics right I think we should continue Building Solutions over them you know do we need them you know tomorrow or next month probably not yet yeah I think that's fair I mean I also agree that Mev probably needs to be solved closer to the edges and right also applications you know stand to benefit from solving that problem close to the edges where you know like value can flow back to users Etc right um yeah I wonder is is there is there a future where

like is there a future where XLR is also providing you know some form of security guarantees to change like I mean this whole interchange security narrative uh or you know mesh security since you guys are going to be connected to all these chains and all these Roll-Ups Etc yeah does that does that make sense or is that something that you see as a long-term vision I mean I think security is going to be more and more mixed right across different Stacks so you know in ethereum ecosystem you have a lot of um you know eigen layer types of approaches right that that use the ethereum token for security things instantiating certain applications you know within Cosmos valve interchange like mesh security right I think those are kind of a general trends that we're seeing more and more of where you know one chain can borrow security you can lend security

across from uh from another things get a little bit complex there frankly for you know security and other things so you have to be kind of a pretty delicate um so maybe you know at some point we have a kind of conversations with osmosis right and a bunch of other folks too kind of a borrowing land security across yeah across um you know this chains that provide value to each other in some sense um I think we're gonna see more of it I think you know next year we're going to see the build outs of those Technologies and we'll kind of see them instantiated after that maybe I mean a related topic here but you know what's your um you know how do you reason about you know all of the different types of

execution environments that developers have access to today right so I mean if you want to build if you want to build something on a blockchain say you want to build a Dap you can go you can go the simplest route which is like you can build a contract on you know any number of chains and you can probably use axelr to orchestrate all those contracts and yeah I mean actually it could also maybe serve to scale uh smart contracts to some extent because you're sort of spreading um that that the block space across different chains yeah and then there's like of course the Celestia Vision which is you know decoupling consensus from from the execution assignment layers and then you have like the osmosis Vision which is like we're going to control every layer of the stack because the application right uh necessitates right every layer of the

stack being um being controlled I sort of see that as a you know the the Amazons and the Googles of the world right they're building their own data centers they're not going to be building on someone else's Cloud uh you know how do you reason about which types of these configurations are better suited like how should developers think about what to use if they're building an application and as a as an orchestration layer yeah are you guys also you know thinking about you know helping developers choose the right um you know being being sort of a steward there and helping developers choose the right type of of infrastructure I guess yeah no it's it's a it's a great question so I think one thing

um I think kind of for a developer as they're starting to build right you have to think about you know what are you building what is your go-to market right then like what is your user acquisition strategy and like what properties your applications used to have so as an example let's say you build in some kind of a sophisticated sort of financial primitive that has you know very interesting like liquidity properties okay uh Do you want to build your own app chain for that um and I claim probably not if you experimented at the application layer logic and you don't know whether or not your application even has a product Market fit probably just want to you know take some contracts you know write them over a week you know deploy like on one chain or a couple of chains and see if anybody would even interact

with those things right you have to think about your interchange strategy from day one like how you want to scale from that um but you want to kind of go to market as quickly as possible right then like you need to use the tools that will allow you to do that um if you are building something where you know there's a product Market fit so decentralizer changes you know we've seen them right like with no more liquidity better ux's will lead to ultimately more uh scalability for these um decentralized exchanges then you have to say Okay what is my long-term future to provide then these kind of a extra level of services that my competitors would not be able to provide and that maybe means building your own stack and controlling it from the ground up right where you can control the full execution

you can have reliable kind of transaction fees and so on and so forth so yeah I would say kind of a for developer the the simple template you can follow say okay this is my application do I have a product Market fit if not find the easiest shortest path to go to market and like figure out if anybody is going to use that if you're trying to kind of improve and innovate on the products that that have uh usage um then you want to think maybe about controlling some parts of the stack or scale into as many chains as possible kind of a from the get-go because those will be your differentiators right so you have to have those differentiators yeah but I mean in the long term do you see Axel are having a significant role in just being sort of an entry point for

like say your new blockchain developer you want to deploy your application you know to as many systems as possible you're going to come up without you know you're going to start interacting with XLR and then um you know XLR May also provides some tools that uh helps deploy those applications to the right type of infrastructure so like if it's like a you know Rinky Dink little you know right Dap You know you might you might just want to deploy as a smart contract on ethereum and all DVM chains right if it's something you know more complex in the same way that you can use digital Evolution today to like launch a WordPress site just like in one click you can also launch you can also use it to launch like a kubernetes cluster and

and like the interface helps you figure out you know what you need and there's applications already there yeah yeah right like I think that that's reality right like you're gonna have to go and uh you're gonna have to uh yeah you're gonna need a place where you can manage your application across multiple chains right and uh potential like through the sort of kubernetes stack and like the tools and the templates that we're building we'll be able to do that for the users cool so yeah before we wrap this up what's uh what's new what's next on the roadmap that is next on the road map it's a kind of a building that's sort of ecosystem right working with a lot of developers to to help think about what are the use cases what are the template contracts they actually need how to instantiate them uh think about you know uh

protocols uh across across the full stack so yeah cool well thanks so much for doing that sounds really nice for having me really interesting and uh yeah I look forward to being here again next year when you do this again awesome thanks for having that intro thanks