Fuel: Scaling Ethereum with the Fastest Modular Execution Layer

foreign [Music] I also can't see the slide so I'm gonna like also attack us on the trailer okay so I'm going to talk a bit about how we got to where we are today with you all uh by going through at least timeline of events uh in June 2019 I introduced the optimistic raw design Paradigm under the title of minimal viable emerging census and this kind of kicked off the whole idea that you can have some sort of scalable execution system anchored into ethereum for security uh moving on uh to December 2020. this was you know right at the end of the year but still in 2020 we did a Mainland launch of fuel V1 as the first optimistic rollout on Main and ethereum and through the style is actually the still the only system that could be considered a true roller that is trustless and permissionless uh since then uh up until January 2022 we were essentially heads down building out uh fuel V2 which was an evolution of the protocol from a payments only platform to a general purpose smart contract execution platform so we published our code and GitHub since then the code has been developed it has been open source and entirely developed planned and Etc all in public not a lot of projects I should do this entirely in public we ask you to all our development in public uh uh then um June of 2022 we launched a sway swamp demo sway swap is a part of Junior soft V1 to sway which is the high-level language that I imagine most of you are here excited about uh and a lot of the private tests now and then in September of 2022 so just a short month ago we we released the beta one public testing of the fuel protocol this is actually completely permissionless anyone can use that to buy smart contract run transaction and you can use it today and now we're here uh.com October 2022 and what do we have and where are we going to go let's talk about the three pillars of fuel and what makes the protocol so great to use and to build with Etc so we have three fundamental pillars one of them is performance uh performance through parallel transaction execution the second one is flexibility and waste reduction through the fuel virtual machine and the last is a superior intact unmatched development experience through Sway and fork and I'm going to be expanding unusual these colors in the coming slides so let's start with the first one performance through parallel transaction attribution this one is actually going to be the shortest of the three floors of Calvert because it's actually fairly straightforward to explain which is that you can see from the start here uh the well the number of transistors on CPUs has been increasing exponentially over the years you know this is Moore's law these single threaded performance in the last you know 10 plus years hasn't increased exponentially it's kind of stalled it's basically leveled off what has increased exponentially however over the years has been the number of cores right so if you have a system that is sequential that can only leverage a single core it's like you're running it on a 10 year old computer right it's not it's not exactly a very good place to be when you're trying to build a Global Financial access Etc system right you really want to leverage the same that is increasing exponentially year over year and that is this parallel execution multi-core uh multiple cores multiple threads running in parallel uh the fuel virtual machine is designed and the fuel protocol is designed to be able to run transactions in parallel as opposed to evm which unfortunately can only run transactions sequentially this will lead to a vast increase in throughput all of us being equal not because you need a more powerful computer but just because you're using all the resources of your computer that in in the VMware just kind of sitting there wasted so that's the again that's really all there is to it parallel transaction execution massive increase in Drupal now on to waste production uh an increased performance on the single threaded model oh I guess I didn't collect this and on laser function and improved reference within a single thread through the fuel virtual machine so there's also some QR codes uh here that you guys can scan if you so wish that link to some of our documentation around these things just in the slides will all be posted later on so if we don't if we don't want to scan them right now they'll obviously be available uh the fuel VM is fundamentally the evm but improved one amazing thing you can do in rollups is experiment with improvements enhancements Etc and there have been many many erps and just ideas that that didn't even make it to erps that have been proposed over the years for ethereum but that could never be implemented because of a need for backwards compatibility also limited developer resources you know just worries of too too much change too fast might be risky if you have a large code based on Randy with a lot of tech debts all right but people still want these changes they've been proposed uh you know if you take a roll up and you know you might say oh okay I'm an evm equivalent roll up I want to improve it I'm going to start implementing eips to improve it right I'm going to add a counter traction number we're going to add parallel transaction execution Etc that's fuel right the fuel of M is the evm but improved so if you're looking for the evm of five years from now that is the fuel VM next one uh stateless account attention some other projects give like an entire talks about this one topic but this is just one of the many things you get in fuel so it just gets one side uh fuel supports account of traction but statelessly uh State full account attraction is actually a denial service Vector so be wary if any project that says it has state state full account abstraction we have State lost account abstraction what does it allow you to do well like any account abstraction protocol it allows you to Define conditions under which a transaction is valid not conditions you know not logic of what the transaction will do but actually conditions under which the transaction is valid or not uh you know the most obvious case one thing you could do is use a different signature scheme I uh you know use snore signatures if you want to and this is actually what enables us to use any wallet whatsoever for fuel right obviously you know we're building a native wallet that has all the bells and whistles uh you know things like transaction simulation you know and uh a mode where you can like log into pretend to be in any public key or any address Etc but you know maybe if someone doesn't want to install a new attention because they use Solana right and they have assign a lot or they use ethereum they have metamask right you can use any of these things enzyme transaction on fuel because of a kind of traction that allows you to define the validity conditions that are basically well whatever signed message whatever log you want will do it checks out for validity and users are the ones that Define the spending conditions the validity conditions of this not the protocol not those anyone in the world can go in and just Define some new condition and you know it'll work with a new blockchain just like that no protocol change is required required no governance required just as a user you just write it and you're done uh we all know that transferring tokens are a really painful thing right there's like super extremely actually for real this time safe transfer from right uh needed because there's so many there's so many vulnerabilities and something as simple as just transferring a token properly uh fuel supports multiple multiple assets multiple assets natively so every token is a native asset uh so you have like a die as a native asset you could have used to see as a native asset you could have well either obviously is a native asset uh and this these native assets can be pushed with contract calls which means you don't need the notion of token approvals you can push them their first class citizens just like how in ethereum you can push ether with a contract call Noah token approvals so not only are you getting better security from not needing you know some sort of safe it's not transfer from function transfer from function we also don't need token approvals and this is actually a really big thing for users not developers because as users you know that token approvals are a really big ux pain point right it's due to approve the exact amount you want to spend if you do then you have to always add a second transaction every time before you interact with the protocol it's more expensive it's slower it's worse ux if you do internet approvals now the protocol has a bug they can train all your tokens all the time I mean whatever whatever you infinite approved right with us normally for NATO approvals I have no need for token approvals because you just push the native asset that way next is NATO state math because then you show them on the right track uh there's no need for a safe math Library there's no need for some runtime overhead or like add extra byte code to check for Save math the virtual machine itself support safe math natively by default which means you get overflow protection for free uh cross call shared memory uh again this isn't like all these things are either eips directly or like variations or inspired by EVS if you guys have heard of transient storage right transient storage is storage that persists across contract calls within a single transaction that's what this is right it's some piece of memory that is accessible across contract calls uh the fuel virtual machine all contract call frames share this Dynamic which allows you to do things like a completely in-memory re-entrancy card you don't have to set a storage slot for re-entracy card you can do an entirely in memory and in fact this is already implemented in the sway standard Library it was a function to do an in-memory reaction zero so it's not just theoretical it also allows you to pass large data around with contract calls so if you happen to do some data data computation intensive tasks you can do it just by passing a pointer to the data the next one is transaction scripts uh one of the pain points of a proven transfer from in addition to you know which the proves being painful is they have to be done in two transactions you need a transaction first to approve make a complete and then transfer fund and it has to be done in two transactions because an ethereum transaction can only call a contract it can't call two contracts or call two contracts then do some conditions and call a third contract or fourth one depending on the same condition the fuel protocol has transaction scripts which are basically byte code embedded directly in the transaction and that is the entry point for execution not the contract call and the script is by code it can do anything it could call one contract it we call two contract contracts they could do an atomic approve and transfer from obviously for fundable assets like I said before those you know multiple native assets so you don't actually ironically you don't need this for a proven transfer from atomically for Native assets but it will be useful for things like if you have a non-fungible token that does have a proven transfer from then you can use you can do that atomically in a single transaction thanks to transaction Scripts this also allows you to do things like you know add liquidity to a pool or for two different tokens Etc so basically anything that nowadays you would need multiple transactions to do just due to the nature of ethereum only processing a single contract call for transaction you could do it in a single transaction until uh we're getting to the end of the section and last but not least to reduce waste the virtual machine is register based and it uses 64-bit words uh the 64-bit words uh instead of 256 bit words like what the evm has means a lot less waste a loss a lot closer to the metal when it executes because you don't need if you integer math every time you do an addition you can just add two numbers together and this goes really fast uh and combining these things together including being register based means that you're executing a lot fewer instructions to do the same work in addition to just executing faster and that reducing the number of instructions executed to do the same work is very important because gas accounting overhead is a huge portion of the overhead of the virtual machine it's like enormous uh and you want to reduce that overhead as much as possible to squeeze as much throughput as you can on the same physical Hardware so by being registered based you greatly reduce that doesn't really affect like the end user at all because you know you as a user you know there's medium stack based but you don't care those Statics if you're a user or a developer it just is it just works right okay on just Man four and an unmatched developer experience uh standard Library so the language is very minimal a lot of things are moved to the standard Library one example that we'll reuse and subsequent slides is the EC recover right this thing here will recover the public key or the address does an implementation detail from a signature and a message hash right in solidity this is part of the language itself in other words the compiler developers need to go in and add some special magic method into the compiler embed it into the compiler easy recovery right that does not exist in swine this way you compiler and the sway compiler team don't know what EC recovery is this exists in the standard Library which is written the standard library is better in Suite although it's software not embedded into the compiler um here's a QR code I think to link to the implementation of easier government why is this good it's good because it means that the standard Library can move very fast because you don't have to get the compiler developers to do something this is in this way any if any of you can write solidity right you and you can write sway you can just add stuff to this movement submit a PR and just add stuff to the standard Library you don't need to know how a compiler works right you just might swag which is writing the smart contract code uh so it allows the language to move quickly because it's lean and it allows the standard library to move quickly because it doesn't you don't need to know how compiler Works uh to contribute to the standard Library and this basically almost every function that isn't actually like core to the language itself is in the standard library and not in the language itself next uh generics in some types uh generics is the diagonal brackets right so you can Define the type of assign later uh some types are you know either one or the other uh rather kind of like unions uh combine them together and you can get things like a result for instance which we'll talk about on the next slide but generics are very good because they they allow you to reuse code to reuse logic without having to duplicate code right there's a safe math library right versatility but if you want to use safe math for like a un 64 instead of a un256 you just have to like copy all that code and change the type right if you have generics you don't have to do that because you can just make logic generic over any type that supports some functions like say an addition and then you know instantiate instantiated with different types so it allows much easier code reuse without having to well it allows it allows code reviews period uh for things that are the same logic but in different types uh now why do we care about results specifically and why is this important we're going to go back to our example of easy recover on ethereum and solidity the easier recover function will return something special if there's an error can someone yell out what that something special is okay someone someone says zero perfect right so if the signature is invalid then easy recover will return a magic value of zero you know those address zero has you know signed over this message hash with a signature obviously that's not true because you know if you're new with it if you knew the private keys of the address zero the things would be very bad but the easy recover doesn't tell you anything explicitly right there's this magic value and if you don't remember to check this then someone can pretend they're from address zero right and maybe like do a bunch of nasty stuff and in fact just a few months ago a contract forgot to do this and I think about exploited or maybe it wasn't exploited at least it was still there as a bug in code uh with results uh you can actually wrap the return of things so easy to recover in sway which again the standard Library function does not return a value it returns a result over a value and an error right so if the if the signature is invalid is not going to return zero it's going to return an error and if you want to actually get into the value you have to unwrap the result and you have to do this in other words you have to handle that error and the compiler will force you to handle that error explicitly uh you know in solidity that's not the case you have to actually go manually remember to check the zero value and you know there's all the places where this happened so having generic in some types allows us to have results along with all the things and this allows for explicit error handling which means safer code because the compiler tells you you don't have to go and remember yourself okay next one type in front we probably all hate writing types of things especially when those types are long especially relevant when you have generics uh there's a left keyword now an alternative would have been a VAR I guess but you know there's been some bike shedding I think on Twitter I saw a fairly recently on the slack keyword so this one has a left keyword and this allows you to have type in fronts right we use the same type system as rust so you can just you know whatever's on the right it can be inferred uh you have to actually write out very few types and if you look at our standard Library I think sniper inference is used quite a bit throughout it so that would be a good example of how how you don't have to write that many types everywhere and onto okay next one is namespace storage access in solidity uh storage variables and regular variables are all in the same namespace and if you have a storage variable Foo and the local variable Foo and you go like you know Foo dot whatever you know which one are you accessing right likewise what happens if you have two variables that are close in name right you have like you know count and CMT let's say right you can use the wrong one by accident right you intended to increment something in storage but you incremented it only locally or vice versa and sway storage accesses are namespaced with a storage dot keyword which means if you want to access a storage variable you specifically have to write out storage dot this means you can just look at the code typos are not and you can see what parts of the code are actually touching storage versus not right so additional explosiveness and it means additional safety next one is exhaustive pattern matching this one was implemented quite quickly by one information compiler Engineers Emily uh for those of you who aren't familiar with pattern matching it's a match statement right and it allows you to exhaustively enumerate all the possible cases so let's say you're matching in a Boolean the exhaustive cases are true and false right and if you only matched on true the compiler would tell you hey you haven't matched exhaustively uh this means that unlike in solidity where you have to do an if else chain and hey if you forget to check a case and you're in the in your state machine right uh for your contract if you forget to check your case well too bad so sad the compiler tells you nothing right uh with exhaustive magic Expressions well not only is it cleaner because it's all like in a single thing instead of a chain and it's also exhaustive and the compiler will tell you if you missed a case next one is zero cost obstructions uh this is kind of a first class notion in this way language and this way combin binder uh that this little pilot doesn't really do one example of a zero cost attraction there's zero cost things in general it means moving stuff from runtime to compile time wherever possible that's what the ethos is really about one example is well what happens if you could check method payability at compile time instead of at runtime right it's a solidity compiler will actually inject some runtime code into every method that is non-payable right this is a runtime cost it's bad and that's why optimizers will actually just add payable to every public method uh to avoid that runtime cost and just say Okay read the read the documentation right read the docs in the function and then don't send either to this to this method right but you can always do it at a compile time which is what uh display will do right this way from highlight is that you actually check at compile time but someone trying to send some non-zero value of any asset not just ether uh to some non-payable method okay uh and another that's not least I think I'll Zoom through since I have one minute left is reagency reentions exploits are still happening to this day six plus years later after the dial tooling should pick this up but it doesn't that's why compiler will warn you if your contract has some potential reaction to Golden vulnerability because it violates the check effects interaction pattern or other patterns this way to Milo will actually warn you so goodbye other days of re-entracy vulnerabilities because we now have two of them that can warn us about that all right and last but not least on the language side but on the tooling side we have Fork the fuel orchestrator which is the equivalent of Foundry or cargo npm this allows you to do a variety of things including building deploying managing dependencies [Music] thank you so much okay it allows you to build apply manage dependencies in the same way cargo does so no weird git modules this is an Australian formatter test a language server we actually had a language server before uh so if you want to there's a QR code to link to the sway book if you want to learn how to write Sway and dive in a head first this will take you straight there I'm gonna leave that for a few more seconds and then with a few seconds left I would like to close out the slide by thanking not only you guys but each and every one after using 65 contributors in the fuel Labs team that has raw fueled where it is today thank you [Applause]