Rust x Ethereum Day 2023 at The Foundry SF

Tom Meagher presents "Wagmi / Viem"

Thanks to Paradigm for hosting this event.

We're going to talk about 2 programming languages today.

JavaScript is like, no 1 really likes it.

We're actually going to talk about TypeScript, which is a little different.

And if you're not familiar with TypeScript, It's a super set of JavaScript.

It actually has a really important role in the crypto community.

You know, everything from Uniswap, ENS, FriendTech, if you've used any of these things, they have front ends, which are primary ways that people interact with protocols and other really cool stuff we build.

And I just so happen to maintain a couple open source libraries.

1 of them is Wagme, which is a high-level React hooks library.

If you've donated to the latest Gitcoin round, you've used FriendTech, you've registered a domain on ENS, anything like that, you've probably used Wagme.

It's pretty popular throughout the space.

It allows you to do stuff like connect wallets, send transactions.

And yeah, I mean, it launched fairly recently, and it's sort of taken over the front end world.

Me and then my co-collaborator Jake, who's in Australia so he couldn't make it, started collaborating with Paradigm in November last year.

And yeah, just some examples of what you can do.

Here's a really simple way to connect a wallet.

You would think that this is easy, but there's so many different wallets out there, hardware, and lots of other ones.

And if you do a little bit of configuration and then just put this code into your editor, you end up with something that doesn't look quite as nice as that because you have to write CSS, which is kind of a disaster.

And then you can do other stuff, too, like contract interaction.

Here's an example from mint.fun, just like minting NFTs.

Pretty straightforward, not a lot of code.

And so we had this higher level reactive framework to build applications, but we wanted to move a little bit further down the stack.

And so there's things like this that have existed over the years, Web3.js, Ethers, JS, and I feel like similarly to the rewrite it in Rust mentality, we were sort of like rewrite it in TypeScript, like really, really good type safety and type inference.

And so VM, which is our effort for that, launched earlier this year.

It does JSON RPC requests, ABI encoding and decoding, signing.

It's kind of a cool thing to do because Wagme was originally written in Ethers.js.

We wrote VM, swapped out the underlying implementation, Everything kept chugging along on all the dApps and stuff that were using it.

This isn't probably what you would see If you compared Rust with these different JavaScript frameworks, but in terms of encoding, it's the fastest out there that I'm aware of right now that's used and very popular.

You can interact with Anvil really easily.

There's like wrappers for all the Anvil methods you do use.

And this is really popular, and people using it in their front end, like test suites and stuff like that.

This is the part that I get really excited about.

So basically, everything up until this point has mostly probably just looked like JavaScript to you guys.

I mean, TypeScript is super-save JavaScript.

And there's this really cool thing that you can do.

TypeScript is a Turing-complete language.

And what you can do is you can take code, so in this case, here we have an ABI fragment, which is a tuple, and then in the TypeScript type system, you can transform it and then create static types, which then add a lot of nice type safety, whereas JavaScript doesn't have any.

And this is really important because if you pass the wrong number value or you're not passing in an address or something, people might lose money, something might break.

And yeah, you see a type error here because we know we've parsed that in the type system and then pulled it out and said, OK, this needs to be a big int, and because it's not, it's doing an error.

Big ints in JavaScript, this would have been 420 and then an N after it.

And you know, similar thing, you know, We don't just do types, we do fixed length tuples too.

The type system is really cool and allows us to do some pretty complex stuff.

It's like a whole programming language in its own.

And just to demonstrate something that I think is even cooler, but demonstrates the power of TypeScript.

This is like a function, we have human readable ABIs.

This is a function called parseABI, which takes, basically you can just copy the signatures from your contract.

And it has 2 implementations, 1 at runtime, which will transform those strings into a JSON ABI, but then also a parallel implementation at the type level, which in your editor you see I'm hovering over the symbol, and it's transformed it, which was cool.

So yeah, I think 1 thing that we've been trying to hammer on a lot is this concept of advanced developer experience, which coming from the Rust world, some of these things might look pretty similar, like making sure things are strongly typed, inferring types wherever we can.

It's really nice to be able to just go into your editor and write some code and auto-complete your way to success.

If anyone has a really large contract that they know of, you can tell me about it because I'd love to try it out.

But this stuff works really, really well.

You can just throw massive contracts at it, and the type system's able to handle it all.

Modular architecture, so we really care about making sure that All the functions that exist in VM and Wagme are low-level enough that you don't have to do workarounds and things like that.

They're really composable and work well together.

Because often this stuff is running in the browser, Some people are building their APIs with VM and other back-end related stuff, but because a lot of this often runs in the browser, making sure that it's as small as possible.

Yeah, and we try to make contributing easy.

Really high-quality docs, tests, because that's the stuff that makes, I mean, that stuff can make your day job really painful if you're using library and makes it easy for people to learn.

I think reading the VM docs has been really helpful for a lot of JavaScript people because it sort of introduced them to lower level concepts in Ethereum that were abstracted away before, or they didn't really understand.

We tried to use the same names for stuff, like RPC methods map, like those names map to exactly the same names in VM for functions and stuff like that.

And so yeah, the stuff we built has been pretty popular.

Writing TypeScript, there's some things that I am very envious of when I look at the Rust world.

Error handling JavaScript isn't the greatest.

1 of my personal favorites is pattern matching in Rust.

I feel like the JavaScript community has basically built libraries that are Rust language features.

There's 3 package managers at least that are popular for JavaScript.

That's something whenever you're writing something, it makes you feel good about it.

So this is where we get to maybe combining Rust and TypeScript together.

This is kind of like a blue, because TypeScript is blue, like a cartoon version.

And so something I've been thinking about is how can you take some really great stuff, TypeScript types, and that's like the stuff that JavaScript developers are using in their editor and keeping things safe, and how can you pair it with something like using Rust at run time?

Maybe there are some libraries and stuff that you're lazy and you don't want to reimplement that in JavaScript.

Maybe they're really solid, lots of people use them, they're extremely performant, stuff like that.

So yeah, this is just like an exploration into TypeScript and Rust via WebAssembly.

Sort of the goal here was to see if we can maintain the same developer experience, but then also maybe reduce some things like bundle size and improve performance significantly, and Also give JavaScript developers access to the Rust community, because there's a lot of great stuff happening.

Yeah, and you see the TypeScript logo here.

It's not as great as Ferris, so unfortunate.

Unfortunately, I'm not familiar enough with Alloy to have implemented that.

And yeah, VM, and we're going to compare them together.

So on the left-hand side is ethers RS, and this is going to be signing some data, which we'll look at in a sec, and on the right is VM.

Not perceivable, but it's Rust, so definitely quite a bit faster there.

If you wanted to do this for 1 of your libraries, how would you do it?

There's some imports and stuff that's not here, and excuse my rust if it's not.

So yeah, we're just signing some type data.

So we're going to expose that method in a way that Wasm can use.

And then also we're going to be generating random wallets, so doing that as well.

If you're not doing any crazy type level programming, which we are, in this case we are, You can just get TypeScript types to automatically work with this stuff without too much overhead.

But in this case, we're going to write some basic TypeScript using this library called ABI type, which is 1 that we also work on, which does all the type transformations.

And so, yeah, I mean, There's not much here.

And then in terms of what you have now, you run WasmPack, and now you have this library that you can use.

And you get all the benefits of Rust behind the scenes.

And then you also get the benefits of TypeScript, really strong type safety, inference, auto-completion, And yeah, works really well.

So what does the future of this look like?

It's not like a frequent thing that people are reaching for all the time.

Well, unless you're doing something extremely computationally expensive, where you're okay with having some maybe context switching between different languages, and you're okay going over the Wasson bridge and taking that hit, and then maybe loading some extra bundle size depending on what libraries you're using.

Otherwise, you know, people have sort of stayed away.

But some things that I'm excited about as stuff improves is maybe we can swap out some internals in VM.

Like we have our own ABI encoding and decoding in there, which is pretty fast like you saw, but it doesn't compare to Rust.

So if that becomes a bottleneck, eventually maybe we want to swap it out.

Another thing that I think is really exciting is maybe running Anvil or something like it in the browser someday for simulation or other things like that.

And then I think it'd be cool if, for certain things that are applicable to a wider audience, maybe people that would use JavaScript libraries, that there's implementations that already exist in Rust, is like adding TypeScript types and Wasm packing your Rust library.

Because then you don't have to write that much JavaScript.

You're only really writing the type level.

And yeah, I'm super down to chat about this more.

I think it's exciting, and it will only get better if there's some cross-pollination between communities and people working on stuff.

Especially in crypto, I think there's maybe some exciting use cases.

So there's actually 1 more thing I wanted to chat about here, which is this thing called Rivet.

I'm not sure if anyone's seen this, but we announced this this morning, and Rivet is – So right now we find ourselves in this situation where, you know, as developers, most of us are using consumer wallets and like global test nets to write our software, which aren't really meant for this use case at this point, you know, consumer wallets don't necessarily have features that, you know, you need to debug stuff and iterate quickly.

If anyone's tried to, like, do stuff, like run Anvil and use MetaMask and have to reset nonces and stuff like that, It's not very fun to do.

And then global public test nets, sometimes the iteration speed is slower.

You have to scrounge up some test net ETH and things like that.

So yeah, the goal of what Rivet is is what if we built some tools for developers to use?

It's developer wallet and dev tools, sort of like React dev tools, if you've used that or any other browser dev tools.

It's a little bit higher level, allows you to manipulate state of Anvil.

So you can really shorten the feedback loop to doing stuff like send a transaction, okay, now it's reset.

You need to add some balance or fund an account, just click a button to do that.

And yeah, we're super excited to collaborate with Paradigm on it.

You can just go to this link if you want to try it out in an early alpha state.

And I'm going to show it to you here in this demo.

We can pick some ETH amount, swap to USDC.

The cool thing about this is you go to any website, start interacting with it.

In this case, we're not going to confirm the swap right away.

We're going to change our balance so you can see how it works.

We're going to auto-mine, or manually mine here.

So we switched our balance to 10, and now we don't have enough.

So let's add some ETH back to our balance and mine that.

And then let's switch to interval mining so we don't have to manually press stuff anymore.

And then, yeah, we can just swap and it's done once it comes up to confirm.

And yeah, we're super excited to keep building on this and making sure that it's really solid and something that shortens iteration time for people, allows people to collaborate.

1 thing that we're really excited for is this notion of time travel debugging, where you can just jump back and forth on the chain to reproduce issues that users are having, and just move really quickly.

And if anyone has any questions, happy to answer them.

you want to learn more about our JavaScript, TypeScript.

Maybe you can't answer this, but why do you think the Ethereum Foundation isn't pushing forward a lot of these ideas.

These ideas are excellent and badly needed.

And how hard is it going to be to push these ideas back into the Ethereum Foundation?

Yeah, you mean stuff like developer tools or Rust?

Yeah, I mean, I think the Ethereum Foundation is great.

Like, they set up some roadmap and things like that.

So, people are just working on stuff that they find cool and taking initiative.

I feel like community already does a decent job, but I think, yeah, sometimes it is good if stuff comes from like a respected and trusted source too.

And maybe to add on that, that the EF is responsible for fostering an ecosystem, but ideally the ecosystem, it should be anti-fragile.

The EF should be able to disappear tomorrow and the ecosystem should still move forward.

I was curious what's your experience with Wasm and the maturity of it in terms of adoption in the browser a little bit more.

Yeah, I haven't used it a whole lot other than just experiments around it.

I mean, from what I've seen just based on diving into it really quickly, it's like the developer experience of me jumping in with no knowledge, there's a little bit of learning curve to figure out how to package these things up, but once that's done, I can like, this wasm wallet package, you can go to NPM, it's available there, or you can go to this website wasm-wallet.vercel.app and just try it out and it works pretty well.

So stuff's definitely a lot better than it was like 5 years ago when I tried to hack on it then.

Yeah, so this specific case, the bundle size has actually increased a little bit.

But there's a lot that you can do to try to eliminate that.

I'm asking because in the past, the reason I moved on from a lot

of Wasm stuff is because the bundle size blew up.

and the whole pipeline was not well suited to Wasm.

So I have quite a bit of experience here, if you need help.


Speaker 0: Yeah, thanks for coming, everyone. Super excited to be here. Thanks to Paradigm for hosting this event. We're going to talk about 2 programming languages today. Any guesses which ones?

What's that? Rust is 1 of them. Not JavaScript. JavaScript is like, no 1 really likes it. We're actually going to talk about TypeScript, which is a little different.

And if you're not familiar with TypeScript, It's a super set of JavaScript. It actually has a really important role in the crypto community. You know, everything from Uniswap, ENS, FriendTech, if you've used any of these things, they have front ends, which are primary ways that people interact with protocols and other really cool stuff we build. And I just so happen to maintain a couple open source libraries. 1 of them is Wagme, which is a high-level React hooks library.

If you've donated to the latest Gitcoin round, you've used FriendTech, you've registered a domain on ENS, anything like that, you've probably used Wagme. It's pretty popular throughout the space. It allows you to do stuff like connect wallets, send transactions. And yeah, I mean, it launched fairly recently, and it's sort of taken over the front end world. Me and then my co-collaborator Jake, who's in Australia so he couldn't make it, started collaborating with Paradigm in November last year.

And yeah, just some examples of what you can do. Here's a really simple way to connect a wallet. You would think that this is easy, but there's so many different wallets out there, hardware, and lots of other ones. And if you do a little bit of configuration and then just put this code into your editor, you end up with something that doesn't look quite as nice as that because you have to write CSS, which is kind of a disaster. But, yeah.

And then you can do other stuff, too, like contract interaction. Here's an example from mint.fun, just like minting NFTs. Pretty straightforward, not a lot of code. And so we had this higher level reactive framework to build applications, but we wanted to move a little bit further down the stack. And so there's things like this that have existed over the years, Web3.js, Ethers, JS, and I feel like similarly to the rewrite it in Rust mentality, we were sort of like rewrite it in TypeScript, like really, really good type safety and type inference.

And so VM, which is our effort for that, launched earlier this year. It's a lower level interface. It does JSON RPC requests, ABI encoding and decoding, signing. It's kind of a cool thing to do because Wagme was originally written in Ethers.js. We wrote VM, swapped out the underlying implementation, Everything kept chugging along on all the dApps and stuff that were using it.

And so VMs, we rewrote it. It's pretty fast. This isn't probably what you would see If you compared Rust with these different JavaScript frameworks, but in terms of encoding, it's the fastest out there that I'm aware of right now that's used and very popular. You know, it does some cool stuff. You can interact with Anvil really easily.

There's like wrappers for all the Anvil methods you do use. And this is really popular, and people using it in their front end, like test suites and stuff like that. This is the part that I get really excited about. So basically, everything up until this point has mostly probably just looked like JavaScript to you guys. Because it is.

I mean, TypeScript is super-save JavaScript. And there's this really cool thing that you can do. TypeScript is a Turing-complete language. And what you can do is you can take code, so in this case, here we have an ABI fragment, which is a tuple, and then in the TypeScript type system, you can transform it and then create static types, which then add a lot of nice type safety, whereas JavaScript doesn't have any. And this is really important because if you pass the wrong number value or you're not passing in an address or something, people might lose money, something might break.

It's not a great situation to be in. So here's an example. We have this ABI fragment. And yeah, you see a type error here because we know we've parsed that in the type system and then pulled it out and said, OK, this needs to be a big int, and because it's not, it's doing an error. Big ints in JavaScript, this would have been 420 and then an N after it.

And you know, similar thing, you know, We don't just do types, we do fixed length tuples too. So here's 1. The type system is really cool and allows us to do some pretty complex stuff. It's like a whole programming language in its own. And just to demonstrate something that I think is even cooler, but demonstrates the power of TypeScript.

This is like a function, we have human readable ABIs. This is a function called parseABI, which takes, basically you can just copy the signatures from your contract. And it has 2 implementations, 1 at runtime, which will transform those strings into a JSON ABI, but then also a parallel implementation at the type level, which in your editor you see I'm hovering over the symbol, and it's transformed it, which was cool. So yeah, I think 1 thing that we've been trying to hammer on a lot is this concept of advanced developer experience, which coming from the Rust world, some of these things might look pretty similar, like making sure things are strongly typed, inferring types wherever we can. It's really nice to be able to just go into your editor and write some code and auto-complete your way to success.

We support ABIs, type data, schemas. The ABIs can be massive. If anyone has a really large contract that they know of, you can tell me about it because I'd love to try it out. But this stuff works really, really well. You can just throw massive contracts at it, and the type system's able to handle it all.

Modular architecture, so we really care about making sure that All the functions that exist in VM and Wagme are low-level enough that you don't have to do workarounds and things like that. They're really composable and work well together. Because often this stuff is running in the browser, Some people are building their APIs with VM and other back-end related stuff, but because a lot of this often runs in the browser, making sure that it's as small as possible. Yeah, and we try to make contributing easy. Wagner has around 150 contributors.

VM has around 80. Really high-quality docs, tests, because that's the stuff that makes, I mean, that stuff can make your day job really painful if you're using library and makes it easy for people to learn. I think reading the VM docs has been really helpful for a lot of JavaScript people because it sort of introduced them to lower level concepts in Ethereum that were abstracted away before, or they didn't really understand. We tried to use the same names for stuff, like RPC methods map, like those names map to exactly the same names in VM for functions and stuff like that. And so yeah, the stuff we built has been pretty popular.

Okay, so now for Rust. Writing TypeScript, there's some things that I am very envious of when I look at the Rust world. Error handling JavaScript isn't the greatest. 1 of my personal favorites is pattern matching in Rust. It's really nice.

I wish something like that existed. There's libraries and stuff. I feel like the JavaScript community has basically built libraries that are Rust language features. Package management is another. Random on cargo is great.

There's 3 package managers at least that are popular for JavaScript. And then obviously performance. That's something whenever you're writing something, it makes you feel good about it. So this is where we get to maybe combining Rust and TypeScript together. This is kind of like a blue, because TypeScript is blue, like a cartoon version.

And so something I've been thinking about is how can you take some really great stuff, TypeScript types, and that's like the stuff that JavaScript developers are using in their editor and keeping things safe, and how can you pair it with something like using Rust at run time? Maybe there are some libraries and stuff that you're lazy and you don't want to reimplement that in JavaScript. Maybe they're really solid, lots of people use them, they're extremely performant, stuff like that. So yeah, this is just like an exploration into TypeScript and Rust via WebAssembly. Sort of the goal here was to see if we can maintain the same developer experience, but then also maybe reduce some things like bundle size and improve performance significantly, and Also give JavaScript developers access to the Rust community, because there's a lot of great stuff happening.

Yeah, and you see the TypeScript logo here. It's not as great as Ferris, so unfortunate. OK, so to set the stage, I have a demo. It's going to be using ethers RS. Unfortunately, I'm not familiar enough with Alloy to have implemented that.

And yeah, VM, and we're going to compare them together. So on the left-hand side is ethers RS, and this is going to be signing some data, which we'll look at in a sec, and on the right is VM. I wonder which 1 is going to be faster. That's pretty fast, right? Not perceivable, but it's Rust, so definitely quite a bit faster there.

What does this look like? If you wanted to do this for 1 of your libraries, how would you do it? There's some imports and stuff that's not here, and excuse my rust if it's not. Something's a little funky with it here. So yeah, we're just signing some type data.

So we're going to expose that method in a way that Wasm can use. And then also we're going to be generating random wallets, so doing that as well. If you're not doing any crazy type level programming, which we are, in this case we are, You can just get TypeScript types to automatically work with this stuff without too much overhead. But in this case, we're going to write some basic TypeScript using this library called ABI type, which is 1 that we also work on, which does all the type transformations. And so, yeah, I mean, There's not much here.

It's pretty straightforward. And then in terms of what you have now, you run WasmPack, and now you have this library that you can use. This is in JavaScript now. And you get all the benefits of Rust behind the scenes. And then you also get the benefits of TypeScript, really strong type safety, inference, auto-completion, And yeah, works really well.

So what does the future of this look like? Wasm's been around for a while. No one's really used it. It's not like a frequent thing that people are reaching for all the time. What are some reasons for that?

Well, unless you're doing something extremely computationally expensive, where you're okay with having some maybe context switching between different languages, and you're okay going over the Wasson bridge and taking that hit, and then maybe loading some extra bundle size depending on what libraries you're using. Otherwise, you know, people have sort of stayed away. But some things that I'm excited about as stuff improves is maybe we can swap out some internals in VM. Like we have our own ABI encoding and decoding in there, which is pretty fast like you saw, but it doesn't compare to Rust. So if that becomes a bottleneck, eventually maybe we want to swap it out.

Another thing that I think is really exciting is maybe running Anvil or something like it in the browser someday for simulation or other things like that. And then I think it'd be cool if, for certain things that are applicable to a wider audience, maybe people that would use JavaScript libraries, that there's implementations that already exist in Rust, is like adding TypeScript types and Wasm packing your Rust library. Because then you don't have to write that much JavaScript. You're only really writing the type level. And yeah, I'm super down to chat about this more.

I think it's exciting, and it will only get better if there's some cross-pollination between communities and people working on stuff. Especially in crypto, I think there's maybe some exciting use cases. So yeah, TypeScript loves Rust. So there's actually 1 more thing I wanted to chat about here, which is this thing called Rivet. I'm not sure if anyone's seen this, but we announced this this morning, and Rivet is – So right now we find ourselves in this situation where, you know, as developers, most of us are using consumer wallets and like global test nets to write our software, which aren't really meant for this use case at this point, you know, consumer wallets don't necessarily have features that, you know, you need to debug stuff and iterate quickly.

If anyone's tried to, like, do stuff, like run Anvil and use MetaMask and have to reset nonces and stuff like that, It's not very fun to do. And then global public test nets, sometimes the iteration speed is slower. You have to deploy things. You have to scrounge up some test net ETH and things like that. So yeah, the goal of what Rivet is is what if we built some tools for developers to use?

And so that's what Rivet is. It's developer wallet and dev tools, sort of like React dev tools, if you've used that or any other browser dev tools. It's a little bit higher level, allows you to manipulate state of Anvil. So you can really shorten the feedback loop to doing stuff like send a transaction, okay, now it's reset. You need to add some balance or fund an account, just click a button to do that.

And yeah, we're super excited to collaborate with Paradigm on it. You can just go to this link if you want to try it out in an early alpha state. And I'm going to show it to you here in this demo. So we're on Uniswap. This is the Uniswap's website.

We can connect to it. We can pick some ETH amount, swap to USDC. The cool thing about this is you go to any website, start interacting with it. In this case, we're not going to confirm the swap right away. We're going to change our balance so you can see how it works.

We're going to auto-mine, or manually mine here. So we switched our balance to 10, and now we don't have enough. So everything's updated appropriately. So let's add some ETH back to our balance and mine that. And then let's switch to interval mining so we don't have to manually press stuff anymore.

And then, yeah, we can just swap and it's done once it comes up to confirm. Yeah, and so, yeah, we just swapped it. You can see the nonce incremented. We can see the transaction went through. And yeah, we're super excited to keep building on this and making sure that it's really solid and something that shortens iteration time for people, allows people to collaborate.

1 thing that we're really excited for is this notion of time travel debugging, where you can just jump back and forth on the chain to reproduce issues that users are having, and just move really quickly. So, yeah, that's Rivet. And if anyone has any questions, happy to answer them. Oh, and You can go to these links if

Speaker 1: you want to learn more about our JavaScript, TypeScript. We're going to

Speaker 2: do 2 questions for Tom.

Speaker 3: Maybe you can't answer this, but why do you think the Ethereum Foundation isn't pushing forward a lot of these ideas. These ideas are excellent and badly needed. And how hard is it going to be to push these ideas back into the Ethereum Foundation? If at all, I wonder. Maybe you can answer that.

Speaker 0: Yeah, you mean stuff like developer tools or Rust? Data stuff. Yeah, I mean, I think the Ethereum Foundation is great. Like, they set up some roadmap and things like that. But Ethereum is like a community.

So, people are just working on stuff that they find cool and taking initiative. So yeah, how does it get back in there? I don't know. I feel like community already does a decent job, but I think, yeah, sometimes it is good if stuff comes from like a respected and trusted source too. So I don't know.

Speaker 2: And maybe to add on that, that the EF is responsible for fostering an ecosystem, but ideally the ecosystem, it should be anti-fragile. The EF should be able to disappear tomorrow and the ecosystem should still move forward.

Speaker 4: Thanks. I was curious what's your experience with Wasm and the maturity of it in terms of adoption in the browser a little bit more.

Speaker 0: Yeah, I haven't used it a whole lot other than just experiments around it. So yeah, I guess that's mostly it. I mean, from what I've seen just based on diving into it really quickly, it's like the developer experience of me jumping in with no knowledge, there's a little bit of learning curve to figure out how to package these things up, but once that's done, I can like, this wasm wallet package, you can go to NPM, it's available there, or you can go to this website wasm-wallet.vercel.app and just try it out and it works pretty well. So stuff's definitely a lot better than it was like 5 years ago when I tried to hack on it then.

Speaker 2: And 1 last question from James.

Speaker 1: In the same vein, have you done any

Speaker 5: bundle size

Speaker 1: comparisons for the Wasm versus Veeam?

Speaker 0: Yeah, so this specific case, the bundle size has actually increased a little bit. But there's a lot that you can do to try to eliminate that.

Speaker 6: I'm asking because in the past, the reason I moved on from a lot

Speaker 5: of Wasm stuff is because the bundle size blew up.

Speaker 1: And Webpack

Speaker 4: and the whole pipeline was not well suited to Wasm.

Speaker 1: So I have quite a bit of experience here, if you need help.

Speaker 0: Totally. Yeah. Very interested.

Speaker 2: Big up, Lowe's, for Tom. Big up for Tom.

See all Paradigm transcripts on Youtube

Rust x Ethereum Day - Wagmi / Viem