Cardano Progress Update by Sebastien Guillemot (Oct 2019)


Hey everybody my name is Sebastien and I’m the Engineering Lead at EMURGO, One of the companies behind the Cardano project. In this video, i’m gonna talk about all the work that’s happened in the Cardano ecosystem in the month of September and part of the month of October. So a lot has happened as usual such as the launch of the network testnet
for Shelley, we had stuff like the upcoming release of Daedalus, the new version of Marlowe, a lot of exciting research papers. So before I start this video I just want to
apologize for this video being a little late I caught a cold at the start of the month and so my voice didn’t really sound good so I had to wait a bit longer for it to heal so, sorry the video is a bit late but let’s get right into it. The most exciting thing I want to talk about was the launch of the network testnet for
Shelley. So what does that mean? So we had a testnet before for Shelley, but you could not communicate with other nodes. Now with the network testnet, you can start up a node and you can connect to the blockchain, download blocks, create a stake pool, join a stake pool all this kind of fun stuff. You can also, if you really want to create your own private network and connect with
your friends and have your own mini Shelley testnet. And so IOHK has a blog post about the topic that explains it in detail and so I’ll have a link in the YouTube description to this blog post. But you can definitely go check it out and play with it and Rick has a video livestream on his channel, I need to probably refresh
it He has a livestream on his channel that shows all the networks or all be nodes in the Shelley
testnet You can see this is Rick’s node right here connecting to all the other nodes in the world. So if you want to, you can run your own Shelley
node and see how it connects to Rick’s node and other nodes across the world. So you can see there’s a lot of notes running
a lot people participating in the networking testnet and this is the second step of our testnet
release. The third step will be the incentized testnet Where we actually give rewards for staking. So right now, there are no rewards. You can create stake pools, you can join stake
pools, but there are no rewards for joining a stake
pool. And so the last step of the testnet will be adding incentive code. And that’s what the Jormungandar, The rust team has been working on. You can see in the past month and a half They’ve released a bunch of updates, a lot of these are about the networking test
net and making it more stable, work across multiple operating systems, easier to download, all this kind of stuff. And they’re also working on the incentive
code. So, you can see that they’ve added a bunch of stuff related to the incentives, they also have a readme on the github page that explains exactly how the incentives will
work. And so, if you’re not familiar how staking rewards will work in Cardano, I’ll have a link to this readme in the description that explains exactly how stakepools are rewarded, where do withdrawers come from, this kind of information. Obviously, they have not just worked on the incentive, they’ve also worked on tooling support for Jormungandar, which is
the Rust full node for Shelley. So they have a huge variety of github repositories, the whole different tools, So we have Jormungandar Nix for Nix tooling, we have Finnear for tool for monitoring stakepools, you can easily monitor if your pool went down or what happened, we also have Europe which is for installers or Jormungandar to make sure that you can get
easily install experience. We have Jormungandar testnets which is kind of a list of different test
nets available. And so, if you want to start your own testnet, you’ll be able to kind of come here and see what’s going on. Additionally, IOHK runs a few different testnets. For example they’ll have a stable and nightly, So stable will be only builds that we know
work for sure. Nightly will be continuous deployment, so if you want to try the latest features as they’re deployed to github, there’ll be a testnet for that. And we have a testnet stakepool registry validator
tool. And so basically the reason we need this is because for this testnet stakepool registry the way you add your testnet is that you will make a pull request on github and you’ll add your staking pool and say this is my staking pool information, and there’ll be a human verification component
to it along with a automatic verification component that your stake pool matches a set of conditions. Such as the name is unique, this kind of stuff. Obviously this is not kind of the final solution for the mainnet, But is kind of a temporary patch to make it easy to advertise your testnet pool while we’re running the incentivized testnet. And so a lot is happening on the Jormungandar to get all this incentive
testnet running, and not only are we doing a lot of work on the core tooling, obviously all the ecosystem has built to connect
to this testnet and the best way to connect to this test net is the Shelley Web Assembly Bindings. And so there’s a library for this called GS chain libs It is a library of rust that compiles to Web
Assembly so you can easily connect to Web Assembly from your Daedalus or Yoroi or whatever other application. Okay. And so, if you’re developing any tooling that wants to connect to the Shelley Testnet definitely check out this repository. The thing that they’ve done this month is they’ve added a bunch of examples of how
to use these Web Assembly Bindings for your various
projects. For example they have a wallet project which
is a very simple wallet. It’s just like you know, no fancy UI just like a box with an address
field in it. You put your address, it tells you the balance
of the address , and it’s meant to be very simple on purpose. That way, if you’re a developer you can get the smallest possible example
of how to integrate Shelley into your wallet. So if you’re a wallet developer then check
out this repository. We also have a faucet. So it’s an example pod to run a faucet for
Shelley, And so if you’re running a tool that uses
Shelley, you can check out this faucet and get some
ADA to help test your tool. We also have an explorer to show you how you would make an explorer with Shelley with Jormungandar. And you can see it kind of looks like this, so it’s not meant to be like a production tool. It’s just meant to be debugging tool to help
developers build the pretty explorers and the next explorers
for Shelley. This is a very basic tool just to get to see
blocks and information. And so right now I’m running a local host
version of it, and there will be a public version of it in
the future. They’re currently in the process of getting
it set up, so probably by the time you see this video this website will be working. You’ll be able to have a public Explorer for
Shelley. Again, this is a temporary website, Once Seiza and the Haskell themed Explorer
support Shelley natively, then we won’t really need a tool like this. But this is a nice simple example of how to connect Shelley to your Explorer so that only we can use it at EMURGO and the
others keeping it at IOHK but also any other company that wants to implement
Shelley can look in this example and see how they set it all up. So if you want to set it all up, what’s the
best way? Well, now we have an NPM package for the Y’s
and bindings. So if you want to try out web assembly for Shelley,
check out this NPM package. It’s built for browsers, so if you’re using
node.js you’ll need to use a slightly different version
of it. You can see it have examples of how to set
up with web pack, how to set up the code, examples of the code, everything you need to get started. So I’ll have a link to this NPM package at
the description So if you’re a developer, definitely check
it out. So how are we making use of this in Yoroi? Well, we unveiled our staking UI for Yoroi, so as you can see in this video from within
the Yoroi extension which runs on Chrome or Firefox, you can easily select your stake pool, look at the information about stake pools, press delegate, and easily delegate to stake
pools. So this is all within the familiar Yoroi UI. So how do we do this? Well one of the first steps towards doing
that, was rewriting our storage API to be able to
have it more flexible to support Shelley Wallets. And this Yoroi new storage API is super flexible, so it will also allow us to add stuff like
temporary wallets. So for example if you unplug your ledger device, the wallet will be removed from your Yoroi
instants, it’ll also allow us to do stuff like balance
trackers, a lot of stuff that our fans have been asking
us to include. So it’s really exciting. We also have a bunch of other stuff coming
up like the ledger rewrite. So ledger changes the protocol that’s required
to communicate with the ledger device. So we’ve taken this opportunity to make the Yoroi UI for our UX for ledger
integration more intuitive. So more explanations, more step-by-step, and
so that’ll probably be coming out with the next Yoroi release. We’re also working on a memo feature, and
so, let’s scroll, when you send a transaction you can easily
press the add memo button and you can connect with your Dropbox or external
storage to easily add memos to your transaction. And the reason this is important is because
oftentimes, for example, for tax purposes you need to remember why
transaction was sent and sometimes you don’t remember. And so now, with this memo feature it’ll be
easily able to add an explanation for what a transaction is for. And you can see in your transact history the
memo will be displayed and so how do we do this in a way that’s secure? Right, so we gave it a lot of thought about
this. For example how to make it secure even if
your Dropbox gets hacked, how do we make sure that if you open a new Yoroi instants on a new computer it’ll still restore your memos as is as they
were on your previous computer. And to do all of this we wrote two specifications. One, called the utility key derivation and one called the message signing specification. And we had both these specifications reviewed
by a cryptography auditing firm. So it’s not a full audit because we didn’t
review the code. We’re still writing the code though we had
all the cryptographers use the specification reviewed and signed
off by them. So we’re really excited about its feature it’s gonna take some time to get it all coated
out especially because we’re trying to balance
writing new features with supporting Shelley. But it’s some exciting stuff that though it’s
in the works for Yoroi. Another feature that’s really awesome is the
ability to see your balance in another currency and so we’re basically done with this feature
we just need to polish up the UI a bit, so probably coming up in a feature Yoroi release. It allows you to see, it allows you to see
your Yoroi balance in Bitcoin, Etherium, USD, a bunch of other fiat
currencies and so that’s something else that people have
been asking us for, and I’m really excited to be able to deliver
this feature. It’ll be first available in the Yoroi extension
and then later on added to Yoroi Mobile. And so, if you want to build something like
Yoroi, you’re inspired by all the work we do, we have a project that we announced last month
called Tangata Manu, which is a project that essentially allows you to easily run
the backend for something like a light wallet, like an explorer, all using the rust codebase. And so we’ve been working on Tangata Manu
for a while, we’ve now open sourced it so anybody can use
it and use it to build their own projects. And last month we also added elastic search
support to it so that should make it very easy to use in a wide variety of applications. Now let’s see, we’re not the only ones working
on explorers. The Haskell team is working on their own Explorer,
and the reason this is important is because Cardano Explorer, which is the
Explorer by IOHK right now is made for the Byron release of Cardano. Okay, and remember we’re going to the Shelley
release, so you need to do an upgrade of the Explorer. And so that’s what these projects are for
and also you can see it kind of what this Explorer will look like. So this is the UI and you’ll be able to see
stakepool information. So this is all like a fake information to
show you what it will look like. You’ll be able to see stakepools, stakepool
lists, the information about stakepools, how well
they’re doing, and obviously you’ll have a search box and you’ll see information about the network
and how well it’s doing. It was really cool to see a very pretty UI coming from the Haskell team
for their release of Shelley. And so this is what I just showed you is the
front-end for it. Obviously there’s a back-end also that it
they’ve been working on which is this Cardano Explorer github repository They’re doing a lot of work on it mostly making
it faster, adding new endpoints, new ways to expose information
about the network. If you want to check it out definitely look
into these two projects and follow along and see what features they add. And if you have any features that you would
like to have, definitely comment on their github projects. So speaking of the Haskell team, something
the Haskell team wrote a long time ago is Cardano SL. So Cardano SL, it’s the codebase that powers the Byron release of Cardano. The version before Shelley, the one that everybody’s
running. So if you’re running Daedalus, or you’re on
an exchange, or you’re running an Explorer, you’re most
likely running Cardano SL. And so they release the new version of Cardano’s
SL 3.1. And so if you’re using Cardano SL as an exchange or other kind of application, definitely check
out this release and see if anything in here is relevant to
you. Now obviously Yoroi is doing a lot of exciting
stuff We’re not the only ones doing exciting stuff
in the wallet space. Daedalus team is also releasing a new version
of Daedalus called 0.15. It’s got some cool features in it, the one I think this coolest is this News
Feed feature and so basically it allows you to see upcoming
news and past news in the Cardano ecosystem. And the reason this is important is because
for Shelley, we’ll be doing a lot of releases that, where
users really care about knowing what’s happening right. So we need to tell people, hey staking is
available, hey we’re making this change to and so the best way to reach our users is
to embed these notifications inside the application. So that’s what this new newsfeed feature is
for. And so it looks very pretty, it’s very well
done and this will be part of the 0.15 Daedalus update. Some other features they’ve been working on
is a way to verify your mnemonic. So if you’ve created your wallet you know
two years ago and you’re not too sure if you remember your mnemonic, now they have
an opportunity in Daedalus to retype your mnemonic, and It’ll tell you what not is the right one. So it’s kind of a nice UX thing and to be
able to ship Shelley support inside Daedalus, they’ve also been doing a lot of work to integrate
the Rust code base into Daedalus. So what does that mean? It means you’re running
Daedalus essentially on the back end, There’ll be a switch where you can switch
between the Haskell code base and the Rust code base, and they can kind
of pick which one you want to use. And because the incentive test net will be
released on the Rust code base at first, with the Haskell code base coming after, they need to have the ability to support the
Rust code base. And so they’ve been making a lot of switches
on the back end of Daedalus to add the ability to integrate
with the Rust code base. And so all that is coming together now, they’ve
done a lot of the integration work on the API side, and integration on the node side, and you can see this they have a lot of pull
requests for this summarized in this one. So it’s been a lot of work. It’s great to
see it all come together. So if you’re wondering how that switch is
made, it’s done with a project called Cardano wallet on github. And so this is the project that kind of handles
the abstraction between Daedalus and the full node and allows it to kind of switch between the
Rusk and Haskell implementation, also handles the database, all this kind of
information. And so to power Shelley, obviously they’ve
been making a lot of changes over the past month. So they’re still making some optimizations for
Shelley’s new endpoints to get staking information, and optimizing
staking information, all that kind of stuff. They’re also doing work on rollbacks which
is important because on Shelley, it’ll be a decentralized
system so there’s a higher chance that a rollback
happens. That’s a blockchain rollback. And so they’ve been doing a lot of work to
optimize rollbacks to make sure they all work correctly. Okay, something that we didn’t really have
to worry about in the Byron era. And obviously they have to do a lot of testing. So they’ve been doing very extensive property
based testing for all the code they write to make sure that there are no bugs when they introduce
this new Shelley release So a lot of stuff has been happening on Shelley. As I’ve shown you, we’re also doing a lot
on Goguen. So for Goguen, for this node who don’t know, this is the smart contract release of Cardano. So Shelley will not contain smart contract,
they’ll release after Goguen will. And so that includes stuff like Plutus and
Marlowe. So Plutus, Marlowe have also been doing a
lot of work this month, Also a lot of it on documentation. So now they have some new use cases that they
kind of coded out. So now if you’re a smart contract developer you wan’t to see how do I do this kind of
application on Plutus we have more examples. we’ve also been doing a lot of work on Marlowe
tutorials. So obviously we have the Plutus book, we have the Plutus Udemy course, we have a
lot of information about how to write Plutus smart contracts, and now we’re going into Marlowe and we want
to explain to the world how to write Marlowe and how to build, easily show the world how easy it is to write
and also smart contracts. So you can see if you go to the Plutus repository
in Marlowe tutorial docs we have a lot of information about Marlowe
already written. Hopefully this will be packaged up into a
book like format in the future. As we’re doing this, we also released Marlowe
3.0 in time for the Cardano 2 year Anniversary which contains
a lot of improvements. So if you want to see what Marlowe looks like
now, you can see it right here. So this is your Haskell code which is kind
of, if you want to add new features on top of Marlowe it’ll be compiled, it compiles
it down to the Marlowe code which is a domain-specific language. And if you want to see how this code actually
behaves, you can send it to a simulator where you can actually run your
code. See the hub behaves if you send payments to
Escrow in this conformation. And the coolest thing is you can now actually
analyze your smart contract, and they’ll tell you if there is a mistake
in a smart contract. Right, and so this is the advantage of having
a simple DSL, right. It means that as you write Marlowe code, you
can easily run this static analysis tool and It’ll tell you stuff
like, hey your contract will never terminate. We can know this because the DSL is restrictive
enough to it to allow for this kind of static analysis. We also have the familiar blocky, so if you
don’t like to write code, which a lot of people don’t, they want it
easy to use. You don’t have to be a developer to use it. You can use this blocky tool, looks like maybe
it is a bit too zoomed out, where we can easily use like a drag-and-drop
building blocks to build your smart contract without having
to really know much programming. So all these features that used to be kind
of scattered around are now all gathered up into this nice website
similar to Plutus. And so you can easily add transactions to
go through blocks statically and analyze your code, all this kind of information
all from within one web page. And so that’s what Marlowe 3.0 brings to the
table, and there will also be a book on the topic, and tutorials on this topic, and so they’re
still working out the kinks, but it’s really a sight to see and they had
a live demo at the Cardano 2 Year Anniversary to show how you can easily write a smart contract
using the building blocks. So you can easily put pieces together without
really having to know much coding, and still have a good guarantee that there
are no bugs in your code. Obviously they’re still making changes to
the Plutus, the core base itself. So that’s something to the state machine which
allows you to easily halt a script. Obviously terminate the script nothing ever
happens after here’s a kill switch, the added support for type families inside
Plutus’ TX working on formal verification of all these logic inside Plutus. So we want to make sure that the Plutus smart
contract programming language has a a strong fundamental basis to it. And you may remember Plutus napkin, this kind
of project we had a long time ago, we just want to make sure that Plutus is based
off a very well-defined concepts in program language theory. And so we had all the, all of Plutus the theoretical
basis deployed, it’s wrapped up in one napkin. So you can see on the napkin all the rules
to Plutus , and now we’re firmly verifying all the assumptions
we’ve made. And so that’s what this project is. It’s doing this metatheory project, and so
that’s still going on as we’re working to making all the beautiful
experiences of Marlowe and Plutus, we’re also making sure that everything we’re
doing, it’s done right. A lot of some other visualizations and stuff
is happening. It’s gonna come up, some people have talked
about how, the way to visualize the blockchain itself in the Plutus testnet. It’s not super obvious and so we’re working
on some new UI to make it easier to visualize how inputs
go to transactions, go to outputs, this kind of information when you’re testing
out your Plutus smart contracts. So it should make it easier for developers
to easily visualize what’s happening as they’re developing their
Plutus smart contract. So some of the scenes that i want to cover
is the Shelley specification. So the specification team is in charge of
making sure that Shelley from a higher-level mathematical point of
view is all well-defined. So it’s good to have code that really matches
or make sure the math checks up. So that’s what the Shelley specification team
is working on. And so, they made some edits to the specification
with related to knowledgeable calculus, which is how to make sure that we handle stuff like division and square roots and these kind
of operations. If you don’t do it well, it may lead to a
difference between implementations. So, you want to make sure that all that’s
handled. We have some updates to this specification. We’ve had updates to multi-sig. So how we plan to release multi-sig for Shelley. We had some updates to the executable specification
which is kind of a bridge between the code and the specification. Remember in Cardano, you want to take a step
by step approach to basically write a specification. You prove the specification is equivalent
to the executable specification which you prove this equivalent, so on and
so on, until you prove it’s equivalent to the code. And so they’re working on the executable specification, notably they’re making sure the executable
specification meets a set of properties. So they wrote down a bunch of properties that
we know must hold for Shelley in this document. And now they’re making sure that all the code
they’ve written matches all these specific properties. And so, you can see right here, they’ve started
working on including all these specifications inside
these executable specifications. They’ve also been working on a new type of certificate
for Shelley. So if you’re working on an explorer, or any
kind of system that shows the Cardano blockchain, you will need to account for a new kind of
certificate called DCert mir. Okay, so if you don’t know what certificates
are, There’s stuff like how you register a stakepool,
how you delegate to a stakepool, all this kind of information where you post
to the blockchain. And so there’s a new certificate, and the
reason we need a new one is because we need a way to take the rewards
from the incentive testnet and bring it back to the mainnet. So remember for the Cardano incentive testnet,
the ADA you earn will be real. That is the ADA you earn on the incentive
testnet will be brought back to the mainnet as real
ADA. And so in order to do that we need a new certificate. Where we see on the mainnet that here’s a
certificate that proves that a certain amount of ADA was earned on
the test net and be allowed to be brought back. And so if you wanna know more about this, I’ll have a link to this pull request in the
description of my YouTube video. And lastly for the code, I want to go over
the Ouroboros Network code. Ouroboros network is a way to rewrite the
whole network stack for a blockchain from the ground up. It’s partly been going on for a few years
now, and the reason we’re doing this is because
a lot of blockchains failed to scale because of their network implementation,
right. And so we want to make sure instead of reusing
some network implementation for Cardano, we really thought from the ground
up what you need for network stack for a blockchain. And so the Cardano Ourooboros network team
has been working hard. Notably what they did this month is a huge
amount of work on ChainSyncing, right. And so now, with all this work they’re able
to take a client and sync the whole chain using their new networking
stack. And so now that they’ve got a lot of stuff
done with the ChainSync, they’re going back and doing some extra work
on the transition to Ouroboros Praos, or doing some extra work on the mempool which
is some of the lab stuff that we need to get done before this Ouroboros
network implementation is done. Now we’re getting kind of near the end, we
have to have a very strict testing plan to make sure that we don’t have any problem
in this new networking doc And that’s what this consensus testing plan
is. It’s a document that explains exactly how
we’re going to test all the various properties of our new networking stack to make sure that
there are no bugs, there are no mistakes, and everything we’ve
implemented works well. So obviously in Cardano, we take this very
seriously and we make sure that everything we’ve implanted
works out. So we’ve had a lot of work done on mempool
transition to Praos, a lot of ChainSync implementations, and we have a plan in which kind of shows
how far along we are in the Ouroboros annotation. And in the past month, we checked off a lot
of these boxes here in the ChainSync client. So you can see the last things that we kind
of get to or stuff like mempool we’ve done some of the work for it, we’ve
already done some of the work for standalone node, and standalone nodes. And the last part is kind of a testing. Right, so now we have to go through this checklist
and make sure every part of it is well tested and we make
sure it all works So, really exciting to see that this long
projects been going on for a long time. It’s kind of nearing a first version just
in time for Shelley. So some of the stuff I want to mention that’s
going on the Cardano ecosystem that’s not related to code is our education
program in India. So EMURGO has an education program in India, we train students in universities about blockchain,
about decentralized technology, in hopes that they can then join our ecosystem and the blockchain industry and help contribute. So we had one of our engineers called Vicente
go to India and help teach students about blockchain and
about Cardano,about all the work we do. And so you can see some of the pictures here. We also had our Cardano 2-year anniversary
in Bulgaria. So, a really awesome event. We had a few hundred people show up, which
is really surprising because a lot of people we’re so passionate
about Cardano. They went to Bulgaria to spend the time with
us to celebrate the event. When we were there, we had an event with the
Cardano Ambassadors to talk to them about what they think is important
for our ecosystem. So if you don’t know what Cardano Ambassadors
are, they’re a group of people that have contributed
a lot to the Cardano ecosystem, and they’re recognized by the Cardano Foundation as being constant contributors to our ecosystem. So we met with a lot of these people in Bulgaria, so we paid for some of their flight tickets
to come out. We talked to them about what we can do as
IOHK, as Cardano Foundation, as EMURGO, to help improve the Cardano ecosystem. We also planted some trees over there, and the point of planting the trees is kind
of symbolic because these trees will grow for, the next
you know dozens, hundreds of years. And so it’s kind of a living part of the Cardano
ecosystem. Now you know, you can go back there in 50
years and see the trees that we planted to celebrate
the Cardano 2 Year Anniversary. So now I want to mention, oh I forgot, this
is also related to code is the formal Ouroboros. We’re doing a lot of work to firmly verify
the Ouroboros papers, and how we structured the papers. So for example, of communication between nodes that we described in the papers and kind of
stuff. And so we’ve been working on formally verifying
this for a long time now, and it’s kind of step by step approach. It’s very hard we had to invent our own cadlist
to be able to do this So if you’re interested in custom calculi
to solve all these problems, definitely check out the formal Ouroboros
github repository Where we’re continuing to do more work to
formally verify all the content in Ouroboros papers, which is really important because you know, it’s possible that somebody reads the paper
and they don’t spot a mistake. And that’s not acceptible for us. We need to make sure that there are no mistakes, and we can firmly prove that there are no mistakes. And it’s kind of what this Github repository
is all about. So lastly, I wanted to mention research. OK So it’s been a lot of research this month.
Also one is on software updates. Remember, with Cardano we want to be able
to update the blockchan in a decentralized manner. And so we have a paper on this topic, and
now where we can implement on this topic So for example, in this pull request, we’re
implementing a system improvement proposal voting, and this is not the start of the implementation. We’re working on this for a few months now, so if you’re interested in implementation
of decentralized software updates for blockchains, definitely check out this github repository,
check out the paper, and the code to go with it. Runtime Verification which is one of our partners
for the Cardano ecosystem published a paper on IELE, which is a virtual machine that we think is
a lot better than the EBM. It’s much easier to formally verify then EBM, and so they published a paper on IELE on the work that they’ve done in partnership
with IOHK. And so if you’re interested in IELE and how
it may be used for Cardano in the future after we’ve shipped Plutus and
there’s other technology, definitely check out this paper. We also have a paper called Kachina, which
is the foundations of private smart contracts which is important because there’s some smart
contracts on finance applications or you cannot legally have other participants
know that something happened. This is regulations for various countries, and so we need to have a way of handling private computation. And so this paper kind of handles that topic. And we also have another paper, it’s a systemization
of knowledge about Communication Across Distributed Ledger’s. And so there’s been a lot of talk about stuff
like layer 2. A lot of talk about Thomas Schwab’s lightning, all this kind of various systems that communicate
across distributed Ledgers. And so this paper talks about various systems
people have come up with, and tries to categorize them into various
taxonomies to easily reason about the safety properties of each
different implementation. So if you’re interested in the different ways people have been trying to solve communication
between Ledgers, definitely check out this paper and see, come
an overview of the whole ecosystem. And lastly under, unrelated topic, IOHK published
a paper on Proof of Burn. It is also important because Proof of Burn
is one of the ways that people want to communicate between distributed Ledger’s, right. So imagine you want to transfer a Bitcoin
to Cardano, one of the ways you could do it is you burn
the Bitcoin and redeem it on the Cardano blockchain. And so to be able to do that in a safe way,
we need to be able to prove that you really did burn your Bitcoin. And so there is no a previous formal definition
of what it means to burn a coin and how you can prove that a burn really did
happen. And so that’s what this paper is about. So there’s a lot of research still going on
Cardano. Obviously we’re still writing all the code. You can see with Jormungandar, we’re doing
a lot of work to ship it all to production. But as we’re doing this, we continue to do
research to never have Cardano fall behind. Right. We’re always going to be doing the research and be sure we’re one step ahead of the competition. And that’s it for this update.

21 thoughts on “Cardano Progress Update by Sebastien Guillemot (Oct 2019)”

  1. Thanks, you forgot to put the link to the incentives readme on GitHub?

    Edit: found it.. so hard to find… https://github.com/input-output-hk/chain-libs/blob/master/chain-impl-mockchain/doc/incentives.md

  2. All of you are dumbasses are hopeless to actually KNOW HOW TO FIND A REAL investment, nothing brought you to this coin but geek hype AND LOW COST…pray and hope for this coin.lolllll…shitcoin is always a shitcoin..

  3. All coming together 🙂 I just can't wait to watch the updates in 1-5 years time and look back and reflect on how much progress has been made. Truly revolutionary.

  4. So many updates to go over it's crazy. Inspiring to see all the work going on in the backend, no hype, no bullshit, just constant slow grind with the aim of launching a superb decentralized smart contract platform that scales 🙂

    Much props to all the teams involved!

  5. Keep up the great work Sebastien & the Emurgo/ ADA team! 🙂 Does anyone know more about the testnet incentive staking scheme? Is it % based and will it only be funds you currently have on Yoroi ? (could you add more post snapshot?)

Leave a Reply

Your email address will not be published. Required fields are marked *