Learning the Fundamentals of Tenderly: The full-stack Web3 infrastructure layer

GM, GM. Welcome to what's going to be another great DevNTell, gang. So if you didn't know, DevNTell is a 30-minute podcast held every Friday, allowing founders, hackers, and anyone in between to showcase what they've built or the product they've founded. And this week, I'm ecstatic to welcome Nenad Vitorovic, who's DevRel at Tenderly. Tenderly is a full-stack Web3 infrastructure layer with Node RPC, dev environments, and exploration tools. So if you stick around for today's session, you'll see Nenad introduce us to Tenderly, its use cases, and showcase practical applications in an exciting live demo. All right, let's get into it.

GM, GM. Welcome to the show, Nenad. Pleasure to have you on, man.

GM, GM. It's a pleasure to be here. Hello, everybody.

Excellent, excellent. Yeah, I'm really excited to get into all of the great stuff you have prepared for us today. But before we get into that, would you like to give an introduction about yourself, if folks aren't familiar?

Yeah, sure. So my name is Nenad. I'm DevRel lead at Tenderly. And yeah, before DevRel I used to be an engineer, and before that I used to be a teacher for a little while, so you sort of see how those things come together. And yeah, I'm showing people how they can build dApps and contracts and test them in different ways using Tenderly, but way more beyond that as well.

Awesome, awesome. Yeah, that seems like the exact mix you need to get into the DevRel space. So that's excellent to see. What did you used to teach, if I may ask?

Yeah, so I used to teach like introduction to programming, databases, a little bit of object-oriented, you know, that kind of stuff. So a lot of introductory university courses.

Oh wow, okay. Awesome, awesome. And I guess what brought you into the world of like professional software?

Yeah, so I like to joke that I hated teaching Boolean algebra. But actually, yeah, I really enjoyed building things and building things within a team. So I started, I went back into the industry and that's where I stayed. But again, that sort of teaching thing always haunted me because whenever we sort of introduced a new technology in the team, I would sort of pull the wagon there. So then I got a chance to pull a pretty big wagon of Web3 developers.

Awesome, yeah. Someone always has to lead the wagon, so no better person from what you've said. And I guess when you made your foray into software from academia, was Tenderly the first stop or was there anywhere in between?

No, it was everywhere in between, from mobile to infra to backend to all sorts of stuff. And then Web3 happened and then Tenderly happened.

Gotcha, gotcha. Awesome, man. Yeah, I guess with that, it's a good segue to see what Tenderly is all about. I'm excited here and folks, if you have questions, please ask them in the chat as we're going along and we will get those answered for you. But without further ado, there you go. Floor is yours.

Okay, there you go. So I do have a little presentation here. It's just a couple of slides, it's mostly images, pictures, so don't be worried, I'll be doing a lot of slides. So as you said, Tenderly is a full-stack Web3 infrastructure platform for dApps and teams. And what this means practically is that, well, we have the infrastructure and different tooling for debugging and developing and staging and monitoring dApps. And yes, we're building this for dApps, but we're also building this for teams, so the collaboration within the teams gets as smooth as possible. And I will demo some of those things later on. So this is a slide with my name on it, with my Twitter handle and as I said, DevRel Lead at TenderlyApp, so if you're not following TenderlyApp, follow on Twitter to get the updates there. And I would just like to come through different things that we have. As I mentioned, there are a couple of buckets and the first bucket is the tooling for development and staging, and those are, to name a few only, Virtual Testnets that we will cover today, the Visual Debugger and the Visual Transaction Trace Inspector. The second sort of bucket is Security & Monitoring and there we have, how I like to put it, reactive security tooling and proactive security measures. So proactive security is simulations, which would give you the prediction of transactions execution before it touches the chain, so you know what you're signing. And in that sense, it is proactive. And on the other hand, there's reactive: alerts and Web3 actions that allow you to monitor contracts, for example, to monitor if an event parameter has a value greater than a particular threshold, then you will get a signal that that is happened on your Slack or Telegram or a webhook gets triggered, so you get informed about stuff happening on-chain pretty soon. Like the simplest application of that is tracking the state of your balance in your wallet, so if it goes down, then you know it happened. And Web3 actions, so this one over here, that's pretty much like serverless backend for smart contracts. So alerts will tell you, 'Hey, this happened,' and Web3 actions, they will actually run a little bit of JavaScript that you set up on Tenderly. So you can automate things like sending a nice message to your community on Discord, or even pausing a protocol if you want to go that far. So that's the second bit, security and monitoring, and the third bit is actually RPC Node, and that node, oh, sorry, we got to that one. And the node actually, well, it has everything that we previously mentioned as RPC methods, so simulations are there, gas estimation is there, tracing is there, and of course, the standard set of RPC methods is present, but it's also got another cool feature and that's node extensions that allow you to write your own custom RPC methods so you can encapsulate a little bit of logic. So if you're prototyping something and you don't want to run an API elsewhere, well, you can, and you need a node, well, you can just pack that little bit of JavaScript in there and there you go, you have an RPC API that you can use.

So these are the three buckets. And yeah, now we come to this slide, so this is like the motherboard. This is everything, it's how it's connected. So on the one hand, we have the developer explorer that has all the things that I mentioned, the debugger, the gas profiler, the tracer, and the visual simulator that is really helpful when you debug issues because you can well, simulate a transaction whether you're building a new one or you're trying to fix a failing transaction on testnet or, God forbid, mainnet. Then you can use the simulator for that because you get like nice UI that you can fill in and you can do all sorts of things like overriding storage slots, you can even change the source code when you simulate. So it's pretty wild and Solidity devs and security researchers, they pretty much love it because they can do all sorts of crazy things and mock different conditions that are not present on-chain. So that's the developer explorer. And the second bit that we will focus on today are Virtual Testnets. So we know that Tenderly has node, node RPC, so we got the standard methods, there's a simulator, there's the gas estimation, and building on top of that, we created something that is sort of a replacement for public testnets. So if you want to test a dApp or a protocol as a team, you can just spin up a fork of mainnet using the Virtual Testnet. And that gives you access to all the mainnet information, it also gives you an unlimited faucet, so you don't need to wait for that 0.1 or 1 ETH to mine, which is pretty handy when you want to test something out with high volumes of tokens, whether it's native tokens or ERC20 tokens. So this is a part of what we call Admin RPC, in other words, it's the cheat code RPC, or the God mode RPC, or better yet, Pseudo RPC, which allows you to change absolutely anything around the Virtual Testnet. And since the virtual testnets have full data from the mainnet, from the originating chain, this pretty much allows you to do CI and CD and it allows you to check how protocols behave with actual data. So imagine like you did deploy it and you can actually see how your contracts would behave in a realistic world, not the world of, you know, an empty chain with some mocked states. So that's there. And another cool use for that is staging, so you can pretty much take your contracts and after you're done with them, you can stage them for other people like UI and backend and indexers in your team to work with those contracts. Or you can even stage an entire dApp, so put the contracts, connect the UI to the Virtual Testnet, connect your subgraph to the Virtual Testnet, and you have staged the whole thing, whether it's for like internal testing or you want to do a beta test or you just want to do bug bounty but on an isolated environment, then testnets can be a pretty good answer to that. And I will not go through all of these other boxes, I want to stay focused on the testnets part. But as I said, the monitoring area, we have Web3 actions and alerts, which are pretty useful for different governance cases, for security researchers, and of course, for all of that we have different APIs, a CLI and an SDK that allow access to all of this and allow people to manage all of their stuff on Tenderly. So that's like the bird's eye view of the platform. And as I said, now I would like to just show you how the platform actually looks. So here we are. And this is Tenderly, it's a web platform essentially. And on the left-hand side you have all these things that I mentioned, here you can see your usage and stuff like that. And I want to go straight into Virtual Testnets.

And we could create one in the browser, but I actually want to do something different. I want to go through a flow of a team working on a codebase and you know, doing their contracts, adding their UI and so on. So I'll switch over to this scaffold-eth project, actually this is a fork of scaffold-eth that I made so it incorporates Tenderly. And let's do a demo with that. So for those who don't know, scaffold-eth is just a scaffolding framework, you write out your Hardhat contracts and then Next.js has a UI that automatically sort of generates the interface for interacting with those contracts. And I added a little Tenderly package here, and this one is what we care about today. So there are a couple of scripts and the first thing that we would need to do is actually provision a new Virtual Testnet by calling this command. And what it does in the end, it just calls the testnets API, so we get a new instance. And let's run this one, so it should be, let me see, yeah, we could go with these. So this is the name of my environment, so you can imagine you can have a demo environment, you can have a internal testing environment, you can have different environments. And these are the chains that this environment will sort of hold. So I want mainnet and I want Base in this case. And if I run this command, it's doing stuff and when I go back here and reload, I pretty much get those two testnets created pretty fast. And I will say it again, so this completely gives you the data that's available on mainnet. So everything is pretty much visible, so if I wanted to, I don't know, query a balance or a liquidity pool, I could do that and I will get the latest mainnet data because this is the latest block there. Okay, so far so good. Now, the second thing that we need to do, and now I'm switching over to a smart contract developer, I'm putting that Hardhat on. And the next thing that we need to do is actually connect the Hardhat project to that virtual testnet. So for that we have this command: connect hardhat and then I need to specify the name of that environment, and it's this one. Oh, actually I made a mistake, I need to activate it first. And then connect it. Okay, and from the Hardhat directory, nothing changed in the UI, from here I would need to just say yarn deploy network virtual-mainnet. So I would run the deploy task and this would be the special network that we're deploying to. Now, how do I know that? Well, oh, something happened. Ah, yeah this happens sometime because I had previous deployment and now it's complaining. So here it is, it's happening and how I knew the name of the network, well this little script of mine, well it just added virtual-something to the configuration so all these networks are present and recognizable in their name. And you can see how these transactions are happening here and all of that just popped in. Now, one interesting thing is that it appears these contracts are immediately verified, and they are. So if I go inside and if I pick this function, then I will actually see the content of that file in Tenderly. And what's also cool is that you get all the arguments decoded, but you can also hop into the debugger. And here, I just need to zoom out. And here you can actually see the entire call trace, which is not that deep, but also you can see the events that were emitted and everything is pretty much decoded in here. So this is how long it took for a couple of contracts to get deployed and if you're staging contracts for development, I think this sort of time saver is pretty significant.

Now, the next bit after the contracts are deployed, if we go back here we can see that we have this Admin RPC and we can share it with the rest of the team. Of course there's a WebSocket RPC as well. And you can find all the contracts in here under virtual contracts, so these are all those contracts that I deployed. You might be wondering how does this get verified? Well, here we have a little package called Hardhat Tenderly, which performs automatic verifications of contracts on Tenderly, so it's not going to Etherscan or Blockscout, it just remains within Tenderly so if you're doing something and you don't want your code to be seen publicly, this is a way to keep it private. And now I want to go into the UI. So I would just say connect this environment with the Next.js project. And what it does, it just pretty much creates a similar configuration file in here. Here it is, with the network config that fits the VM config style. And yep, that's pretty much it here. The last thing that I need to do and I want to do is actually running this, running the UI and here we go. Right there, so we have all these contracts that we deployed available. And now comes the question, so what do I do for test ETH? So as I said, we have the Admin or Pseudo RPC, and it allows us to build unlimited faucets. So this little button when I click it, it's actually talking to Tenderly and saying, 'Hey, use this wallet and give it 100 ETH.' So when I reload, I have 100 ETH pretty fast. And I'll just interact with this contract, so I'll just call it DD and put a bunch of initial supply. And we already have a transaction that has happened, it's complete. And if I go back over here, well, we can also see this transaction that happened just now as well as set balance. So this was like a pretty, pretty fast run-through this whole thing.

And I'll just like to touch upon a couple of different things on testnets. So here if I go to Faucet, then I can actually enter a bunch of addresses and an arbitrary amount and pick whether I want to do the native token or I can do an ERC20 token. I can even paste an address of an arbitrary ERC20 and it will be funded. So here, let me fund this one with 1000 USDC. And this is how much it took us to get those 1000 USDC. So that's pretty cool. And yeah, if you're looking for integration instructions, here they are, how to integrate with Foundry, Hardhat, Wagmi, VM, and how to do some sort of basic interactions around with virtual testnets.

And before I finish, because there's really a lot to show and to say, I would just like to first of all show the public explorer. So I just opened this up and I could share this link to pretty much anybody, whether or not they have a Tenderly account, and they have something that looks like our dashboard, but it's actually just a public explorer showing all the transactions that have happened, of course fully decoded with all the events decoded, state changes showing up and gas profilers showing the gas usage. And here, if I try to open this one, it says, 'Whoops, something has gone wrong.' And this is not an accident, this is not a mistake. When I created this virtual testnet, I decided to tuck away the actual source code. So I just went for the ABI visibility. I could also go to full visibility, so the source code is nicely visible here, or no visibility, so you wouldn't even get any decoding whatsoever. So this is one pretty cool thing. And another pretty cool thing, and let me hop over to docs to touch upon that, is state sync. So state sync pretty much means that even though I've forked from mainnet, as mainnet keeps growing, my virtual testnet will be aware of the latest changes happening there. So if this block over here is trying to read an oracle value that was updated here, that will be possible, so I will get the very latest oracle value in there. And this is completely configurable. And of course, since we are talking to the developers here, here are the Admin RPC methods. So we have a bunch of network customization like increasing time, timestamps, skipping blocks. What's cool as well, setting balance is setting ERC20 balance, setting storage to arbitrary location so you can mock things, you can also set code to arbitrary locations so you can like deploy bytecode you've instrumented in a way so you can keep track of what's happening to your contracts, and there's snapshot and revert that allow you to undo whatever you did. So these were Virtual Testnets in a pretty short time, but as you can see, there's also a lot of things like Simulation API, the Developer Explorer with the simulator UI, there's alerts and Web3 Actions over here, and a bunch of other different things.

And that would be, that was my demo. I would like to leave some time for questions and answers. Yeah, this was actually really, really awesome. Like I'm a developer myself, so seeing this in action was like really cool. So with the Virtual Testnet, like what's its uptime? Like when you launch it after some period of inactivity, does it just shut down or is it like up until you tell it to go away?

Yeah, so virtual testnets do have a lifetime, let's say, so if after a particular time you're not using it, it will be sort of deactivated. The important thing is that the entire, all the data, all the transactions and the state changes will be preserved also for a limited but of course longer time, so it's open for inspection. And in the future, you'll be able to pause a virtual testnet as well so you're purposely, you're intentionally sort of putting it to sleep, let's say.

Gotcha. And with the RPC URL that's given to you, can you use that in like your personal like staging or testing environment? So say you have like a app that you've deployed, can you use your Virtual RPC in that environment and have the connections kind of talk to each other?

So can you use the virtual testnet RPC in a production dApp? Is that what you're asking? Staging app. Staging app, yeah, yeah. So you can definitely, whatever you do for staging, you can hook it up to the Virtual Testnet. Of course, you would need to solve the challenge of connecting other off-chain components to the testnet, like indexers and bridges and stuff like that. And there is some progress and there is some research going around those questions right now and hopefully those will be answered as well.

Yeah, yeah for sure man. And I guess in terms of how people can get started, is there like a pricing model or can devs just start deploying virtual testnets off the bat?

Yeah, so for trying out virtual testnets you can do that on the free plan, but it has a limitation of the number of blocks it takes. I think it's like 30 blocks, which is really, you just get a little taste of it and if you do anything serious then it's not possible. Other than that, you could activate the free trial for two weeks and really push it to the limits, and please do. And after that you would have to decide for either a developer or Pro plan.

Gotcha, gotcha. And say you get to a point after you're done testing through Tenderly, does it also support bringing in like a mainnet, an actual mainnet contract for you to be able to see all the security and monitoring and all that?

Yeah, so if we're talking about the moment after you've deployed to production, yes, absolutely. So this part of the dashboard, one level up, it's actually the one that you can use to track all the contracts you care about. Let me show you that, so here I'm going to add a contract and it's going to be the one from mainnet, and hit save. So I got my swap router, actually Uniswap swap router and I can immediately get the listing of all transactions happening on that contract and others. I can filter by transaction, I can build alerts around that contract. So let's say I want to do event parameter for swap router and this is the transfer event, and let's say this is greater than, I don't know, this much. So I'm building out an alert that will track that live contract from the mainnet. So yes, after staging and trying it all out in that controlled environment, after you go live, you can just hook up your contracts in the Tenderly dashboard and set up the monitoring in there.

Cool. And then can you send the alert to like PagerDuty or is it email or SMS? I guess that's the next step.

There we go, next step. So here you can see that we have, you can set it to email, Slack, Telegram, Discord, it can go to a webhook, it can go to PagerDuty and wake you up in the middle of the night. It can go to Sentry, and it can also be piped to a Web3 Action. And as I mentioned, Web3 Actions are serverless backends for smart contracts, let's say. And let's do a simple one, you can actually build a webhook using this completely, but I'm going to take block and here I can write a little bit of JavaScript. And if you're using the CLI, you can actually upload a whole NPM package so you can use other JavaScript dependencies, NPM dependencies. And here you would have to select a trigger and so on, and so on. So this is a way that you can build like a very, very specific criteria of watcher monitoring and then pipe it to the Web3 Action so it processes that thing.

Interesting, interesting. And last question from me is what or do you support a wide array of chains to be able to be used or yeah, what networks do you support?

Yeah, pretty much. So there's last time I checked over 50 something networks, mainnets and testnets as well, all included. So we have a pretty growing ecosystem of networks that want Tenderly integrated so developers can have the best developer experience and can build reliable products and be able to sleep at night.

Yes, that's what we all want, just a good night's sleep. Well, yeah, unfortunately this brings us to time, but Nenad this was really, really awesome. Like I mentioned, I'm a developer myself, so like seeing this in action was like really cool. But I guess for folks who want to reach out, ask questions, get help, like what's the best way for them to reach out to you or anyone at Tenderly? Yeah, so for any sort of help with Tenderly itself, here you would see a little Intercom icon so you can reach out to our support team and they're pretty amazing and highly responsive. So that's the fastest way. And if you're okay with waiting a little bit, then you can also write to me on Twitter or Telegram and yeah, those are the two ways that you could definitely get in touch with us.

Awesome, awesome. And I guess just to leave folks with a little tease, if you can, can you share anything around potential goodies that are upcoming in the roadmap? Or if not, like how can people keep tabs on that?

Yeah, so we're definitely working on improving the experience in the dashboard. We're also doing some work around simulations and the simulator UI. And one of the best ways to stay in touch is and actively follow what's happening here is going for our RSS feed, which I cannot find, but you can also subscribe to the newsletter because we really push out the updates regularly over there.

Excellent, excellent. Well, like I mentioned, Nenad, thank you so much for taking the time to come on today. I really appreciate it, giving us this awesome insight. And yeah, you're welcome back on anytime if you have any more goodies to share. Thank you very much, it was a pleasure and thank you for having me. My pleasure. All right, all, with that, I just want to wish you a very happy Friday, happy weekend, happy post-Thanksgiving to our US friends and we will catch you back here next week for another great episode of DevNTell. All right, all, catch you next time. Bye-bye.