 Hello, I'm Dionysius Zindros, I'm a PhD candidate at the University of Athens, and I'm working on blockchain technology and cryptography, and in particular my research interests are in sidechains and the consensus layer of blockchains in general. So today I will show you a high level overview of what sidechains are and what you can do with them. So let's begin with sidechains, this is a blockchain technology, it's an upcoming idea. It has not been fully implemented yet, it's not something that you can use already, but it's our plan to make it possible to use this on various blockchains, and in particular Cardano and the Adder cryptocurrency. So let's go over what sidechains are and how they work. So first let's imagine two existing blockchains, let's say the Bitcoin blockchain and the Ethereum Classic blockchain, and let's imagine that these two blockchains supported the idea of sidechains, which is not something that they do, but as an exercise let's see how it could possibly work to have sidechains on these blockchains before we get into how they could work for the Cardano platform and how they will work for the Cardano platform. So in these chains we have a main chain and we also have a side chain. So let's imagine that this is our main chain and this is our side chain. Whether this is the main chain or this is the side chain can be swapped around, but for now let's imagine that they have this kind of relationship with them. Now in the Bitcoin blockchain we have a Genesis block and the Ethereum Classic we also have a Genesis block and time goes by and blocks are created. Now what sidechains allows us to do is to move value that is denominated in one of these two into the other blockchain. So the idea is that let's say I'm storing some Bitcoin in some account on this blockchain. So imagine I have some sort of account to my name with one Bitcoin, let's say I have a transaction that gives that amount to me and then I want to move that one Bitcoin into the Ethereum Classic blockchain. So at some time, let's say t0, I want to be able to move that amount and have it remain a Bitcoin from the Bitcoin main chain into the Ethereum side chain. So what I do is on this block I create a transaction that moves out that one Bitcoin from this Bitcoin blockchain into the Ethereum Classic blockchain and here I create another transaction that receives that amount. So here I create a transaction that consumes this Bitcoin and here I create a transaction that emits this Bitcoin. Now suddenly after this block this Bitcoin disappears from the Bitcoin blockchain and appears in the Ethereum Classic blockchain and note that the unit of account in both cases remains one Bitcoin. So what I've done is I've moved a Bitcoin from the Bitcoin blockchain into the Ethereum Classic blockchain but it has not become an ether, it's not a different coin. So this is similar to an exchange taking place, a coin that is exchanged for another coin that live on different blockchains, however here I don't have any counterparties, I don't have anyone that I have exchanged with, I just did this on my own. So I've moved value, I've moved an asset from one blockchain to another like this. And then these blockchains keep evolving, they keep creating blocks and of course Ethereum blocks are much, much more often than Bitcoin blocks so you can represent that like this and then at some point I can move that amount back and so this Bitcoin now is destroyed on the Ethereum Classic chain and it appears again on the Bitcoin blockchain. So this is a two-way peg, what we call a two-way peg and the peg means that one Bitcoin on the Bitcoin blockchain is worth one Bitcoin on the Ethereum Classic blockchain, they're the same value, they're the same unit of account and the two way means that I can move them back and forth, I can move them around like this. So this is already very useful, let's see some applications of this. So imagine that on the Bitcoin blockchain I use it as my savings account, I keep some coins here, let's say I have a wallet of 30 Bitcoin, these are my savings and then I want to be able to work with the Ethereum features with just some of these coins. So let's say I take 0.1 Bitcoin from here, I remove it from my 30 Bitcoin that I had and I keep some of them on the Bitcoin blockchain and some of them I move into the Ethereum Classic blockchain, so see how that will work. So at some point I have all these coins together and they live here and then I decide to split them up, so at this point here I have 29.9 Bitcoin on the Bitcoin blockchain and I'm moving 0.1 Bitcoin into the Ethereum Classic blockchain and so I have here this amount. Now the owner did not change, it's still me but the amount that I have here and the amount that I have there is different. Now why is this useful? It's useful because in Ethereum I have all these nice features that I don't have on Bitcoin yet, for example fast blocks, low fees and tiering completeness. So I can do as I please with these 0.1 Bitcoin in the Ethereum Classic blockchain, I can put them into an ICO, I can put them into a DAO, I can put them into a different kind of smart contract, whatever I like. All the tiering complete features of Ethereum, Archea, or I can just use them to pay salaries without having to pay huge fees and without waiting for long confirmation times. Now this 0.1 Bitcoin can be moved around between people, it can change hands, it can change owners but the total will remain 0.1 Bitcoin. Now whenever some of the people that I've paid wants to move back some of their coins, they can do so by the reverse transaction. So in that case, eventually maybe 0.1 Bitcoin will potentially go back to the Bitcoin blockchain. And the usefulness is that while it lives, while the 0.1 Bitcoin lives on the Ethereum Classic blockchain, all of these features are very useful, I can just use them and they were not available before. Now let's move on to how Cardano plans to use sidechains and how we will implement sidechains and Cardano. So now that we've explained how sidechains and mainchains would work and we've imagined them on traditional cryptocurrencies where they're not yet possible, I will now explain how we plan to do them on Cardano. So sidechains on Cardano, Cardano already has one main chain, the Cardano settlement layer main chain. This is where ADA lives, the cryptocurrency of Cardano, this is what we call the home blockchain of ADA, the blockchain where ADA is created and where it's normally maintained. It also has a series of blocks and you can keep your ADA safe on this ledger in which you will have your savings accounts. So I could have 10 kilo ADA right here. The settlement layer of Cardano is a simple blockchain, it has very limited features and this is a choice, it's a design choice. We have designed it this way so that it remains simple and so that we can audit its security. So simplicity is one of the features that we want for the Cardano settlement layer and this is because we can achieve better security through simplicity. So limited attack surface means that the number of features that this has is low and so the things that could possibly go wrong is limited. The number of possible holes that an attacker could find, the number of vulnerabilities and adversary could look into is limited. So the code is also limited, so small code base and auditability. Because everything is open source, people can look at this code and because it's a short amount of code they can see that everything will work fine from a security point of view. So this is the reason we don't want to add many complicated features to the Cardano settlement layer, we don't want to add Turing completeness or smart contracts here. To add support for smart contracts, there will be a different chain, the computation layer. The computation layer will be a different blockchain but it will be part of the Cardano network. So both of these are Cardano blockchains and both of these maintain the same asset adder which moves back and forth between these chains. So the side chain also has a Genesis block and a series of blocks and it allows people to move adder from the main chain into the side chain and back, like we explained before. So at some block, I can move some of my adder to the side chain, work with it with a smart contract and eventually move it back if I want to. And if it has changed hands here, this is fine, the person that has now the ownership of the adder can now move it back if they like. Now keeping adder in the main chain or the side chain is a trade-off. If you keep it on the settlement layer, you have limited features. You don't have Turing completeness but you have very, very good security that has been audited and the limited features give you this good security. On the other hand, if you're working with the computation layer, you have all the feature richness of a Turing complete language. For example, Plutus is one. However, this is a complicated blockchain similar to the Ethereum blockchain where a lot of features are incorporated and we have to be very careful about making sure that every part is secure. So while you keep your adder here, you lower security and you increase feature richness. So on the computation layer, we can innovate, we can test out new features. So you can think of this, the settlement layer as a very careful blockchain like the Bitcoin blockchain where changes are slow and the developers are very careful about reviewing new patches and proposing changes. While the computation layer, you can think of it as a theorem where the developers iterate more quickly, they try out more features, maybe they even do some hard forks to enable new features and so on. So it's a balance, it's a trade-off. Now how do we ensure security in case there is some sort of catastrophic failure between the two chains? So this is something that we call the firewall property of side chains. And let's see what this means. Now imagine that, of course we want to keep the side chain very safe and we want to review all the code, but imagine that some sort of catastrophic failure allowed an attacker to create an arbitrary amount of money within the side chain. So at some point in time, there is a catastrophic failure. So maybe this is a bug, maybe this could be a security assumption that was violated, but after some sort of block, it could be possible imagine that an attacker creates more money than they should be able to. So what the firewall property gives us is the following. If on the add a settlement layer, we've moved as users, the total user base, if we've moved together a certain amount of add a, let's say 100,000 add a, then in the future there is no way to return more than this back into the main chain. So I can still make transactions to bring money back, but the total amount here and the total amount there has to be at most equal. So this is always less than or equal to 100,000 add a. Of course, people can move add a back and then move it, move it back and forth as many times as they like, even after the failure. But this is a kind of limited liability that the main chain, you could think of it as a loan. The main chain gives a loan of 100,000 add a into the side chain. And then the side chains liability is to pay it back, but it cannot move more money back because this is the money that is owned by the main chain, essentially. So now that we've seen what side chains are, let's see a little bit more about how they work in order to be able to move money back and forth between chains. We need to create transactions that enable this movement of money. So let's imagine I want to move one add a from the main chain to the side chain. And let's go over how this will happen. I have this add a in one of my accounts. What I do to move it to the side chain into one of my accounts, let's call this account a and let's call this account b. What I will do is I will create here a transaction that wants to move this one add a from account a to account b. If both of these accounts were on the same chain, this would be easy. I could just create one transaction that moves money from a to b. But here I have to move money cross chain. So the way that I will do this is I will create a transaction that takes money out of the account a and destroys this money. So this money is no longer spendable here. It's like a proof of burn. So this is the destruction of money on this side. And this transaction is going to be confirmed in one of the main chain blocks. So this transaction here is going to be put in here. So what this block stores is a transaction that takes money out of the account of a and moves it into a location that is now unspendable. At the same time, on the side chain, we want a similar transaction, maybe a dual transaction that creates money. So this is a creation of money. And this is the this is the burn transaction. And here we will have a dual Coinbase transaction. So this is not the usual Coinbase transaction that creates money out of mining. It's a Coinbase transaction that creates money out of a dual transaction that has destroyed it. But for this side chain, again, it seems that this money appears out of nothing and goes into B's account. So this transaction will have to be confirmed as well. So it goes in here. Now the important part is that the input to this transaction, I'm drawing these transactions as if they had unspent transaction outputs and inputs in the same way that they work in Bitcoin, but they could easily work in the same way that Ethereum works with accounts, inputs and outputs. Now once this transaction is created, it needs to be confirmed by the mentors in the side chain or the miners depending on what kind of coin we're working with. So it could be that both of these are proof of work chains. It could be that they're proof of stake chains like Cardano is, or they could be a hybrid. So one of them could be work, the other could be stake. So let's imagine that we have a proof of stake in both. So in the case of a proof of stake, what we need is that this input to this transaction is confirmed to be a rightful creation of money. So it needs to have a reference to this corresponding burn transaction. The way to do that is once we have this block buried under enough other blocks, let's say K other blocks to make sure that this is stable, and imagine K is equal to 6 in case of Bitcoin where we say, oh this has been confirmed enough. Now this transaction along with this block can be collected all of this part. So all the proof of stake or all the proof of work from Genesis up to this block and including this transaction and this extra blocks on top, all this has to be collected into a short proof that this input into the Coinbase transaction is a rightful creation of money. So you can imagine this being sucked up into a short proof and this proof is put into this transaction as a way to say that I have the right to create this money. Now if we're talking about mining and proof of work, then this proof that illustrates that all of this history has happened is called a proof of proof of work. Why is it called a proof of proof of work? All of this chain had some proof of work happening up to this block in which the burn transaction took place. However, we don't want to represent all this proof of work by illustrating the whole proof of work. Why? Because it's very long. For instance, in Bitcoin's case, the chain from Genesis to the current block is maybe 400,000 blocks. The proof of work is represented by the block headers, each of which could be 80 bytes long. So the total of this would be more than 32 megabytes of block headers. However, this is just a transaction and we want a transaction to be very short in size. This is why we compress all of this proof of work into a short proof that illustrates that proof of work did actually happen without ever showing the proof of work itself. So it's a proof of proof of work or a popeau. These proofs can be quite short. They can be maybe a few hundred kilobytes, let's say 100 kilobytes. And so for modern blockchains, they can be included within transactions themselves. And the nice part about these is that they can be checked independently by the miners living within this side chain. So if a miner exists here and is mining this side chain, they don't need to look into this network of the main chain at all to see that this transaction was really valid. In fact, this check can be encoded into a simple smart contract that says check that the proof of proof of work actually captures some proof of work that shows that this transaction was confirmed and buried under a sufficient number of blocks. So these are checkable by verifiers that don't have any idea what is going on here. In order to make this transaction, the steps would be as follows. First, I create the transaction here to destroy the money. Then I take this transaction along with the previous proof of work and I create a proof of proof of work. And this is a short string, so it's a sequence of bytes, like a small file. I take that and then I put it into a new transaction which I create on the side chain. I post it into a smart contract. The smart contract checks that it's valid and then it's mined by a miner within the side chain and the miner executes the smart contract, making sure that everything is okay without ever having any special opcodes that look into what's happening on the main chain. These proofs of proof of work have been explored in a paper by KLS in 2016 published in financial crypto. So this is KLS, etc., and they were the first proof of work to be constructed, but for this case we need something slightly additional. What we need is something that we call non-interactive proofs of proof of work. So this is a construction that we made this year with my advisor KLS and Andrew Miller. Non-interactive proofs of proof of work or NEPOPAUS, they allow the exact creation of these proofs, but in just one step. So to just compare what non-interactive means, if you have interactive proofs of proof of work, you may need to do multiple transactions to ensure that you're proving that this took place correctly. However, with non-interactive ones, you just create a short file, a piece of proof, and you post it on one transaction and you don't have to do anything else. It should be sufficient to convince any miner on the side chain that your money has been destroyed on the main chain and rightfully you can make it appear on the main chain. All right, so now that we've established how side chains and main chains interoperate within the cardinal system, how you can move things around, and how you can create proofs of proof of work or proofs of proof of stake. Now, that we've also showed the firewall property that guards against catastrophic failures in one side chain. Let's talk a little bit about how these proofs of proofs look like. So let's talk about how these proofs of proof look like. And recall that I mentioned there's proofs of proof of work, but there's also proofs of proof of stake. So these are the two main categories and what these do is you want to capture in a short string, a short piece of file that proof of work or proof of stake took place. So I'll get a little bit more technical on how we do that in the case of work, in the case of proof of work, but recall that cardinal is a proof of stake system. So in that case, it's a different construction. So for proofs of proof of work, what we want to do is given a work-based blockchain, we want to create a short file that captures the fact that there's so many blocks here. Let's say there's 400,000 blocks here. So I want to say there exists a connection from Genesis to this block that is K blocks from the end. And I also want to include in my proof the hash of this block so that I can show that a transaction was included in its Merkle Tree. If I'm able to show that the blockchain from Genesis to here, where Genesis is the string that you already know, is 400,000 blocks long and the hash of the last block is such and such, then using a standard Merkle Tree inclusion proof, I can then show that this transaction was confirmed in the blockchain that has so many blocks. And I can also include a small suffix of K blocks to show that this block has been buried under sufficient proof of work. Now in order to do that, what we do is we do some modifications on how the blockchain is constructed. So let's look a little bit about how work is done to generate new blocks. Recall that there's something that we call the mining target. And whenever I create a block and I try to confirm some transactions by hashing the Merkle Tree route along with some nonce, what happens is I do a brute force loop. My ASIC or my GPU does a brute force loop that checks if the block ID is below a certain threshold of T. And the block ID is just the number of the block itself. It's a big hash and this inequality being less than T, sometimes we express it as the fact that the hash of the block begins with enough zeros. But more precisely, what we're saying is that it's below a certain threshold. So whenever a miner tries to create a new block, this block ID is just completely random. So imagine that I have this range of numbers. Maybe let's draw it horizontally. So imagine that you have this range of numbers that are all the possible block IDs. So these are from zero up to some power of two. So two to the kappa. Okay. And then there is a certain threshold. Let's say it's actually quite low, but I will put it here just for having some space in the interest of space. Now, when I do an attempt to mine blocks, each attempt will just be a random selection of numbers from zero to two to the kappa. So it could end up here, which is an invalid block, or it could end up here, which is a valid block. Now whenever I find a valid block as an honest miner, I will broadcast it to the network and the others can verify that the ID falls within this range. So it starts with the appropriate number of zeros. But here's something that we noticed. If we look at only the valid blocks, then this range can be split into two. So this is two t halves. And because these numbers of valid blocks are completely random, half of the blocks will fall here and half of the blocks will fall here. We call the blocks that fall within this range on the lower half superblocks or one superblocks. We can repeat this process and split this portion here into half and look at this t quotas portion over here. And then we notice that one quarter of the total blocks will fall within this range. So these are called two superblocks. And we can split it again here. And the blocks that will have this ID will be one eighth of the total blocks. We can continue this. And we can say if I keep splitting it new times, then a portion one over two to the new blocks will fall within that range. So for instance, if new is zero, then this is two to the zero. So this is one over one. So all blocks will fall within that range. It's 100%. If I set mu one, I say this is one superblock. So it's half or one over two blocks having this level, mu. If I'm talking about one eighth, or setting mu to three, then one over eight blocks will have this property, one eighth of the blocks will have this property. Now, why this is important is is this. In my blockchain that has 400,000 blocks, about half of them will be one superblocks. So that's 200,000 blocks. About a culture of them will be two superblocks. So that's 100,000 of them. But if I'm looking at, let's say level 15 of superblocks, then there's very few blocks that are 15 superblocks. Somehow these superblocks capture a lot of proof of work within them because they were very lucky blocks. They happen only occasionally. So within 400,000 blocks, 15 superblocks, we could have maybe just 10. However, the fact that these 10 have occurred somehow captures the fact that there has been work happening within the blockchain because all of these blocks would have to be tried out to get so many 15 superblocks or superblocks of level 15. So just keeping these 10, 15 superblocks, so the count of blocks is 10 and their level is 15, allows us to illustrate to someone who doesn't have the whole blockchain the fact that work took place. So just capturing these 10 blocks and sending them is a proof of work. So we can just send these and this should be sufficient to claim to someone that look 400,000 blocks of level zero or approximately so many have been mined because this is the only way I could get 15 superblocks or 10 blocks of level 15. So this is the way the gist of the construction on how this works. Of course, of course there's a lot of mathematics involved in proving it secure and proving it, proving that an adversary cannot create such proofs and convince a verifier about something that did not take place. But I think this captures the basic idea of how we could compress the blockchain into a short amount of blocks. So now that I've showed you what sidechains are, what main chains are, and how they could work for traditional cryptocurrencies and how they will work for Cadano's settlement layer and computational layer, let's talk about the applications and implications of sidechain technology to wrap up this talk. So I'd like to mention four important properties that are possible with Cardano and how three of them are enabled by sidechains and how sidechains play a role in making sure that they're properly done. So the four properties that I like about Cardano is sustainability, is interoperability, scalability, and upgradeability. So Cardano's sustainability is really about proof of stake and how this does not waste energy resources. It doesn't have the huge impact on the environment that work-based cryptocurrencies have, and hopefully it's something that can continue to live on for many, many years and become a mainstream means of value exchange. The other three properties are the thing that is enabled by sidechains. So this is proof of stake idea, but these three things are sidechains enabled. So having sidechains means that we can have these properties. Let's talk first about interoperability. Now I've already shown you how Bitcoin and Ethereum or Ethereum Classic could work together and have value exchange between them. This is something that could happen as well with Cardano and other coins that are willing to adopt the sidechain features. So if Ethereum Classic wanted to adopt the ability to interoperate with Cardano, then that means that we could move ADA from Cardano into the Ethereum Classic blockchain and back, but also vice versa. We could move Ether from the Ethereum Classic blockchain into the Cardano blockchain and back. So these chains can work with one another in this manner. Now one exciting topic about interoperability is how these sidechains could interoperate with more traditional systems like the banking system. So I personally prefer to keep my money decentralized, but many people want to interoperate with the traditional system. If we have the Cardano main chain living as a settlement layer, there is no one preventing people from creating their own sidechains. And as long as Cardano supports this kind of interoperability, we could see developers creating sidechains with their own blockchains, with their own features. So if a bank, let's say, wanted to create their own sidechain, ideally we wouldn't want it to be Cardano approved. So as I keep my ADA within the Cardano main chain and I don't move it to any sidechain that I don't like, I don't care as a user if there's sidechains that I don't agree with that have different security requirements and different security assumptions and a different threat model. However, there have been organizations that have created unfree blockchains. So this could be an unfree blockchain, meaning a permissioned blockchain. And these are useful for certain applications and to some people. Now if these people wanted to interoperate with the banking sector, they could move their ADA to this sidechain. And then because we have the firewall property between the two, the amount of money that can be moved back is limited. And so if I don't agree as an ADA user, as a Cardano user, if I don't agree with this sidechain and the fact that it has trusted third parties, I don't have to move my ADA into it. But the people that move their ADA into it are essentially saying how much liable we are and they're putting their capital as liability. And so the people that move the ADA here into the sidechain, they're vouching with their money and then the amount of money that can be moved back is exactly the same. So if this banking sidechain decides to somehow allow central parties to create money out of thin air, that's fine because the amount of money that can be returned is really limited. And so for me, as a Cardano user on the decentralized and permissionless chain, it will mean that this is for me nothing more than a transaction. But for banking applications, if regulators want to create a sidechain that has laws applied to it, it has central parties like judges or jurors applying traditional legal decisions on this part, this does not affect the decentralized portion. And so we can move money back and forth and this money can be more regulated if they want to and this can remain the way it is. And of course money can be moved back and forth here, but the rules of how to move money back from this sidechain is really up to the security assumptions that this sidechain has. So if it requires a signature from a central party to say that, oh, this transaction has been approved by a legal authority, then they can have this requirement before moving money back. And this is really up to the sidechain operator to say, what are the rules? But for ADA, we don't really care. It's really an open ecosystem where people could create potentially other sidechains that have their own features. So this is about the interoperability with the regulation and traditional system. Now about scalability, this is a big problem in current blockchains and Bitcoin is currently facing this problem. Even Ethereum is currently facing such problems. The question is how do you achieve high throughput in your blockchain? How do you achieve many transactions per second or many transactions per block? But if you have sidechains, you have an immediate way of sharding your blockchain. So here's one idea and I don't know if this will be implemented in Cardano, but it's definitely possible with this technology. If you have your main chain where you keep your money, you can use this as a settlement layer and then you can create one sidechain per industry. So you could say, here's the automobile industry. Here's the travel industry. These people that work in these industries, they regularly transact with one another. So what they could do, what a travel company could do is they could create a separate chain and then the companies that are working in the travel industry or the professionals that are working there could move their money from the main chain into the travel industry chain and then they could do all the transactions that are that pertain to travel within that chain and then whenever they want to move money back, they can do this with a two-way peg and that means that all the transactions that happen within this industry, they're offloaded off the main chain and so that means that they don't really count towards the throughput of the main chain because as I said previously, these are minted or mined separately and so we don't have this limit in this combined way. So it's a very simple way of shodding things. So the automobile again industry could have their own chain and whenever these two sidechains want to interoperate with one another, if the travel operator wants to pay an automobile operator, either I can move it back to the main chain and into the automobile chain or I can move it directly like this. So whether this will be possible is slightly an open research question of how exactly you can move things around between sidechains but definitely you can improve scalability by offloading transactions all for the main chain and into specialized sidechains. So this is how the scalability portion is solved and now for the last part, the last feature of upgradeability, this is also a hot topic it has been the cause of a civil war within bitcoin and with bitcoin and bitcoin cash people that want a different feature they really have to hard fork the chain and cause a split and a polarization of the supporters but with sidechains hopefully we can solve that and the way that it could work is as follows. Suppose that I have a main chain and this main chain has a certain number of features but not everybody agrees with these features it could be for example the block size limit. Now if I want to I can create a sidechain that has a different set of walls but now I no longer need to create my own token and wait for it to gain value I don't need to to take care of volatility or be concerned about any of that what I can do is with sidechains I can just move money say adder out of the main chain and into the main chain into the sidechain and then immediately I can enjoy the features of the sidechain without needing an exchange without needing to care about volatility without finding a counterparty that is willing to buy from me and without risking the value that I'm putting in because I can always turn it back but at the same time the people that don't trust the sidechain they don't have to move money out for the purposes of a main chain user the sidechain is nothing more but an account right because there's a firewall between the two and so I can keep using the features of the sidechain like this now imagine if the bitcoin debate was realized like this so in this case we could have the bitcoin blockchain here we could have a separate bitcoin cash blockchain here that has a completely separate history it starts maybe more recently but it doesn't share the history like they did and then whenever somebody wanted to use eight megabyte blocks or they want to use faster confirmation times all they had to do was move one bitcoin into the bitcoin cash blockchain they could transact in it for as long as they liked and then move it back in fact they didn't even have to move it back they could keep it here and if eventually everybody moved their capital out of bitcoin and into the bitcoin cash sidechain then the bitcoin blockchain could eventually become obsolete and this is a smooth way of upgrading the the coin and in that case all of this history could just disappear and all we left all we left with are proofs of proof of work that this coin was created rightfully but that's all and therefore this is a smooth way of creating a new feature without causing polarization between the supporters so i think this sums up the nice applications of sidechains interoperability scalability and upgradeability and this also sums up my my talk on sidechains and cardano and i hope this was a way a good introduction to see how these work and what are the benefits of using them