Rust x Ethereum Day 2023 at The Foundry SF

Raul Jordan presents on "Arbitrum Stylus: Rust smart contracts on L2"

My name is Raul Jordan and I am 1 of the crazy people that's staking on mainnet with wrath And I'm here also a maintainer of the prism consensus client for aetherium and also working now on L2 technology So really excited to talk to you guys about Arbitrum's stylus and what we're cooking up.

All right, so L2s on Ethereum are really awesome.

They enable things that just weren't possible before.

We can do so much more if basically we can get a lot of the guarantees of Ethereum in the fact

that you can bridge over and you can also bridge back with fraud proofs and

that gives us so much opportunity to explore just crazy things that on otherwise would take years to do on Ethereum L1 for a good reason.

Ethereum is this decentralized kind of very secure base layer and it's a very strong data availability layer.

If we want to keep, you know, if we want to really move and change some of its key features, that obviously takes a lot of time and there's a lot of inertia behind it.

a lot faster and oftentimes in ways we couldn't expect before.

So I'm working on currently the Arbitrum L2.

And at a high level, how it works is that we run goEthereum state transition function.

So this is the same thing that happens when you process an Ethereum block, when you process an Ethereum transaction.

And what we do is that we compile all that code into this format called WebAssembly, which some of you are familiar with, which then gets proven back on Ethereum with a delay of approximately 7 days.

So during this time, people can make claims about arbitrum state, and they can also dispute those claims.

And always, Ethereum will be the final arbiter of truth.

So we'll figure out if somebody is lying or

if a dispute was just completely incorrect.

And the idea is that it's this compact binary format That's originally designed for the web.

And the idea is that with this, we can run other languages than JavaScript in the browser.

So we can do things like, for example, run C code, run Rust code in the browser.

And it's supported heavily by web standards committees.

It's become an amazing tool that is already in production at many companies.

And many folks already have had exposure to it.

Coincidentally, it's also really great for L2s and for doing this kind

So originally, JavaScript was really all we had for developing web technologies.

And today, the ecosystem is a lot more mature.

So browsers now support, you know, very robust experiences with WebAssembly, and especially Rust has really awesome support, first class support with some of the tooling that exists out there today.

So something we asked ourselves is, hey, L2s, what they're actually doing is proving computation on Ethereum, right?

We don't really say what kind of computation, But most of

the time it's EVM computation, Ethereum computation, right?

It doesn't need to be that way necessarily.

So actually the computation that we do is

we do fraud proofs over any kind of arbitrary user Wasm?

So the question is, why not other binary formats such as MIPS or RISC-V?

And really it comes to the tooling and the community support.

Wasm has become so supported by standards committees that

the tooling is getting better and better each year.

And even the creator of Docker anticipated that Wasm on the server was going to be the future.

He said that if Wasm existed back when he was creating Docker, they wouldn't have even need to create Docker in the first place.

Arbitrum Stylus is a next-gen environment for developing smart contracts on Arbitrum.

You can write your smart contracts in Rust, C, C++, and really any language that compiles to WebAssembly and doesn't have a runtime.

It's not a new L2, and we like to call it EVM+.

We actually have 2 VMs running side by side, which is the EVM and also the Wasimer VM.

And they can fully interact with each other, and they still go through 1 exact state transition function in 1 database.

There's nothing like this that exists today.

Some of the breakthroughs that are possible with stylus is that a lot of execution becomes incredibly more performant, and that also means resource efficient and cheap.

So for example, Benchmarking Ketchak shows a 73x performance improvement.

When it comes to certain things such as memory, we can see gains as much as 500x on certain memory types for applications that use medium amounts of RAM.

It translates directly to transaction costs for users and things that just weren't possible before within the bounds of the EVM.

So when you have access to Stylus, we get things such as amazing cryptography that can be implemented on Arbitrum,

gaming AI, generative art, and even precompile research.

So instead of waiting years to adopt a precompile, it can be implemented

Most importantly, and what I'm most excited about, is that you get to write pure Rust.

There's no crazy domain-specific language, no wild, crazy chimera of languages that seems like Rust but isn't Rust.

a very low-level syscall-like API to get access to host functions.

This means that you can implement really nice frameworks on top that provide nice types, use Alloy, use all kinds of things.

The community can choose any way they want to go with this.

Even the most minimal entry point, you have a function that just takes in some bytes and outputs some bytes.

You can go wild, do anything you want here.

And you're not bound by the traditional gas limits or execution costs that EVM contracts would normally have.

Can we add support for other languages in Rust?

If folks here are curious about Zig, it took me about 16 lines of code to add full support for Zig for Stylus.

you have any other favorite programming language that

you want to write smart contracts in, you can go ahead.

When Stylus, we have fully working fraud-proving for Stylus programs, full EVM compatibility and interop, and also ABI equivalence, which is really important.

Rust is supported out of the gate, and a lot more is coming.

interact with a stylus program, it looks just like a Solidity smart program, a smart contract.

You don't even need to know that it's in Rust.

Underneath the hood, it could be written in Rust.

And basically, the world is your oyster if you use Stylus.

If you're an L2 developer, If you're interested in smart contracts, if you like writing Rust, please find me after this talk.

out to the team lead and the master mind behind Stylus, which is Rachel Bosfield from our team.


Speaker 0: All right. Hello everyone. My name is Raul Jordan and I am 1 of the crazy people that's staking on mainnet with wrath And I'm here also a maintainer of the prism consensus client for aetherium and also working now on L2 technology So really excited to talk to you guys about Arbitrum's stylus and what we're cooking up.

Speaker 1: All right, so L2s on Ethereum are really awesome. They enable things that just weren't possible before.

Speaker 0: We can do so much more if basically we can get a lot of the guarantees of Ethereum in the fact

Speaker 1: that you can bridge over and you can also bridge back with fraud proofs and

Speaker 0: that gives us so much opportunity to explore just crazy things that on otherwise would take years to do on Ethereum L1 for a good reason. Ethereum is this decentralized kind of very secure base layer and it's a very strong data availability layer. If we want to keep, you know, if we want to really move and change some of its key features, that obviously takes a lot of time and there's a lot of inertia behind it. So in L2, we can innovate and do things

Speaker 1: a lot faster and oftentimes in ways we couldn't expect before.

Speaker 0: So I'm working on currently the Arbitrum L2. And at a high level, how it works is that we run goEthereum state transition function.

Speaker 1: So this is the same thing that happens when you process an Ethereum block, when you process an Ethereum transaction. It goes through Geth.

Speaker 0: And what we do is that we compile all that code into this format called WebAssembly, which some of you are familiar with, which then gets proven back on Ethereum with a delay of approximately 7 days.

Speaker 1: So during this time, people can make claims about arbitrum state, and they can also dispute those claims. And always, Ethereum will be the final arbiter of truth. So we'll figure out if somebody is lying or

Speaker 0: if a dispute was just completely incorrect.

Speaker 1: So why WebAssembly? What is this thing? Why are people talking about it? People also call it WASM for short. And the idea is that it's this compact binary format That's originally designed for the web.

And the idea is that with this, we can run other languages than JavaScript in the browser. So we can do things like, for example, run C code, run Rust code in the browser. And it's supported heavily by web standards committees. It's become an amazing tool that is already in production at many companies. And many folks already have had exposure to it.

Coincidentally, it's also really great for L2s and for doing this kind

Speaker 0: of fraud-proof verification game that we

Speaker 1: just spoke about. So originally, JavaScript was really all we had for developing web technologies. And today, the ecosystem is a lot more mature. So browsers now support, you know, very robust experiences with WebAssembly, and especially Rust has really awesome support, first class support with some of the tooling that exists out there today. So something we asked ourselves is, hey, L2s, what they're actually doing is proving computation on Ethereum, right?

We don't really say what kind of computation, But most of

Speaker 0: the time it's EVM computation, Ethereum computation, right? It doesn't need to be that way necessarily. And could we do more, right? So actually the computation that we do is

Speaker 1: in WASM, and a lot

Speaker 0: of this comes from GoEthereum. But a question arises, Can

Speaker 1: we do fraud proofs over any kind of arbitrary user Wasm? And the answer is yes. So the question is, why not other binary formats such as MIPS or RISC-V? And really it comes to the tooling and the community support. Wasm has become so supported by standards committees that

Speaker 0: the tooling is getting better and better each year.

Speaker 1: And even the creator of Docker anticipated that Wasm on the server was going to be the future. He said that if Wasm existed back when he was creating Docker, they wouldn't have even need to create Docker in the first place. So that's how big of a deal this is. So presenting Arbitrum Stylus. Arbitrum Stylus is a next-gen environment for developing smart contracts on Arbitrum.

You can write your smart contracts in Rust, C, C++, and really any language that compiles to WebAssembly and doesn't have a runtime.

Speaker 0: So are we choosing between EVM or WASM? No, this is actually fully composable. It's 1 chain, multiple VMs. It's not a new L2, and we like to call it EVM+.

Speaker 1: We actually have 2 VMs running side by side, which is the EVM and also the Wasimer VM. And they can fully interact with each other, and they still go through 1 exact state transition function in 1 database. There's nothing like this that exists today. Some of the breakthroughs that are possible with stylus is that a lot of execution becomes incredibly more performant, and that also means resource efficient and cheap. So for example, Benchmarking Ketchak shows a 73x performance improvement.

When it comes to certain things such as memory, we can see gains as much as 500x on certain memory types for applications that use medium amounts of RAM. And the numbers are just staggering. What does that translate to? It translates directly to transaction costs for users and things that just weren't possible before within the bounds of the EVM. So when you have access to Stylus, we get things such as amazing cryptography that can be implemented on Arbitrum,

Speaker 0: gaming AI, generative art, and even precompile research. So instead of waiting years to adopt a precompile, it can be implemented

Speaker 1: as a Rust program directly. Most importantly, and what I'm most excited about, is that you get to write pure Rust. There's no crazy domain-specific language, no wild, crazy chimera of languages that seems like Rust but isn't Rust. No. You get to write pure Rust.

And you can use

Speaker 0: the tools you're comfortable with. To interact with the EVM, we provide

Speaker 1: a very low-level syscall-like API to get access to host functions. This means that you can implement really nice frameworks on top that provide nice types, use Alloy, use all kinds of things. The community can choose any way they want to go with this. Even the most minimal entry point, you have a function that just takes in some bytes and outputs some bytes. This is just pure Rust.

You can go wild, do anything you want here. And you're not bound by the traditional gas limits or execution costs that EVM contracts would normally have. Can we add support for other languages in Rust? If folks here are curious about Zig, it took me about 16 lines of code to add full support for Zig for Stylus. And if

Speaker 0: you have any other favorite programming language that

Speaker 1: you want to write smart contracts in, you can go ahead. It's all up to you. When Stylus, we have fully working fraud-proving for Stylus programs, full EVM compatibility and interop, and also ABI equivalence, which is really important. Rust is supported out of the gate, and a lot more is coming.

Speaker 0: The really cool thing is that when you

Speaker 1: interact with a stylus program, it looks just like a Solidity smart program, a smart contract. You don't even need to know that it's in Rust. You get an ABI interface to Solidity. You call a function. You do a transaction.

Underneath the hood, it could be written in Rust. It could be written in Zig or even in C. And basically, the world is your oyster if you use Stylus. If you're an L2 developer, If you're interested in smart contracts, if you like writing Rust, please find me after this talk. And you

Speaker 0: can contact us. I want to give a huge shout

Speaker 1: out to the team lead and the master mind behind Stylus, which is Rachel Bosfield from our team. And you can also contact me. So thank you everyone.

See all Paradigm transcripts on Youtube

Rust x Ethereum Day - Arbitrum Stylus: Rust smart contracts on L2