Anna Rose (00:00:02):
Welcome to Zero Knowledge. I'm your host, Anna Rose. In this podcast, we will be exploring the latest in zero knowledge research and the decentralized web, as well as new paradigms that promise to change the way we interact and transact online.

Anna Rose (00:00:24):
This week, I catch up with Sergey Gorbunov from Axelar. We revisit the topic of bridges and chat about what led him to work on interoperability. We then talk about the problems that Axelar is trying to solve, how it compares to existing solutions and what's next for the project. This is one in a series of bridge and interoperability episodes that I plan to do for the next few months. So I hope you enjoy. Before we kick off, I wanna just highlight the ZK jobs board for you. If you are looking to jump into ZK professionally, I wanna remind you to head over to the ZK jobs board to find job posts from some of the top teams working in ZK. Find the next project or team you wanna work with. I also wanna encourage teams who are hiring to use the jobs board to find your next hires. We have great teams like Aleo, Anoma and Mina already there. So be sure to add your jobs as well. You should also check out our linktree. We have put together a list of a lot of the channels that we have. We are adding to it, but if you wanna jump into ZK, this is probably a good place to start. So now, Tanya, the podcast producer will, I'll tell you a little bit about this week's sponsor.

Tanya (00:01:24):
Today's episode is sponsored by Polygon Zero. Polygon Zero is a layer 2 scaling solution for Ethereum. What separates Polygon Zero from other ZK scaling solutions is the power of Plonky 2, a groundbreaking prover system, which generates ZK proofs faster than any other existing tech. Plonky 2 supports an efficient recursive proof generation allowing Polygon Zero to scale horizontally. Meaning the throughput of the protocol is not limited by the weakest nodes on the network, but only by the total compute available visit polygon.technology to learn more about Polygon Zero and other Polygon solutions. So thank you again, Polygon Zero. Now here is Anna's interview with Axelar.

Anna Rose (00:02:08):
Today. I'm chatting with Sergey Gorbunov from Axelar. Welcome to the show Sergey.

Sergey Gorbunov (00:02:13):
Hey Anna, great being here.

Anna Rose (00:02:15):
I do wanna share this. The ZK validator is an investor in Axelar. And what is interesting about when we actually did that investment for me, at least that was, I think the first time I saw a project that talked about this like multi asset bridging technology, and I know you don't call yourself a bridge, so we'll get to the difference there, but it back then, like, or when I first heard about it, it was for me the first time I'd even had like really heard that concept. I know since then there's been a few more that of like entered the space with a similar thing I wanna get into sort of the competitive landscape and just generally I'm actually doing like multiple episodes right now on these types of solutions. So I'm planning on doing like one a month. So I'm very, very excited to be digging into this one to Axelar, especially since I think this will be the first time I revisit since we spoke like some time ago. What about you? Where are you coming from originally? Like what ecosystem did you start from?

Sergey Gorbunov (00:03:12):
Good. So I guess I started from a technologist ecosystem. How about that? Okay. And cryptographer ecosystem.

Anna Rose (00:03:19):
Did you come from math then? You came more from academia potentially.

Sergey Gorbunov (00:03:23):
So I did a lot of things. I would say, you know, prior to getting into blockchain full time, I originally was very passionate about security and kind of practical security. So kind of concentrated on that during my undergrad. I loved networking. So I worked on software defined networking. We're building like distributed controllers kind of 10, 12 years ago with a couple of professors and students at the university of Toronto. And then I wanted to study formal cryptography, right. So I went to grad school, you know, did my PhD at MIT. And then by the end of it was a little bit bored from doing again pure theoretical research. So I wanted to do something more applied started to play with blockchains you know, some of the early designs behind our grant and with Silvia and a couple other students, we helped to take that project from, you know, resear§h to the market and take the platform live

Anna Rose (00:04:21):
Well. Wait, so you were one of the early, a grand folks then you like, were there like, were you part of that original team then?

Sergey Gorbunov (00:04:27):
So yeah, originally the project started at me and Sylvia doing some research at MIT. You know, when I was finishing my grad school, then I joined university of Waterloo for a couple of years. So the research around a Algorand continued. So Sylvia involved a lot of other students kind of a faculty to help design continue shaping the protocol. I think it's been through like four or five iterations and you know, eventually we got together as a small technical team in early, I believe 2018. That's when initial funding was attracted to the project. And yeah, we kinda took that to the market.

Anna Rose (00:05:04):
What was the impetus to break out of there? Like you'd been working in this project, you know, now you're doing something that I guess could be used together with what the, some of the work you did maybe, but yeah. What, what prompted the move?

Sergey Gorbunov (00:05:17):
So as we're building Algorand and as we shipped to the market, one of the first questions that kept on coming up is how do we bootstrap that ecosystem? Right? And bootstrap in really came to bring in liquidity, bring in users, bring in some of the existing applications to the Algorand platform, right? And in the early days when you ship something technically better without a community, that's a very, a hard problem to solve. And so we were looking for different ways to connect Algorand with other ecosystems, you know, nothing that we could really apply and connected that easily. And at the same time, you know, myself and my co-founder Georgios, we saw a lot of other, just amazing projects being developed in parallel, right? Like Cosmos and big fans like Polka Dot, right? Like Avalanche, Solana and Near and the list goes on. Everybody had their own take on consensus. Everybody had their own take of what smart contracts should look like. And so it was clear to us that if the ecosystem continues to grow, all those ecosystem systems are gonna have different applications, gonna have users, and they're all gonna have to talk to each other one day. And you know, we wanted to bring this connectivity to continue accelerating the ecosystem and, and, and help compose all these different applications.

Anna Rose (00:06:31):
Hmm. I mean, you just mentioned cosmos though, and like cosmos, has IBC kind of, I think it's a pretty early part of the project. Like I think that was announced quite early on. Why wouldn't you have sort of pursued something like that, like a glue between networks like IBC?

Sergey Gorbunov (00:06:48):
I mean, so IBC, I think is a great protocol, right? And I think it works quite well. It's very technically hard to apply to different consensus mechanisms. So, you know, practically for us, like at Algorand to apply something like IBC, we would have to pretty much rewrite most of the consensus because it works very differently. You have kind of randomized selection that allows validators to be selected from, you know, anybody in the world in some sense. And so IBC requires you to have very effective and efficient, like, light client implementation that need to be communicating across all of the different chains that you want to interact with. Right. And so if you want to interact with, you know, Cosmos ecosystem with you know, Solana with you know, Avalanche, you're talking about different consensus mechanisms that have to exchange light clients, you're talking about potential different smart contract languages, a that need to support these lite client implementations.

Sergey Gorbunov (00:07:41):
And then you have to maintain these implementations every time you wanna do an upgrade. And then you have to, you know recreate these connections all the time. So while, you know, from a security perspective, I think it's a, it's a, it's a great protocol and has a lot of advantages as an engineer. And, you know, especially some of the background around networking and things like that. I just knew that the, the friction that was gonna continue we gonna continue see to, to scale these protocols. That being said, I think, you know, we we'll see what happens. Right. I think it's I mean, I think it's still early, we're still building some of these kind of core pipes and connectivity tissues and learning what works, what doesn't.

Anna Rose (00:08:16):
Hmm. Okay. So let's talk then about this emergence of Axelar. So I guess you left the org started a new company. What did you set out to do at that beginning point?

Sergey Gorbunov (00:08:26):
I mean, originally we were actually thinking about some simple applications that would be great to build cross chain. So for instance, things like DEXs right. Decentralized exchanges great use case, you know, right now at that time when we were, were thinking about it to things like UniSwap were coming to life, right. Lots of traction. So it was a very nice early use case for the blockchain ecosystem. And we thought, well, it would be so much better if it's it's, if it's cross-chain enabled. Right. So being able to interact and swap assets from one ecosystem for an asset of another ecosystem that would be amazing.

Anna Rose (00:09:03):
That's the dream. Yeah.

Sergey Gorbunov (00:09:04):
Yeah. But what we realized is that to build an application like that, you're gonna have to roll out so much infrastructure in parallel, right. And then every single time you want to build an application that's cross-chain enabled, you're gonna have to reinvent and reinvent this infrastructure and, you know, whatever you're doing. And so it was clear that there was a, an infrastructure gap that just has to be solved with good robust communication protocols, good robust, you know, relaying services, fee services, you know, interoperability stacks, and that would enable and empower thousands and millions of applications down the line. And you know, to us, that was super exciting, I think, right. Working on the infrastructure, which we've been doing for years and at the same time applying it to scale the whole ecosystem, like what could you ask for more? Right.

Anna Rose (00:09:53):
Cool. But, so let's talk about this question of, of what you call yourselves, cuz I think I've, you've been lumped definitely together with bridges. But I have heard, I think in even like a talk we, we did like for the ZKV privacy and Cosmos like previous online event, I think you, you did mention this distinction, you see yourselves not as a bridge technology. Tell me something about this distinction.

Sergey Gorbunov (00:10:17):
Good. So I think at the high level, the way to think about Axelar is a, it's a decentralized overlay network that's been designed, sir, from the ground up to deliver web3 interoperability. Okay. And so I think the basic core three properties that we're trying to implement at the network transport layer are things like universal routing, universal translation of messages as you go from like one ecosystem to another right. And strong and robust security properties that the ecosystem needs in order to facilitate cross-chain communication. Right. And I think, you know, if you look at bridges, most of them been sort of rolled out as a one-off ad hoc solutions to solve a specific pain point, like transfer an asset from one ecosystem to another and it sort stops there. Right. and I think what we're trying to do is build kind a series of mega highways in some sense that would enable us to connect millions of chains down the line. And that requires of a very different, you know, engineer and infrastructure approach. So you can continue scaling.

Anna Rose (00:11:23):
You sort of mentioned like routing messages. So this is a distinction between Axelar and some of the other bridge solutions. Last month, we did an episode with Gravity Bridge and there's is primarily token transfer. We talked a bit about messaging and I wondered like, when you say messages is this like DApp calls, what, what are those messages? What do they look like? And why are they, are they more complicated to translate than a, like a straight up token transfer?

Sergey Gorbunov (00:11:49):
Good, great question. So when I say, I guess messages, yeah. I'm really referring to an arbitrary payload that you can pass from one chain to another. Right. Okay. And that payload can really encode any information that you want to be executed. Okay. A token transfer is a specific type of, you know, request that you can transfer from a source chain to a destination chain. That request would encode. Like I locked my token here, could you please mint, you know, the corresponding token on this other chain for me, right. To execute that request, you need to, you know, finalize it on the source chain. Right. You need to validate it. You need to create a message that's posted on the destination chain that says that this request has actually been validated. Right. So you can trust it and then you execute that call. So I think that's a very simple use case for interoperability, but I think we want to go beyond that in some sense, what we want to do is we want to be kind of a, a touring complete platform, right. Where you can build applications that are just as rich and powerful as you were to build them on a single chain, right? So you can encode arbitrary payload, NFT transfer, you know, contract calls, lending and borrowing applications. And you can encode that as an arbitrary payload and get, you know, the underlying infrastructure to securely deliver to the destination chain and execute.

Anna Rose (00:13:09):
Is that a harder ask? Is that like a harder engineering fit to actually make it so generalized and not just focused on that one use case of tokens?

Sergey Gorbunov (00:13:19):
I mean, I'm not sure if it's, you know, harder from an engineering perspective, I think it really requires you to think how to build the right system that scales right. And how to build the right system that, you know, when new connections are added, you know, you're not creating like fragmentation across the ecosystem. Right. how do you enable like universal routing across all these functionalities? So when a new chain is added, you wanna make sure that other chains are sort of aware of the path from the source to the new destination chain without too much, you know, engineering or interaction on the back end. So, so things like that and, you know, definitely I would say it actually helps improve overall security, right? When you deconstruct sort of the transport layer of interoperability with application specific use cases that allows you to focus and say, okay, I don't care what the messages are. I need that infrastructure to be as secure as possible and then layers above it in some sense, get to decide what to do with that information.

Anna Rose (00:14:20):
Are they, they read those, that info. They actually decipher it. So it sort of doesn't matter what's in there it's just past.

Sergey Gorbunov (00:14:26):
Yeah. And I think a good, like analogy is like, I think about how you build on a single chain, right? You have a consensus where you can, you know, deploy an arbitrary, smart contract and you can write your instructions on top of it when validators execute and sequence consensus messages, they just execute whatever you tell them. Right. But the consensus itself is not specific to the application. I mean, I think cosmos is a sort of an exception, right. Where the whole stack is designed, where at the consensus layer, you're sort of validating, you know, the messages, but you know, a lot of the other platforms almost to incomplete in some sense, right. Where the consensus just sequences the messages and creates the order in structure. And then you can write an arbitrary logic on top of it.

Anna Rose (00:15:11):
And you're doing it that way. You're kind of, yeah. You're not looking so deeply at the use case with the use of the actual data.

Sergey Gorbunov (00:15:17):
I mean, for some use cases, you can do more interest in things. If you look at the message in the payload for token transfers, you know, in particular. So we enabled one of this properties as I call like translation between like IBC token transfers and EVM token transfers, where you actually have to look at the message, you know in order to encode one format to another. But I think of those things that sort of optimizations in some sense that allow you to do more at the network layer.

Anna Rose (00:15:43):
When it comes to some kinds of information though, like, do you need some sort of translator on either side? Like some blockchains just work quite different. So like, are you acting as that translator between them or are you kind of, do you need to have access to some, almost like the lexicon of each one and then you're yeah. Doing some sort of translation.

Sergey Gorbunov (00:16:05):
Great question. So I think this is one of the core properties that, you know, Axelar network provides at the network layer, right. Which is trying of different messages. So, you know, as, as an example, when you send a message from a cosmos ecosystem that is, let's say an IBC token transfer, then at Axelar network layer, we can take that message. We can translate it to a message that needs to be delivered to an EVM chain and execute it there. So the network serves as this translation layer. Now you're right. That every ecosystem speaks its own sort language. Right. Potentially has it smart contract, so you have to have this translation and then you ask yourself a question where's this translation gonna happen. And there's pretty much two places where it can happen. It either happens at the application logic, right. At the think of it, like almost like the smart contract close to your application. Right. Or it has to happen somewhere in the transport network layer.

Anna Rose (00:17:00):
Yeah. One check here would like if you did it the first way, would that be basically like, almost like a light client on one side that does, I don't know if it would be called a light client, but some smart contract on one side that like gets it prepared in the format that you'd need on the other?

Sergey Gorbunov (00:17:15):
Yeah, exactly. Right. either on the source on destination chain, you have a smart contract that takes a message, you know, decodes it, right. Deconstructs, different payload, and then interprets it and, and, and then pars that. Right. so yeah, that's, if you want to do it almost like at the, at the exit and entrance points. Right. And so if we do some of this functionality, you know, at the network layer, which allows us to be a lot more efficient, a lot cheaper, right. Because, you know, you don't have to pay like huge gas costs for doing this translation layers. And it allows us to continue scaling and add in more routes in a uniform way while just composing and building on the networking effects of the translation. Right. So it's not, it's you change the model from having a peerwise translations and peerwise connections, right. To a model where everything is down at the route and transport layer is serve in a more uniform and, and cohesive fashion.

Anna Rose (00:18:07):
Something that was highlighted kind of early on, that was special about the work that Axelar was doing was the use of threshold cryptography. Is that what makes this more efficient or cheaper? Is that, is that the secret sauce or is that used for some other reason?

Sergey Gorbunov (00:18:22):
I mean, it's definitely one of the ways, right. I mean, the way we design the whole system is to allow us to continue, you know, scaling and making it cheaper and making it more efficient to deliver the messages right. From one ecosystem to another. And so the cryptography component is almost a plug and play component on top of the Axelar network. Right. So we can plug in threshold, we can plug in multisig. You know, I think there's a we've done a lot of work on like standardization of BLS signatures, which I think is gonna be, you know, quite powerful for some of the change that will support, you know, BLS. And you can, you kind of continue down the line and yeah, all of those primitives, they have their own trade offs. Some of them more, you know, efficient, some of them are you know, have non interactive compression mechanisms. Some of them are interactive, but the goal is to continue building the system and continue scaling in it so that the translation, the message pass and functionality can be cheaper and cheaper and cheaper over time. And you know, there's a whole set of optimizations. You can you can do it. Threshold cryptography is definitely one of them.

Anna Rose (00:19:29):
But you just mentioned a few different types. So you sort of mentioned the sort of multisig version, but that makes me think it might be good for us to explore actually, what is happening under the hood in Axelar? Like, are there a bunch of different pairs that you've created that are like moving between the two different two different chains? Or is it cuz when you say that a multisig, I think of the more primitive bridge bridges that do exist today, which is like a multisig connecting two networks, basically locking funds on one side to mint funds on the other and then burning them and bringing them back and unlocking them. But Axelar doesn't do that. Right. Or is it like every single connection has, you know, a unique bridge format.

Sergey Gorbunov (00:20:12):
So let me kind of take a step back. Right. And like let's, let's talk through high level architecture right. Of the Axelar network. Sure. So the, the high level architecture is the following on different chains that we're connecting, we have, you know, a notion of a gateway account, right. Or gateway smart contract, think of it that way. Okay. So, you know, on a EVM chain, that's a solidity contract. So what this contract exposes is a certain API that as an application, you can call to deliver a message to a destination chain that you want to talk to. Okay. Now underneath all of this is the set of Axelar validators. Okay. It's a, it's a permissionless set of validators built on cosmos SDK where anybody can join and participate as a validator. And so collectively what the validators do is that they observe these, uh, re accounts, right?

Sergey Gorbunov (00:21:03):
And they observe messages that are posted to the them. Once they see that a message is posted, they execute a consensus to reliably, you know, verify that message and then process it, process it here means, you know, figure out where it needs to go. So that's routing translation. If it's a message that needs to be sent for an IBC chain, you actually have to take it and translate it to an IBC packet for instance, right. And then serve execution. And the execution means that they collectively authorize a corresponding message to be marked at the destination gateway as approved by the Axelar network. Right? And so this, this last step can is where again, like you need a consensus of, and a majority of validators to approve that message. And to do that, you can, you know, you can have them either post their individual signatures or you can run, you know, threshold cryptography to generate one signature collectively, but it all serves the same purpose where the majority of validators reach a consensus and the threshold of them authorizes the message.

Sergey Gorbunov (00:22:05):
And now it gets, it can be delivered to the destination in know, chain or gateway and from their applications, look at the gateway and say, has Axelar approved this message, right? Yes. Axelar validators have approved the message. The majority of them have, you know, cosigned it or posted individual signatures or one signature. And then therefore I'm gonna go and execute it. So that's the high level architecture. So from an application perspective, you now get to build your application on any chain that you like, right. You pick your home base, what I call. And from there, you get to, you know, interact with other chains by just talking to the gateway. So you don't have to learn Axelar stack. You don't have to understand how relaying is done or anything. You just talk to the gateway. That's a regular, you know, solidity message. Or if you're in a cosmos chain, you will talk like IBC and go from there.

Anna Rose (00:22:55):
When you talk about these validator sets, it just made me think like, is there MEV on these things as well? Is that also where the threshold cryptography could come in handy to like prevent, because it's hidden a little bit, I mean, at least what is it threshold decryption used in the context of MEV but I don't know if that's how you're thinking about it.

Sergey Gorbunov (00:23:17):
That's not how we're thinking about it. Like here, we're using the threshold signatures, I guess, for validation, but you are right. That threshold cryptography can help you against other types of attacks. Right. you know, you know, sequence a set of messages without validator, seeing what the messages are like through threshold description. We actually have kind of a short paper coming on this shortly, how to do it, like more effectively with things like identity based encryption you know, you get to save a lot of traffic at the network layer and you know, you can definitely do it. And I, I think just having validators that have secret keys, that you can do something cleverly with opens up all kinds of optimizations of this transport layer and better security down the line.

Anna Rose (00:23:59):
Got it. But back to MEV, do you, are you worried about that? Is that something to worry about?

Sergey Gorbunov (00:24:05):
Am I worried about it? I mean, I am, but it doesn't prevent me from sleeping at night in some sense. It's okay. So kind of stepping back, right. To, to do the interoperability the right way. It's actually very important to make sure that you don't have order dependence of the messages as you moving them around.

Anna Rose (00:24:27):
Okay. Why would that be a problem?

Sergey Gorbunov (00:24:29):
Good. So the point is that whenever you're talking about very different environments, a hundred things can go wrong. Okay. And then if you have a system that has synchronous communication across different hubs of connectivity, then there's just so many places where things could go wrong and break, and you're gonna be stuck without a system that does, that doesn't make progress. So the right way of doing this is to design a system that in some sense has think of it kind of a IP or UDP level of message passing, right? So these are kind of a protocols on the, on the internet where you don't have a lot of properties in terms of the ordering of those messages and how they arrive. But on top of it, you can build application specific protocols that have stronger properties, right? So for instance, you can have protocols that have sequence numbers that only make sure that before the messages are played on the destination chain, they need to arrive at a certain sequence at the source chain, right?

Sergey Gorbunov (00:25:33):
Mm. But all of that, you can build as application layer protocols on top of the, you know, infrastructure that needs to remain robust and you know, secure. And so if you start mixing those things up, which is, I think a lot of projects have been doing, you're gonna run into all kinds of security issues and all kinds of, you know, fault tolerance problems that you're gonna have to deal with. So you wanna keep it decoupled. And then an application layer continue building this more sophisticated protocols, almost like TCP on top of, you know, UDP IP type of things, right. Or HTTP, which gives you encryption on top of unreliable unreliable communication. And so that's at least the way I think it, it needs to be approached for the blockchain space. Otherwise we're gonna be mixing things up and running into the security issues for forever.

Anna Rose (00:26:16):
But I think what you're saying here is like that sort of MEV would be like on either side of the, like on either side of Axelar, right? Like when you're moving funds from one chain to another, you could be like front or doing something. I don't know what it is, but could there be within Axelar any issues like within the validator set? Like, is there any benefit to a validator putting forward or like, I guess it's hard in proof of stake, but like, is there, is there any game that could be played on the validator side, within Axelar in this context?

Sergey Gorbunov (00:26:50):
Potentially, I mean, I have to think a little bit more, but those are the things that you can protect against, you know, using like threshold encryption and decryption techniques. So I guess on the Axelar network, I'm not too worried about this. I'm more worried of about now this multi chain interaction, right. Where you can have potentially messages from different, you know, source chains that get, you know delivered to the destination chain and you can have all kinds of, you know, race conditions between them and all kinds of MEV. So, so I think that would be a lot more complicated to protect against them, like on the Axelar network, which I think is pretty straightforward.

Anna Rose (00:27:22):
Got it. What is the speed of this movement across, in the case of Axelar? You sort of mentioned that it's fast, but I'm wondering a direct multisig one to one like chain to chain with a multisig on either side, seems like it would be the fastest, it might be expensive because you'd have to like unlock on one side, especially if like Ethereum with very high gas prices, but is there any sort of delay or lag by going through this kind of system?

Sergey Gorbunov (00:27:51):
I mean, not, not really right. I mean, I think in, in that, in that case kind of a, the performance of multisig and, you know, kind of centralized implementations and the performance of Axelar will be pretty com comparable because what you need to do, you need to make sure the request on the source chain is finalized, right? So that's subject to the rules on the source chain. So if it's has instant finality, you know, you wait, let's say for five seconds, right? Or for one second, from there, you need this set of validators to process this message and, you know, translate it or execute it for the destination chain for the Axelar case, you know, it is built around the cosmos case. So we have kind of five second block finality, right. So it's kind of pretty efficient and you can do things, you know, in an optimal way, maybe, you know, in a couple blocks. Right. and then from there, you just take the message and you post it on the destination chain and there you subject to the, you know, lates of the destination chain, I think as all of the systems are gonna be improved in like the latency go down you're effectively adding, you know, another hop of a proof of stake network in the middle which I think can be, can be reduced and you know, down the line, definitely we are looking at kind of subsecond finalities.

Anna Rose (00:29:01):
So one question that came up on a previous episode Tarun actually Tarun was supposed to be on this one, but we moved it around and he, unfortunately couldn't be here, but I know, I feel like he would ask this question, which is say, you're bridging some stable coins to, I don't know, Solana yeah. Or something. And other bridging technologies, other interoperable kind of pools are also bridging their own synthetic stablecoin over to Solana. Now you have like the same ones, but I mean, they have different names, but you're kind of dealing with like the same underlying assets. What are you thinking about with that? Cause I know this is a space that people are kind of worried about, like potentially they're being, I don't know if it's like just crazy arbitrage or if there's some attack somehow in there. I I'm curious to, to get your thoughts on it.

Sergey Gorbunov (00:29:51):
Yeah. So I think it's a kind of a general problem of kind of fragmentation, right. And the liquidity fragmentation, where you can have a situation where you have multiple as sets that represent potential the same thing. Right. But they call differently, they have different contract addresses and so on and so forth

Anna Rose (00:30:07):
And they could have different liquidity?

Sergey Gorbunov (00:30:08):
Different liquidity,

Anna Rose (00:30:09):
I guess, could affect the price. Of course. Absolutely. Like would you almost be able to arbitrage stable coins even though they should be all close to the same amount? If one is actually, how would that work? If one was more rare, if one was like had lower liquidity, would its peg go, would it break upwards like a stable coin?

Sergey Gorbunov (00:30:30):
When, when you have lower liquidity? I mean, one of the examples is that if you then use like in a Dex pool, right, that users are gonna have to tolerate more slippage. Right. that's a very, very simple kind of example. One of our you know, investors actually Steve McKeon, he recently rule an article of what happens when you have this liquidity fragmentation across ecosystems and what is the benefit of unifying it and, and kind of merging it together. Right. And so I think there, he actually very clearly demonstrates some of this precise kind of oponence where have different liquidity pools. If they're smaller liquidity pools, then users suffer at the end of the day. Right. And so what you wanna end up having is like unifying them in some sense. So there's a deeper pool and users can you know, pay lower transaction fees and, and have lower slippage right.

Sergey Gorbunov (00:31:16):
In this, in this process. So going back to your question of liquidity fragmentation, what do we think about it? And you know, what are some of the approaches to deal with it? So A, I think actually an important question that will be answering over the coming years as we get robust interoperability and more general message passing is whether an asset will go to a compute environment or a compute environment will come to assets. Mm okay. So think of it this way, you know, right now we're moving, you know, tokens back and forth through the centralized bridges for the most part that we're moving assets. Right. but you can do it the other way around where you can have a program, right. A smart contract code. And if you need to execute something with respect to this assets, you make a call right.

Sergey Gorbunov (00:32:00):
To a chain where there's a deepest liquidity of this asset. And then that call gets executed on that chain. The state can be reflected there and the state can be propagated to other smart contract or, you know, other users on different chains. And they all get a unified view of that of that state. So I think as we get robust interoperability stacks, and as we get the, a general message passing, this would be one of the questions. And I think there are various trade offs, depending on how you design an application to either move an asset or move the compute closer to the asset.

Anna Rose (00:32:33):
Would it be like you'd have one high liquidity asset let's use like a, it could maybe still be a synthetic, but it's some sort of like for now it would be like a, I don't know if there is already this X USD XUSD, is that gonna be yours by the way? Is it gonna be the, is that the name of the

Sergey Gorbunov (00:32:51):
I think we're now adding a perfect Axl to our

Anna Rose (00:32:54):
Okay. AXL, not X let's call it like ZK. So it's like this ZK USD. Okay. Okay. Yeah. So, so this is theoretical. So if there's a ZK USD pool, that's high, like there's a lot of liquidity in there. The idea here is that instead of trying to move it over to the different ecosystems, you keep it there, right? Like you keep it on that chain, in that format, in the largest pool possible. But if, if you wanted to interact with it, you'd send messages over this chain, but that's not how it is. Right now, like, that's not how it works.

Sergey Gorbunov (00:33:26):
It's not because there there's no interoperability right now across the ecosystems right there, you know, there,

Anna Rose (00:33:30):
But right now what's happening is like you are sending the tokens around. Do you think that there will be that there will actually be a move towards just having the single pool on one chain? That's like, is that, is that sort of a prediction or is that something you're actually seeing movement towards? Cause I think it's going the opposite direction right now. Right? Like right now, tokens are getting sent all over and everyone's creating their own synthetic.

Sergey Gorbunov (00:33:51):
Yeah. So I do think it's gonna get sort of unified and abstracted away from the users. Okay. And I, and I think there are various ways of doing this. So I think, you know, I don't think I would predict that, you know, there's gonna be one asset on, you know, on, on that chain and you have the deepest liquidity and it's no it's not available anywhere yet. But I think depending on the use case and depending on the application one model or the other could make more sense. Right. So, so, so let, let give you like one example, suppose you have an NFT, right. On Solana and you want to take a loan against it on Avalanche. Okay. So in that case, maybe the loan that you want is in the most liquid stable coin on avalanche, let's call it, you know, I dunno, UST for example.

Sergey Gorbunov (00:34:36):
Okay. but your NFT, you know, lives on, you know, on Solana, so what you can do is you can, you know, lock it in a contract on Solana, you can deliver a message to Avalanche that says, you know, this NFT has been locked. This is the user's address. Please give a loan to this user against this NFT. This is a duration of the loan and like all the parameters, and this is their address. So in this case, you don't have to transfer the asset. The asset remains where it is, but you just passed enough information and you obtain, you know, an asset that you deserve or desire on a different chain. Right. so this is one example where you don't actually have to move it. You just need to move sufficient information about it. And I think for different use cases you know, we will have to iterate like one by one where it makes sense what.

Anna Rose (00:35:25):
Hmm. I think the work you kind of described before suggested that it would be good if there was like deeper liquidity pools, but like single assets of, of one kind. But yeah. Are there any strategies being taken by any networks to actually encourage that? Like, could they ever block probably they can't, but like, like, is there any way to, I guess you could, you could highlight one, but like yeah. Is there any way to decide that there is only going to be one canonical version of something on a network?

Sergey Gorbunov (00:35:54):
Yeah. So the, the, there are actually the couple efforts towards that. And I think FRAX is a good example of a stable coin. Right. And serve the way that it works is that the team has economical representation of Frax on, on different chains and they authorize different the bridge providers, right. Or interoperability providers to swap their tokens for the economical representation of this asset. Right. So in that case all the applications would only list and interact with this canonical representation and maybe they authorized serving one or two different paths of routing or delivery of, of those assets to, to that chain. And, and I think that's definitely you know, one of the trends that we're starting to see right now is that unification at a, again, like an application layer where you now trust effectively multiple underlying interoperability stack to, to execute messages on your application specific contract that just mince this kind of article representation of the asset.

Anna Rose (00:36:49):
Hmm. I'm wondering like, how do you actually deploy Axelar onto new networks? What is, what is the action for you? And maybe before we do that, tell me, where are you now? I know, I mean, there was an announcement there you're kind of bringing Adams to Moonbeam, I believe. And I thought that was kind of crazy, cuz it was for me at least the first time I'm like, oh my God. Yeah. There's actually, it's there. Yeah. We've heard about this for a while, but, but yeah. So tell us where you are at. And then I wanna hear about like how to add more

Sergey Gorbunov (00:37:18):
Yeah. Where we're at. We effectively started the main network rollout, which is a phase rollout where different functionality will go live on the network over the subsequent you know, months. Currently we connected I think something like 10 or 11 chains through the Axelar network some IBC chains like you know Cosmos Hub you know, Injecteve, Osmosis, Terra and then a bunch of EVM chains like Avalanche, like Moonbeam, like Ethereum, like Polygon. And we enabled various kinda asset transfer use cases around the network. So you can move things like UST, you can move atom. Right. Which I'm was really excited about to different EVM ecosystems and actually, you know, use it as a, as an onramp to get back to cosmos. Right. So now users can finally get the atom and go back to cosmos without having to go through a centralized exchange.

Sergey Gorbunov (00:38:11):
And there are pools like on UniSwap, right? There are pools on Moonbeam that are being created. So super excited about that. And and it coming months we're rolling out more functionalities. So kind of the general message passing is gonna go live over the coming weeks. On the main network we have, you know, lots of applications that are, that are building in this new environment and, and kind of building their cross-chain applications. And yeah, the goal for us is to connect to, you know, million chains, right. Millions of chains down the line. And that, that requires a very thoughtful approach, how to scale in how to scale horizontally. Yeah. And we'll, we'll tell more about that in the coming months.

Anna Rose (00:38:49):
How do you actually set up on these new networks? Like what, what are you actually doing on each side? Are you thinking in pairs of two networks connecting like between two networks, are you just like, I'm, we're adding a new network to our input and it can go anywhere after that.

Sergey Gorbunov (00:39:04):
Great. So never in pairs, I think, you know, the pair wise approach is, you know, again adds to this fragmentation and liquidity you know, diversion. So yes, you onboard to the, Axeler ecosystem and from there you get connectivity to everything else that's been previously connected. So huge networking effects and huge compounding effects, right from that, the way that it works is kind of depends on the ecosystem. So we support multiple protocols, right? We have we support IBC cuz everything is around cosmos SDK. So to set up, you know, IBC channel, it's pretty straightforward, like 10, 15 minutes and you set up relayers from there, right? Similarly we've done everything almost as easily, maybe a little bit more complex, but in a similar fashion to set up connections with EVM chains, right? So to connect an EVM chain, you would deploy a gateway contract there, the validators register to vote on events from that chain. So they would have to query like a, a light node or a node a of that chain and then a sequence of commands needs to be executed on the Axelar network to, to register that chain and kind of create this path to this new chain. Once that path is edited, the information can flow to all the other ecosystems that have been previously connected.

Anna Rose (00:40:11):
Hmm. But who does that? Is that your team that's doing that or is that, is that potentially like external participants who are like, I want my chain to be also hooked up.

Sergey Gorbunov (00:40:22):
The goal for us is to make this permission less. Right. And so anybody will be able to do this for now. You know, it is a kind of a kind of governance right. Of the chain and like, you know, a number of folks have to authorize and kind of cosign the message to be executed on the network. But you, yeah. You know, down the line, the goal is that anybody will be able to, to set this things up you'll be able to create a connection in an easy way and just talk with other ecosystems from there.

Anna Rose (00:40:48):
Do you not end up with that problem? This is like an old problem that I think I highlighted on the first interview I ever did with Sunny. It was about like, what if one of these chains is super, are super toxic and it's not functioning correctly potentially like there's a consensus, what do they call it? It's been captured. So like 51% attack or 66% attack if it's proof of stake. And like someone's just printing money using Axelar, send these funds elsewhere to trade them. How, how do you actually prevent that in a, in a totally permissionless way? Like in a permissionless system rather?

Sergey Gorbunov (00:41:24):
I mean, I think that's a great question. So I think a couple answers to that. So first of all, I think one, I think that's why it's important to understand that whenever we're talking about cross chain or interoperability minimizing, the number of hops to get from a source to destination is critical. Okay. Right. I think like a lot of people have this, you know, view that the blockchains are gonna be connected in exactly the same way as like internet and peer to peer networks, right. On the internet and peer to peer networks, your packet takes, you know, to 20 hops going from a source to destination oh, true. In a blockchain world that would mean you have to make, you know, you have to assume 20 networks a trusted as you packet goes from a source to destination, which is ridiculous. Right. So I think minimizing the number of hops is gonna be a key point.

Sergey Gorbunov (00:42:10):
And then two, that's why you want to route and deliver information through networks that have been designed to deal with situations like this. Right. And dealing with situations like this, you can have, you know, a number of on chain and off chain protocols in some sense. Okay. So on chain protocols, if the chain is malicious validators, you know, can go and you know, just disconnect their RPC endpoints, right. Or disconnect their real layers and stop processing the message from that chain. Right. You can also have kind of off chain governance where, you know, a committee has to come in and sign a message that pauses transfers in and out of that ecosystem. Right. Or, ah, pauses that state of that chain on all the other chains that it's been connected to. Right. So having a place and interoperability network that deals with some of the situations is also quite important where you have this rules and you think, and through them, at some point, these things will happen. And you have to have, again, a combination of kind of on chain and consensus logic that, that you can deal with. And also off chain, I would say kind of a mechanism to, to prevent some of those things. Yeah.

Anna Rose (00:43:17):
I mean the governance idea definitely sounds like you, I mean, it sounds like you could halt it, but could you undo it? Not really right. Or I guess, no, actually, no, you can't because they live on at this point, like those assets may have traveled onto other networks that your validator set would have no control over.

Sergey Gorbunov (00:43:33):
Yeah. I mean, the reality is that I, I think undo any of these things would be, you know, I think pretty hard, right? It's, it's no different than there is like an exploit in a smart contract on Ethereum and somebody managed to steal funds and then they, you know, execute in five minutes and like route it to all the other DEXes and, and centralize exchanges and try to get their money out. Right.

Anna Rose (00:43:52):
You feel like there's other places you could stop this.

Sergey Gorbunov (00:43:55):
I think some of these things will have to come kind of at an application or on an off ramps in some sense, right. Where, you know, as an application, you can always kind of, delist an asset for instance, right. If, if you don't trust it anymore. Totally. if we're talking about this canonical swaping right. Where multiple bridge providers potentially swap to a canonical representation, you'd definitely can, you know, disconnect one of the paths. And again, from there, if it already traveled through the swapping mechanism, then the applications and like on and off ramps will potentially have to deal with it and you know, exclude the asset or some of the accounts. So I, I, I think it's no different than like, you know, a bug in a DeFi application in some sense that kind of similar strategies will have to be taken.

Anna Rose (00:44:38):
On Axelar there's no, it's not a smart contract platform itself, but like, would you ever imagine a DEX living on you or does it, do you always think of it as living on this sort of native chains?

Sergey Gorbunov (00:44:50):
I, our goal is to empower developers, to build anywhere they want. Right. And that means like giving them tools and giving them APIs to go and build on the best platform that's optimized for the reduce case and optimize for their need. We optimize Axelar network for interoperability. Right. And for routing and for all this functionalities. So, you know, I can't, I guess predict the future, but I think, yeah, in some sense, the network has been designed with the different goals in mind. Right. And our goal is to help scale the ecosystem and empower really developers to make the best choice for themselves. And, and I think through interoperability, you get that

Anna Rose (00:45:28):
A few weeks ago, we had Georgios on the show talking about Foundry, and sort of testing across. And w e like, one of the topics was this multichain. How do you test across them? I don't know if this is like your problem, but I'm wondering if you think about it. Cause it's obviously like you are just providing the way to move between. You're not necessarily saying that like chain A should be tested this way versus chain B, but yeah. I'm wondering, like, do you offer recommendations to teams who are trying to develop across two networks?

Sergey Gorbunov (00:45:58):
I mean, we're definitely gonna provide, you know, examples, right. And like a framework. I think it, I, I do think in some sense, you know, it is our responsibility, right? As a kind of the team, that's doing a lot of work in the space to, to help developer think about crosschain, the multichain world and, and how to do those things. The, one of the key core differences is that everything becomes asynchronous communication, all of a sudden, right. And so whenever you're dealing with this asynchronous communication, you have to think about what happens if the transaction doesn't go through on the destination chain. Right. what happens if it gets reverted? How do you deal with kind of fault backs things like that? So I do think we're gonna be adding, you know, examples. I do think we'll, we'll provide you know, test and frameworks and way for the developers to think about it. And I, I think it'll be collaborative effort between our you know, developers and our team to, to kind of get there.

Anna Rose (00:46:48):
Cool. I mean, a big topic that I think has come up is this idea of just the like arbitrage or hacks actually, like this is where this question kind kind of comes from is given that there's been some very high profile, very large problems specifically. I mean, I think wormholes was the largest and most recent, and that was like a pure bailout. It wasn't returned by the hacker. Sometimes you have the, these hacks where it's like, it's a hack and it's like, just kidding. They gave it back. But yeah, in that case, it wasn't. So what are you thinking? Like, are you not worried that you could fall into the same trap? Do you feel like there's some sort of thing about your system that protects you better?

Sergey Gorbunov (00:47:31):
Yeah. So I think there have been actually more hacks right after the wormhole. There was the, the hack on the Axie Infinity blockchain, right. That I think like 600 million,

Anna Rose (00:47:38):
Which was also a bridge. Yeah.

Sergey Gorbunov (00:47:40):
Which was like a bridge again, like a centralized bridge by, you know, ran by a couple folks. So I, I think this is one of the most important problems itself, right. In some sense is build a secure infrastructure. And I think, I think A, you do have to have a strong base for a decentralized protocol. Right? So where again, I think everything, everything comes down to building a kind of a permissionless system where anybody can support your protocol, right. Anybody, it can participate having the code open source, like people audit it, people inspecting it, multiple participants kind contributing to the security of the network collectively right. In various formats either by running validators or looking through the code or, you know, testing things. So I think that's critical and that's, I think quite important and that's sort of the base of you know, what we're doing at Axeler.

Sergey Gorbunov (00:48:29):
And from there, I think it's a, it's a combination of, you know, the right designs, right? The right architecture, the right engineering practices kind of code audits and being very thoughtful about everything along the way. I think we're in the interoperability, we're kind of in the same phase where we're about, you know, a year in DeFi developments, right? Like people hack and left and right. Everybody rolling out their, you know, DEXs, everybody rolling out their, you know, boring and lending application. Like everybody kind of races for the market and doesn't care too much. And so I, I do think it can be done, you know, secure. I do think it can be done well, but it is kind of technically, probably the hardest problem we're facing right now. What that's what makes us excited, excited every day. So

Anna Rose (00:49:14):
I'm also just curious about how you'd actually, how do you incentivize, like the token, the validators actually in this context, cuz it's not like people are using it for, I'm just curious. Yeah. Like how, how are the fees working? Are you earning the fees from each network and then translating them into the Axelar token? Like yeah. I'm just curious how that works.

Sergey Gorbunov (00:49:35):
Yeah. So the way we build the you know, at least some of the functionality around the token and the kind of general contract calls is that you always pay in one transaction on the source chain and then the set of services takes that transaction fee and then, you know, converts it to pay transaction fees, on Axelar network, or on the destination chain. I see. And then, you know, if they're excess transaction fees, they can go back to the community pool or the validators of the network and things like that. But from a user perspective, it's a, it's super simple. You pay, you know, in the asset that you want on the source chain either a flat at fee or it sort of dynamically calculated and all the other relay fees and the network process and fees are taken care of for you.

Anna Rose (00:50:18):
How are you bringing that into your cuz you're not a smart contract platform. Like you're, you're a blockchain that just has that one native token, I guess. Right. And then just is doing the work of passing this information through itself.

Sergey Gorbunov (00:50:33):
I mean there are multiple ways to, to bring it a, you know, you can always have kind of a proxy contract on the, on the source chains, right. Where, you know, the, the funds are, are locked for the transaction fees, but B we do who actually treat the tokens as a sort, almost like a first class citizens through Axelar network, right. For the purpose that will wanna be able to kind of translate them to IBC messages. Right. As one of the examples. So, so you can actually have, you know, a representation of the tokens that you move in sort of minted on the Axelar network as a standard kind of cosmos denomination, right. And that that asset can be, you know, dispersed to the validators or used to subsidize all the other transaction fees. So there are multiple ways you can deal with it on the source chain, Axelar network, destination chain. It just kind of depends on the trade offs.

Anna Rose (00:51:21):
Which of the networks would you say you're closest to? You've mentioned Cosmos a bunch of times, obviously Ethereum, but like, would you say that your focus right now is at like looking at the Cosmos ecosystem or yeah. Are you, are you looking at other networks as well?

Sergey Gorbunov (00:51:37):
I mean, I think definitely kind of given the technology rollout, I think, and given what we've done, it's super easy for us to onboard any Cosmos chain and any EVM chain. Right. And almost like be one of the you know, one of the hubs across those two ecosystems of the EVM chains and, and IBC chains. And that's why we have kind of a, you know, half a dozen connections across each one of those. But you know, our goal is to be able to connect everybody right down the line. And so we have a kind of a path how we expand and how we, how we grow the network. You know, cosmos to me, you know, in particular is I think I have a lot of respect for, you know, the ecosystem for the technology that's been built. I think it's been one of the, you know, most valuable stacks, I think, where that allowed people to innovate and definitely the community itself is very focused on interoperability. Right. and I think that's that what allows all these networks to sort of talk to one and have compounding effects and actually collaborate. So I, I, I really enjoy kind of working with the, with the cosmos folks.

Anna Rose (00:52:35):
Do you have plans to potentially deploy on Osmosis soon?

Sergey Gorbunov (00:52:39):
So we actually submitted, you know, proposal right. To the Osmosis team for supporting kind of bridge functionality for them. There have been a few other projects that have submitted the proposals. I think, you know, the team's been evaluating and we had some kind of online panels that we, that we talked about.

Anna Rose (00:52:59):
Oh yeah. I, I saw that. I, I really liked that. Actually, it was so interesting. Sunny was hosting and it was like three hours long. Yep. But it was great. It was like, it's basically, I'm doing something similar episode by episode spread out over months, he did it in three hours. So we'll, we'll link to that. If people wanna sort of front run me, hear what, who I'm gonna interview next, but anyway. Cool.

Sergey Gorbunov (00:53:21):
Yeah. So yeah, I think, you know, Sunny and the team, I think they kind of publicly said that they think kind of Axelar approach is the best technologically. What provides for osmosis. It's still gonna be a subject to a governance vote by the Osmosis community. So we'll kind of wait and see what happens then?

Anna Rose (00:53:39):
What about Polkadot, like, you just did the Moonbeam deployment, would you be interested, did in anything else, or did you do that primarily? Cause it's like EVM and it's something that you're, I mean, I guess you have solidity contracts or you have some template that's somewhat easy to deploy to EVM, but yeah. Are you looking at other parachains?

Sergey Gorbunov (00:53:58):
Yeah, I think for us, like Polkadot ecosystem is like kind of forget the technical differences, but I think very exciting because of the connectivity interoperability they have within their own you know, ecosystem. So that's why, you know, we connected with Moonbeam. There are a couple other big parachains that I think have EVM compatibility. So we'll kind of see what happens there. And I think we'll also see how a lot of the, the traffic is routed. Right. Is it gonna be now, you know, suppose you go from a Cosmos to Polkadot, right. That's like IBC then a Axelar, Axelar to EVM, EVM to, you know, another message format within yeah. With,

Anna Rose (00:54:36):
I don't know if that's a message format actually, but anyway,

Sergey Gorbunov (00:54:39):
XMP or what do they call it?

Anna Rose (00:54:40):
XMP. Oh, yes, yes, yes.

Sergey Gorbunov (00:54:41):
Yeah. Something like that. So, so yeah, and then that message format. And so, you know, I think it'll be quite interesting. So one of the next steps for interoperability in general is, would be to build this kind of protocols on top of the core pipes in some sense, right. To make it easy for all these end-to-end flows for the users and applications. So I think that will almost require like a service layer above the network to make some of those things easier and, and multi hop routing in particular,

Anna Rose (00:55:08):
And what about Ethereum and the L2s this is sort of my last kind of question on networks. Like yes, they themselves are kind of like, they have kind of mini bridges to the mainchain often, but yeah. Would you imagine bridging between the L2s?

Sergey Gorbunov (00:55:24):
Oh, for sure. Right. And the, you know, I think a lot of them have a asked for it and you know, so we connected to Polygon. Right. And I think we'll connect to, you know, a bunch of others as well. I mean, I think Ethereum in some sense is becoming like another interoperability hub, right. Where you've seen a lot of the applications, you know, migrate from the main chain to one of this you know, L2s right, or side chains, then Ethereum, what does Ethereum get you? It gets you, you know, security and message relay and transport layer in some sense. Right. So, but it is a very expensive layer, right. No matter what the transaction fees are there still ridiculous. You know, we'll see what happens with the proof of stake migration in, in that process. You know, you having Axelar as the proof of stake network already, right. Allows you to do similar types of functionalities, but in a, in a much cheaper environment. Mm.

Anna Rose (00:56:18):
So I wanna ask you a question about zero knowledge and sort of the actual ZK as validity proof. Do you have ZK in your stack anywhere, or do you have plans to have it?

Sergey Gorbunov (00:56:30):
I mean, not directly, right. Indirectly ZK is used, like in some of the threshold libraries, right. In threshold cryptography to prove certain statements directly, I think it would quite interesting to use it potential down the line again, for the purpose of optimizing some of the validation, you know, semantics right. And transaction sizes. So instead of having, you know, validators compute either, you know, multisig or threshold cryptography, you can, you can come up, you can think of creating you know, a zero knowledge or a proof, right. That the validators have validated a certain message on the source chain by they serve consensus layer or, you know, in smart contracts and then relaying that proof to different chains that we connected with and then just validating it there. Right. So I think that would be quite interesting. I think that would be definitely one of the directions to get us to, you know, many hundreds or even thousands of validators, depending on how optimal you can make this zero knowledge or, or proofs and how efficient you can make the validation logic. Right. definitely something I think worth exploring. And I think the, the second direction, which I'm super excited about is actually working with privacy preserving chains.

Anna Rose (00:57:44):
Right. Yeah. That was actually my next question. I was about to ask you. Great. It's like, what about the privacy part? Cause we talked about a bit like the use of the cryptography, but yeah.

Sergey Gorbunov (00:57:52):
Yeah. So super excited about that. You know, we actually just couple of days ago announced the partnership with Manta network, right. Which is on Polkadot that uses some of the zero knowledge techniques to get privacy. And it's super exciting to me because it enables you to send information, let's say to a privacy preserving chain, almost like to, you know, a black box, do some stuff with that information. Right. Like manipulate it a process, it compute it, exchange it, and then you can come out, you know, on the other end. Right. And like continue sending your assets or your information to, to other ecosystems. So I think it'll be a really exciting direction to see these privacy preserving chains connected to, to other ecosystems.

Anna Rose (00:58:37):
Would you ever be able to provide privacy within Axelar? I mean, I guess not really. If it comes out the other end it's sort of public, but yeah. I don't know if you've been thinking about that maybe or between two privacy chains maybe is another way to think about it.

Sergey Gorbunov (00:58:51):
Great question. So I haven't thought about it too much. I mean, again, in some sense it's a proof of stake network, like any other, so if you wanted to apply privacy, okay. You have to do like research what other people have done kind of what works in the Cosmo stack and with its Merkle tree limitations and, and all that stuff. And so you can definitely apply it if you wanted to. And you know, I, I think we'll have to, I'll have to think more.

Anna Rose (00:59:17):
Yeah. I mean, I guess penumbra for cosmos SDK, they're definitely working on some privacy things, right. Something to check out, but in terms of that going across, I just sort of wanna keep thinking that like so far right now, if you wanted to move from one chain to another, you basically have to de cloak to do it, right. Like you have to unshield, that's what we should be using cloaking, like Star Trek. Why do we use shielding? Sorry, just had a thought. But anyway I love the the like you'd have to basically unshield the asset and then ship it over. Like there's no way right now to keep it private into the bridge. Cause I guess you need to know the amounts where it comes from. And like there's probably too much info that isn't yet you can't yet make private.

Sergey Gorbunov (01:00:03):
So yeah, right now there is no way, I mean, I can think of a couple ways of, of doing it. So for instance, you know, if Axelar network supports kind of a MPC protocols, right, then you can have a protocol where instead of actually, you know, unshielding your transaction, right. Maybe you communicate you share a secret key to the Axelar validators that allows them to privately decrypt the transaction amongst themselves. Nobody has the transaction clear, but it serve a secret share across all of the validators, do their necessary functions to validate it right. And compute a message that needs to be post that on the destination chain in a shielded way. Right. So I can definitely see, you know, theoretically how this would work. Yeah, but practically and engineering wise, I think it would be quite an interesting quite interesting project to do.

Anna Rose (01:00:57):
Cool. I do have one last question, which is a little bit about the competitive landscape. We started with that. Like I mentioned, that, that like, you know, yours was the first project that I'd really understood to act that way, but since then there's other projects that maybe even existed, but I didn't understand them as being sort of this multi asset interoperability play, but there are new ones. How do you think about those? How do you see yourself as different from those? Or do you see these project sort of all kind of headed towards this very similar architecture?

Sergey Gorbunov (01:01:28):
No, not at all. Right. I think A, you're still continuing to see a lot of pair wise solutions, which I think, you know have scalability effects and kind of fragmentation issues that you're gonna have to deal with down the line, B I think a lot of the protocols and there's a, you know, a number of protocols that have been proposed that kind of rewrite and, and change the, the name of things and kind of obfuscate it and actually doesn't add anything to the security of the cross-chain or interoperability. I mean, I think building a decentralized interoperability protocol that works across different stacks is, is again, like very challenging, right? I think it's, it's, it's a very complex technical problem. I think a lot of people have taken, you know, shortcuts along the way to get to the user experience that I think we've been describing for, for the last year. Right. And like pioneer than one of the white papers that we wrote with the gateways and kind of communication across them, you can get to that user experience in a, you know, with centralized backends in some sense, which I think is a mistake and you're gonna be run into the security tissues, but get into that user experience with a decentralized backend, I think is a very complex kind of a problem.

Anna Rose (01:02:38):
Of the other solutions. This is a kind of a funny question. I've never asked anyone else, but I'm curious how you'll answer it. Which is your favorite, which is your favorite of your competitors? Who do you think is like really good? I'm gonna try to ask everyone all the bridge, all the bridging people, this

Sergey Gorbunov (01:02:56):
Great question. So

Anna Rose (01:03:01):
You don't wanna get, you don't wanna say it's such a hard one.

Sergey Gorbunov (01:03:06):
It it's a hard one. 

Anna Rose (01:03:10):
Wormhole, Nomad?

Sergey Gorbunov (01:03:13):
No, I mean, I think Wormhole is centralized bridge for all practical purposes, right? I mean, no matter, I think explores interesting trade offs in the safety and liveness assumptions, but I think from a safety and decentralization perspective it's a step backwards in some sense. Because I think, you know, they, they introduce liveness assumptions to guarantee safety, which I think is very dangerous for the cross-chain world given like all the attacks that we're, that we're seeing in this base. There's not a lot of research on, on this, right on this interoperability, at least protocols that I would consider any, any sound or any, any truthful. I think there's a lot of marketing material and you know, heuristics proposals out there by some people that don't understand anything about basic liveness and safety properties and trying to market, you know, and go to market with them which I think is a huge mistake.

Sergey Gorbunov (01:04:04):
So I actually would love to see, you know, more rigorous analysis on the safety and liveness of the protocols and on the trade offs and the, you know distinction between, you know, permission or permissionless systems which is not something we're, we're seeing a lot in the space. So I would say, you know, it is a hard technical problem. I think a lot of the teams are doing, you know, the best that they can to sort of to solve it. But I think we have, you know, the best and the most decentralized approach and the most universal approach that, that I've seen to date. So,

Anna Rose (01:04:37):
All right. Well said like a true businessman.

Anna Rose (01:04:41):
All right. But I'll, I'll take it. I'm gonna, I am gonna try this potentially with other interviews so they can get prepared for that question of who of your competitors do you like the most? Well, listen, Sergey, thanks for coming on the show and sharing with us, this sort of story of Axelar, the work that you're doing, what makes it unique and yeah. Where you, I think it would be really cool to hear kind of what's coming next and then I think we'll wrap up. So yeah. What is coming next?

Sergey Gorbunov (01:05:08):
Yeah, I mean continuing the network rollouts of various features will go live like, you know, general message passing will go live right on the network across EVM chains. And then we you know, look enough how to extend it to Cosmos chains as well. So I think that's gonna be, you know, super exciting more connections, right. To more networks that are not connected, more applications integrated on top of the network. So we have a huge pipeline of everybody from cross-chain, DEXes, you know, NFTs wallets that are building around the network. So I think that would be, you know, super exciting. And yeah, I think the, the goal is to get us to a world where people or users don't have to think about multichain, right. Or cross-chain. I think these things have to be obfuscated and taken away from the user interaction. So to me the biggest goal and that's the biggest you know, point to work towards.

Anna Rose (01:06:01):
Cool. Well, thank you so much again for coming on the show.

Sergey Gorbunov (01:06:04):
Awesome. It was great being here, Anna. Thanks.

Anna Rose (01:06:06):
I wanna say thank you to Tanya, the podcast producer, Henrick, the podcast editor and to our listeners. Thanks for listening.