ThunderCore: Breakthrough Scaling for Ethereum Dapps

MICHAEL: Today as part
of the Nutshell Series I want to take a look at ThunderCore. So ThunderCore is one of those
breakthroughs in scaling technologies that brings up high
transactions per second. Now we’ve all heard about a lot of scaling
breakthroughs and technologies before, but what sets ThunderCore apart is that it scales not only transactions
but it also scales smart contracts. It allows for under
one-second confirmations. So I guess that that’s part of the main
pull in what drew me to this project. I also spent quite a
long time the past week reading about it and spent
the past few days programming and just testing on that, and I will show you exactly what can be
done on the main ThunderCore Mainnet. And if you guys are new
to the Nutshell Series, the Nutshell Series is where
I give an executive summary of what a piece of technology is. And I have a video playlist for
all the Nutshell summaries up here. Now in today’s video what
we’re gonna look at is why. We’re gonna just look at the theoretical
reasons behind why scaling is so hard, and we’re looking to look at
how ThunderCore solves this. What was their novel
breakthrough technique? And we’re gonna look even deeper, just actually going down
and testing and using it, because I think that’s
probably the most important part. We’ve heard so many things about
all these scaling breakthroughs, but we can’t use them. And the best part about ThunderCore is that it’s live right now and we
can use it in its Mainnet state. And making this video was really fun. And I got to go back to programming and learning a lot about how
this programming structure works. And also I learned a lot about the
fundamentals of blockchain, too. Just reading all of these
academically published papers was much better than reading a lot
of these flimsy marketing schemes. Let’s start off with some basics. Why are blockchains so slow? You’ve probably heard of
the Blockchain Trilemma where Vitalik famously said, “Blockchain systems
can only have at most “two of the following three properties “which are scalability,
decentralization, and security.” So it can only have two, not the third. So let’s cut to the chase. If there is a problem called
the Blockchain Trilemma, then how the hell does
ThunderCore solve this? Well, it does it via two paths, actually. So when you send a transaction, normally it will go through something
called the Optimistic Fast Path, but there’s always a backup. A backup called the Slow Path which
serves as the backbone of this blockchain. And you’ve got to kind of
view it as a super fast highway. It handles a lot of
transactions per second. And it’s super fast. Zoom. Zoom. Zoom. Transactions go left, right, and center. But if something happens to that highway, the Fast Path, you can always resort to the slower
kind of grid of neighborhood roads. It’s more proven, it’s more reliable, and it’s more secure,
but not really fast. And what’s cool is that
ThunderCore chose to use Ethereum as the fallback slow chain. So if anything does
happen on its freeway, on its super express path, it falls back to Ethereum,
and then it resolves issues, and it has the same security
and decentralization as Ethereum. If you look at the fast path in
detail, there are two components. One component is called the Accelerator. The Accelerator is the one responsible
for proposing and ordering transactions. And then there’s a Committee of
consensus nodes that approves them. And if you think about an analogy,
it’s kind of like a sports team leader. The team leader will say,
“Hey, go to that direction.” And then the team players will be
like, “Yes,” or “no.” And so long as two-thirds
of the players say “aye”, then boom that
direction’s set and locked in and it’s only done in
one round of voting. And that’s exactly what makes
ThunderCore transactions so fast and allows for high throughput. It’s because you can propose
very quickly and resolve that, accept it or deny it,
in a single round of voting. There is no back and forth
that can slow down the process. So the interesting thing,
and the first question that will probably spring to
mind is, is this centralized? How much centralization is there? Because there’s one Accelerator
and there’s a Committee, but how much power
does that Accelerator have, and how much centralization is there? And I think that’s the
trickery of all this. The trickery here is that there are
ways to refer back to the slow chain, the Ethereum Blockchain, to make and check up on what’s
happening on the Accelerator, and prove if the Accelerator is
functioning or non-functioning. One of the interesting bits
of research that they did is that they mathematically proved that, so long as there is one
honest node on the network they can find a point where they can
disprove a majority of dishonest nodes. And this is why you can
trust the Optimistic Fast Path. It’s because it’s very resilient to anyone
trying to overrule with the network, and the moment some
dishonest behavior is detected, there are mathematical proofs that can exit out of the Fast Path
and kind of reelect a new system. So now onto the fun stuff. So I’ve been talking
about the theory a lot, but actually, because
the Mainnet is deployed, I actually got to manage
to play around with it and test how a smart
contract could be deployed. So the kind of
interesting thing here is that because ThunderCore is compatible with
EVM it’s essentially just like Ethereum, and it can use a lot
of the Ethereum tools that you’re familiar with on ThunderCore. So if you like Metamask on your browser, you can actually connect up your
Metamask to the ThunderCore Mainnet. And the instructions are pretty simple. You basically copy down
this RPC URL over here, and I’ll just send you a link down below, but you basically paste it
into the custom RPC session. Alright, so you paste that here,
ChainID 108, the symbol is TT. Save that. So once that’s saved you can
actually see that on my account we actually do have a little bit of TT. This is the free TT that you get
to use to test out smart contracts, and it’s all on the Mainnet,
and you can try it out for yourself as well. TT I would like to say, the Thunder
Token, it’s not like an Ethereum token. It’s not living on Ethereum. Thunder Token is on its own Mainnet, and it’s pretty much used
exactly the same way as Ethereum, which is to use to pay for gas for Thunder
Token smart contracts and transactions. Now in terms of what I did, I pretty much used an ERC-20 contract, so these are Ethereum-based
programs and contracts, but I can exactly use them one for one
on Thunder Token, which is kind of cool. So I played around with that. I won’t go through the whole
thing in this Nutshell video, but I will make a few short videos
about how to deploy your own– a tutorial about how
to make your own token. What I will show you is the smart
contract deployment process. So I’m using Remix,
which is a tool used for Ethererum. You can use it directly on ThunderCore. And we will just deploy
the smart token here. Make my own contract. Make my own ERC-20
that lives on ThunderCore. Decimal two places and transact. So this like launching
your own token, guys. This is like– it blows
my mind how easy it was. All the programming stuff, it looks hard, but it took like two or
three hours to figure out. It was pretty much nothing. So you have a gas fee here
for the ThunderCore Mainnet. It takes a little bit of TT. I’m going to confirm. And then… boom. Contract deployed. And that’s how fast it takes. And this is exactly how fast it
would take for a transaction as well. So if you wanna do any sort of
interaction on this ThunderCore, it pretty much just takes under a second. And even if I want to
interact with my contract like print some tokens and give it to
myself just pretty much 888 tokens. Transact. And it’s, it’s done [laughter]. Pretty darn fast. So there were some questions, of course. The first one I asked myself was, “Is this basically like a
faster version of Ethereum?” The team actually
wrote about this as well saying that it’s not just a fast
version low-cost version of Ethereum, but they’re adding a
few other features too. One of the features being a
dApp developer funded gas cost. So right now say if you’re
interacting with a dApp on Ethereum, you gotta hold some Ethereum
yourself to pay for the gas costs. And say, for example,
you’re playing CryptoKitties, and you wanna breed a kitty, you gotta hold some Ethereum. You gotta pay those fees. But here what they’re
trying to build is– on a roadmap they’re building a feature where the dApp developer like
CryptoKitties the company pays for it. So, in fact, the user can use
it as any normal application without having a bunch of fuel
Ethereum nearby to fuel that transaction. So in terms of the current development, I did say that the Mainnet is launched, but there is one caveat to this Mainnet which is that is a
pre-release prelaunch Mainnet, which means that it’s
not fully feature-complete. And one of the main factors that’s
missing is a public staking system. So I said that there’s a
Committee of consensus nodes and these need to be staked. Well, this is not fully built yet. So that’s what’s not available right now. So that staking element is not there, but what is possible is that all these
transactions that’s already happening, and all the contracts that are being
deployed are on the prerelease Mainnet, this will be live, so anything
done now is, well, it’s real. It’s solid. And one of the reasons why they’re
doing this prerelease Mainnet and making sure that this is
the same as the actual Mainnet is that they can port developers and get
these developers coming over right now as opposed to later when every full
feature– all the full features are deployed. So right now they
actually tested this and said, “Hey you know what?” They tested the smart contracts for
Auger, Bancor, Cryptokitties, 0x Project. They brought that over to
the Mainnet for ThunderCore, and it works, so
that’s kind of interesting. They’re really trying to
target Ethereum developers to migrate over to ThunderCore. And that guys is my Nutshell
summary of ThunderCore. Now if you guys wanted to learn a
little bit more about ThunderCore, the best paper, and the best resource
is the Thunderella Protocol Whitepaper. I’ll put a link down on the bottom. And that describes in a lot of detail and has equations for
how this Fast Path works and how to exit it if
something goes wrong. I’m also building a lot more
videos for the Nutshell Series. It’s been really fun for me recently. So if you have any recommendations
for what projects to look at, or what kind of tokens to cover, leave a comment in the
comments section below, and I’ll try to look at them
and do a series for it as well. Thank you guys so much
for watching this episode. What do you guys think about Thunder
Token, and have you guys tried it out? Leave a comment about what you think
in the comments section below as well. Thank you guys so much
for watching this video. See you guys next time.

Leave a Reply

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