A Guide to Tenderly TX Preview Snap


MetaMask Snaps allows you to extend the functionalities of the MetaMask wallet with your unique features and APIs. By using the open-source MetaMask Snap system together with the Tenderly Simulation API, we created Tenderly TX Preview Snap.

Using the Tenderly snap, you can preview the expected outcomes of your transactions without sending them on-chain. Tenderly TX Preview Snap gives you detailed and easily understandable information about your transactions, enabling you to sign and approve them with confidence and peace of mind.

How does Tenderly TX Preview Snap work?

The TX Preview snap simulates your transactions and gives you detailed information about their execution. It uses the Tenderly Simulation Infrastructure to run your transactions against more than 30 EVM-compatible networks, including Ethereum, Arbitrum, Optimism, Base, and Polygon. 

The snap then returns simulation data in a human-readable format instantly, displaying: 

  • Whether your transaction is successful or not.
  • Which ERC-20 and ERC-721 assets are transferred within your transaction.
  • The corresponding dollar values of your transferred assets based on real-time data. 
A Guide to Tenderly TX Preview Snap
Transaction preview in MetaMask with Tenderly Snap

How does the Tenderly Snap protect wallet users?

With Tenderly TX Preview Snap, you can know what’s going to happen with your transactions before actually sending them. This helps you avoid any unwanted consequences, prevent failed transactions, and save money on gas. 

Additionally, you receive this information automatically after installing the Tenderly TX Preview snap, without having to execute transactions on a real network. And you don’t even need technical knowledge to run or interpret simulations.

Yes, it’s that easy! 😎

How to preview transactions using the Tenderly snap

To start using Tenderly TX Preview snap, you just need to set it up by following a few simple installation steps. The process is quick and straightforward, automatically setting up your credentials. 

Once you’ve completed the installation, you can head over to any DeFi platform you typically use. After being prompted to confirm a transaction on MetaMask, you’ll notice a new “Tenderly TX Preview” tab. Here, you’ll find an overview of your simulated transaction, with details on its status, asset changes, and real-time dollar values. 

Want to see it in action? 👀 Check out this short tutorial: 

What you can do with simulated transactions

The Tenderly TX Preview snap gives you a few additional options if you’d like to further inspect your simulated transactions. Here’s how to dive deeper and get more granular information on your transaction simulations using Tenderly: 

1. Inspect and debug a failed transaction instantly 

In the TX Preview tab, you also get a link to the simulated transaction leading you to the Tenderly Dashboard. Once you open it, you can inspect the simulation in greater detail, including the contracts it interacted with, how much gas it used, which events were emitted, and which state changes happened. 

A Guide to Tenderly TX Preview Snap
An overview of a transaction simulation on Tenderly

This can be particularly useful in the event your transaction fails since you can immediately see what happened and try to fix it. Simply jump into Tenderly Debugger to step through the transaction trace by trace and analyze the exact cause of the failure.  

A Guide to Tenderly TX Preview Snap
Debugging a failed transaction simulation on Tenderly

2. Re(simulate) a transaction for new outcomes

After inspecting a failed transaction in detail, you can immediately test out a potential solution. Tenderly’s Transaction Simulator allows you to replay failed transactions with updated parameters and validate bug fixes. 

Just click the Re-Simulate button to initiate a new transaction simulation. Then, you can change transaction parameters, update state overrides, and even modify contract source code. After making the necessary changes, click Simulate to see whether your adjustments were successful.

3. Share a simulated transaction publicly with anyone 

Finally, transaction simulations in Tenderly TX Preview Snap, as well as on the Tenderly platform, are publicly shareable. This means you can share your simulations with anyone regardless of whether they have a Tenderly account. This way, you can encourage knowledge sharing among your team members or seek assistance with failed transactions. 

Start getting transaction previews in your MetaMask wallet

You don’t have to approve transactions hoping for the best. With Tenderly TX Preview Snap, get exact and clear insights into transaction outcomes before even sending them to a network. Use this information to inform your decisions, avoid making a mistake, and save valuable resources. 

And with the Tenderly Simulation API, you can integrate the same functionality into your wallet or dapp. This way, you can bring additional value to wallet users, improve their experience in Web3, and support wider blockchain adoption. 

If you’d like to try integrating transaction simulations yourself, follow this step-by-step tutorial showing how to add the same functionality to MetaMask Snap. Also, to learn how transaction simulations work, head over to the Tenderly Dashboard and try simulating transactions.  

How to Build on Base With Tenderly From Day 1


The ecosystem keeps growing, but it keeps scaling too! Today, Base Mainnet is open for everyone. Base is a developer-friendly Layer 2 solution incubated by Coinbase to bring the next billion users on-chain. It’s built to be a home for Coinbase on-chain products, as well as an open ecosystem where anyone can build.

Backed by Optimism’s OP Stack and built as an EVM equivalent, Base brings scalability, security, and stability. It enables you to quickly deploy your existing dapp or start building a new one with essential tools and infrastructure seamlessly integrated. This Layer 2 network also allows you to deploy your dapp at a fraction of the cost and with the possibility to access other chains. 

To start building on Base Mainnet, you can use Tenderly’s full-stack infrastructure throughout your development journey. By providing tools and infrastructural solutions from development to production, Tenderly enables you to focus on building, testing, and deploying your dapp faster. 

Ready to become a Base Builder? Let’s get started!

How to speedrun dapp development on Base with Tenderly

Base is designed to provide easy, secure access to L1 and L2 ecosystems, and serve as a bridge for users to the broader on-chain ecosystem. With Tenderly’s support and guidance, you can speed up your dapp development and start reaping the benefits of Base faster. 

You can use Tenderly’s testing, simulation, and production infrastructure, as well as essential developer tooling, to focus on building a high-performing product on Base. So, forget about piecing every infra component together and wasting your time on endless setups. Here’s how to do it instead:

1. Develop and test in a zero-setup environment with DevNets

Think of DevNets as your private Base network replica, with all assets you need already deployed and unlocked, including public accounts. With an unlimited faucet, reusable YAML templates, and built-in developer tooling, you can quickly start iterating on your dapp logic. You also get compatibility with your favorite frameworks to integrate DevNets into your existing flows. 

How to Build on Base With Tenderly From Day 1
A DevNet environment for developing and testing on Base

So, if you want to build a high-performing dapp on Base, you can use Tenderly DevNets to: 

  1. Spin up your environment in seconds and see exactly how your dapp would behave in production. Iterate on its dapp logic privately, but with all the production data you need and without any performance delays.
  2. Create and integrate reusable YAML testing templates into your flows without adjusting your code. 
  3. Shorten your feedback loops by inspecting bugs in detail with built-in Tenderly Debugger and validating your fixes instantly with Transaction Simulator. 
  4. Analyze and optimize the gas usage of your code with Gas Profiler by breaking it down granularly by function calls. 

2. Use the simulation infrastructure to build a user-friendly dapp

By integrating Tenderly’s simulation infrastructure, you can provide a more value and overall better, more intuitive experience to your users, abstracting away the complexity of interacting with Web3 dapps. You can help your users feel at ease when interacting with Base through your dapp. In return, this will help you build confidence in your product and establish trust with your users. 

With Tenderly’s simulations, your users can: 

  1. Prevent failed transactions and save money on gas fees by previewing transaction outcomes before submitting them to Base.
  2. Understand complex, chained transactions by seeing all transferred assets, emitted events, and state changes. 
  3. Onboard onto your dapp faster and explore its functionalities for free by running a dapp simulation mode. 

3. Deploy through Web3 Gateway and go live fast

Integrating Tenderly Web3 Gateway, a production-ready node, allows you to simulate and send transactions in the same place. You can integrate Tenderly’s Simulation RPC, dry-run users’ transactions, and, if they’re successful, send them to Base. You can even simulate bundled transactions by using tenderly_simulateBundle.

How to Build on Base With Tenderly From Day 1
Tenderly node RPC Builder for the Base network

Additionally, Web3 Gateway brings you a stable and multiregional connection with the Base network. Plus, your dapp can interact with Base up to eight times faster than the industry standard when it comes to read-heavy workloads. 

And aside from offering all the standard APIs, the Tenderly node is fully customizable. It allows you to deploy your custom code within our node using Tenderly Node Extensions. You can create your own custom RPC methods and give your dapp some unique functionalities, improve its scalability, performance, and extensibility, and cater to the unique needs of your users. 

How to Build on Base With Tenderly From Day 1
Testing a Node Extension for Base Mainnet

4. Keep an eye on your dapp actively and respond instantly  

Once your dapp is up and running on the Base network, don’t forget to keep track of what’s going on. To always stay one step ahead, set up an active and automated incident management system with Tenderly: 

  • Use real-time Alerting to receive up-to-date notifications. You can set up alerts for (un)successful transactions, emitted events in specified smart contracts, token transfers, balance changes of a specific address on the Base network, etc. Once your alert is triggered, you receive notifications to your selected destination, including webhooks, email, Discord, Slack, and Telegram. 
How to Build on Base With Tenderly From Day 1
Setting up real-time alerts for Base
  • Respond with custom code automatically with Web3 Actions. Tenderly Web3 Actions can serve as programmable hooks that can respond to specific on-chain events with custom code. You can also choose a Web3 Action as a destination for your alert and have custom code executed automatically as a response to the event that triggered your alert.  
How to Build on Base With Tenderly From Day 1
Creating a Web3 Action for Base Mainnet

Do it all in one place with Tenderly & deploy faster and smarter on Base

The Base Mainnet network unlocks new scaling and usability opportunities for builders who decide to join and contribute to the ecosystem. If you’re ready to start building on Base, Tenderly offers you the infrastructure, tooling, and support you need to do it more efficiently from day one. 

All it takes is to spin up your development environment and you get access to essential developer tooling to get to production faster. Leave the infrastructure to Tenderly and get a head start building a killer dapp on Base. 

Building Dapps on BNB Chain: How to Go Into Production Faster With Tenderly DevNets


Build N Build (BNB) Chain is a comprehensive blockchain ecosystem designed to enable decentralized applications and services through various interconnected layers. Currently, BNB offers a suite of solutions that are high-performance and cost-effective on top of its consensus layer, BNB Smart Chain (BSC). BSC is EVM-compatible, offering multi-chain access through its hubs. On the other hand, BNB Beacon Chain is the staking, voting, and governance layer of the BNB Chain. 

Additionally, BNB Chain and its testnet are one of Tenderly’s supported networks, with 6k+ projects building on BNB using Tenderly. You can use the Tenderly full-stack infrastructure to support each stage of your dapp development lifecycle on BNB Chain. With Tenderly DevNets, you can simplify and speed up the early stages of dapp development and get to production faster. 

So, if you’re building on BNB Chain, you can use a diverse set of tooling, APIs, and support programs to accelerate development and focus more on your product. Let’s see how you can get started with Tenderly DevNets to build innovative, high-performing dapps on BNB Chain.

How to use DevNets to build dapps on BNBChain faster?

Tenderly DevNets are a managed, zero-setup environment for developing and testing your smart contracts. You can use DevNets to spin up a private network with both historical and most recent states of the BNB Chain. DevNets also come with an unlimited faucet, so you don’t have to worry about getting test tokens. 

Additionally, DevNets are complementary to HardHat, Foundry, and Truffle, so you can easily integrate them into your existing development flows. 

Here are a few ways to use DevNets when building on BNB Chain. 

1. Simplify and speed up your local development

With DevNets, you get an isolated environment that can help you speed up local development with faster feedback loops, easier collaboration, and efficient debugging. Despite having a private environment, you still get the most recent production data from BNB Chain, with all public accounts unlocked for further experimentation. 

Building Dapps on BNB Chain: How to Go Into Production Faster With Tenderly DevNets
Creating a DevNet environment for BNB Chain

Once in a Tenderly DevNet, you can set up different templates for the BNB Chain network and preview how your smart contracts would behave if sent on-chain. And if you come across a bug, you can use built-in debugging tooling to quickly resolve any issue: 

  • Inspect bugs in detail with Tenderly Debugger: Don’t go live on BNB Chain with overseen bugs. Instead, use a DevNet to quickly preview your smart contract behavior and identify issues early on. Then, jump into Debugger to inspect your code by individual function calls. 
  • Optimize gas consumption with Gas Profiler: BNB Chain offers low gas fees, but you can make them even lower. See exactly how much gas your contract would consume once deployed on BNB Chain with Gas Profiler. Inspect your code granularly and identify the lines of code you can optimize to reduce gas usage.
  • Preview and validate your fixes with Transaction Simulator: In the last stage of your debugging process, head over to Transaction Simulator to preview the effects of your changes. You can update the source code of your contract or change specific transaction parameters. Once you simulate your transaction, you can see whether your fix is successful and then deploy it to BNB Chain with confidence. 

2. Test your dapp against real-time BNB Chain production data

You can also speed up your testing process with DevNets and go live on BNB Chain faster. You can use a DevNet RPC as your JSON RPC provider. This way, you can test against the most recent BNB Chain data while still in development. 

Building Dapps on BNB Chain: How to Go Into Production Faster With Tenderly DevNets
Connecting with a DevNet RPC

By using a DevNet for testing, you can: 

  • Test complex scenarios by running stateful transaction simulations within a DevNet. 
  • Automate some of your tests with reusable templates and avoid wasting valuable resources on lengthy setups and redeployments. 
  • Control your testing environment with custom RPC methods and run all your tests under identical conditions. 
  • Get unlimited test tokens that you can get directly from the Tenderly Dashboard, through Tenderly Faucet, or with custom RPC methods. 
Building Dapps on BNB Chain: How to Go Into Production Faster With Tenderly DevNets
Using an unlimited faucet for BNB tokens

3. Make collaboration on BNB Chain easier

When developing and testing with DevNets, your smart contracts are completely private. So, you don’t have to worry about exposing sensitive data on a public testnet. However, despite being private, you can still share DevNets with your team to facilitate collaboration when you’re ready to go public. 

Aside from giving your team members access to your project, you can enable the public sharing of both simulated transactions within a DevNet and entire DevNet runs. This means you can turn your DevNet environments into a public resource and share them across your project to showcase different pieces of code and ensure consistency. 

Building Dapps on BNB Chain: How to Go Into Production Faster With Tenderly DevNets
A DevNet overview page for BNB Chain

Plus, you can share them with external collaborators too. Even devs who don’t have a Tenderly account can access a publicly shared DevNet. 

How to make your dapp on the BNB Chain accessible to your users? 

You probably want to build one of the top dapps on BNB Smart Chain, but a way to do it is by putting your users first. With transaction simulations, you can do exactly that – create a user-focused dapp that is easy and intuitive to use. 

Integrating Tenderly’s transaction simulations into your dapp enables your users to preview their transactions before sending them on-chain. You can even set up a simulated playground mode to allow your users to get familiar with your dapp. 

This way, they can:

  • Understand their transactions better in general.
  • See what tokens have been transferred and how much they’ve earned.
  • Prevent sending reverted transactions and avoid paying for gas unnecessarily.
  • Get a deeper insight into transaction behavior and even inspect state changes, emitted events, and gas consumption. 

How to integrate simulations into your dapp

With Tenderly’s simulation infrastructure, you have multiple ways to introduce simulations into your dapp: 

  1. Simulation API that persists simulation data and allows you to share it with your users 
  2. Simulation RPC that enables you to simulate transactions through Tenderly’s production node
  3. Tenderly SDK that allows you to integrate transaction simulations with speed and efficiency. 

How to get support building dapps on BNB Chain

BNB Chain offers different types of support programs providing incentives for easier and faster dapp development. BNB Chain strives to foster a thriving environment, providing dapp developers with essential services, support, and guidance. 

As a builder on BNB Chain, you can apply for diverse tools and services that can facilitate your development journey. You can also participate in the growing BNB Chain ecosystem and give back to the community with open-source solutions as a recognized contributor.

Go live on BNB Chain faster with Tenderly

Supported by numerous BNB Chain Developer Programs and Tenderly’s full-stack infrastructure, you can focus on building a product that will bring value to your users. While DevNets can help you speed up and simplify your local development and testing, Tenderly’s transaction simulations enable you to build trust and confidence with your users. 

Start building dapps smarter and get to production faster!

For additional insights, learn more about BNB Beacon Chain or explore the intricacies of BNB Smart Chain

Team up & Level up: DevNets for Faster Web3 Development


Having a well-organized team that fosters collaboration can help you build an innovative Web3 product and bring more value to your users. But how do you ensure team cohesiveness in the decentralized Web3 world? How much time and effort do you invest in coordinating your team and piecing the resources you need together? And with most of your team scattered across the globe, how do you ensure consistency in your code? 

All of this can be difficult even if your team members are all in the same place. Luckily, transparency, collaboration, and knowledge sharing are embedded in the Web3 community. Teams worldwide work together toward the same goal – realizing the potential of blockchain technology and bringing it to a mainstream audience. 

So, how do you make this easier for everyone involved? Hint: start with a shared resource that facilitates team collaboration, boosts efficiency, and eliminates unnecessary overhead – Tenderly DevNets. 

How to use DevNets to improve team collaboration

Tenderly DevNets are a managed, zero-setup environment for smart contract development and testing. With DevNets, you can make team collaboration easier in a few ways. Let’s dive into each one. 

1. Ensure code consistency by using the same environment

With Tenderly DevNets, you and your team can quickly execute and test your smart contracts against both historical and real-time production data. You get everything you need already deployed to a DevNet, without the need for contract (re)deployments to public testnets. 

And since you all have access to the same development and testing environment, your team members don’t need to recreate the same conditions. This way, you can significantly speed up your internal processes and keep your team aligned. 

With DevNets, your entire team can:

  • Inspect the same smart contract executions, look into issues together, and ensure high code quality and consistency
  • Control your testing environments with custom RPC methods that allow you to top off your test tokens, modify environment states, change blocks, and manipulate other parameters. 
  • Automate the creation of your DevNet environments with reusable templates and fresh network states. 
Team up & Level up: DevNets for Faster Web3 Development

2. Enable comprehensive tx insights while still in development

Aside from exploring executed transactions using Tenderly’s Transaction Trace and Debugger, your team members can also inspect transaction executions during development. Examining transactions within DevNets can provide your team with valuable insights into the underlying smart contract logic. 

Team up & Level up: DevNets for Faster Web3 Development
Inspecting a simulated transaction within a DevNet

By simulating transaction executions within a DevNet environment, your team members can:

  • Preview transaction outcomes against production data while still in development.
  • Quickly experiment with their smart contracts in a safe, forgiving environment. 
  • Play around with different transaction parameters and see what happens.
  • Try out different bug fixes and validate their solutions prior to deploying them. 

As poolpitako, a software engineer at Yearn Finance, explains:

You need to start learning how to read Tenderly before being able to read Etherscan. If a transaction hits Etherscan, that means that it’s already too late and it’s in prod, already executed, or minted. I think the best entry point is there, seeing a simulation of a multisig transaction, seeing what happens, trying to understand it, and playing with the transaction.” 

3. Share individual transactions and entire runs on DevNets

Another simple way to keep everyone on the same page is to share transactions that you simulate within your DevNet environments. And in addition to individual transactions, you can also share entire DevNet runs.

Team up & Level up: DevNets for Faster Web3 Development
Sharing a DevNet development and testing environment publicly

After running simulated transactions to test state-dependent scenarios, you can click the Share button and allow public access to your simulated transactions. This will generate a URL that you can share with your team and external collaborators.

Team up & Level up: DevNets for Faster Web3 Development
A publicly shared Tenderly DevNet

This way, anyone on your team who doesn’t have a Tenderly account, or external collaborators, can explore all the simulated transactions under the same conditions. Plus, they can jump into Debugger to examine potential issues and continue experimenting with the code. 


You can also use Tenderly Sandbox as an in-browser Fork environment for quick example-sharing. Tenderly Sandbox is a prototyping environment that allows you to experiment and execute your smart contracts instantly.

Spinning up a Sandbox runs it against an individual Tenderly Fork, so you and your team get the production data for more than 30 networks. And you can also quickly access all other Tenderly features since Sandbox is fully integrated with Tenderly’s debugging toolkit.

4. Jump into Debugger and guide your team with annotation and prioritization

When it comes to failed transactions, you and your team have immediate access to Tenderly Debugger, where you can inspect transaction execution in detail. You can use DevNets together with Debugger to: 

  • Inspect transactions trace by trace.
  • Explore state changes and emitted events.
  • See which contracts are involved in a transaction.
  • See how much gas transactions spend by a function call.
  • Evaluate complex expressions in a human-readable format. 

Plus, you can also use Debugger’s annotation and prioritization functionality to prioritize and comment on the exact lines of code with in-depth explanations. 

Team up & Level up: DevNets for Faster Web3 Development
Commenting and prioritizing lines of code in Tenderly Debugger

And what about stressful and urgent situations that require a quick and coordinated debugging response?


The annotation and prioritization functionality can help you keep your team organized and focused in time-sensitive war room situations. If a hack or exploit happens, you can guide them by prioritizing the most suspicious lines of code for inspection.

And by leaving comments, you can also provide directions for removing vulnerabilities so you can quickly resolve the underlying cause of the issue.

Ensure team collaboration and contribute to Web3 innovation

Supporting knowledge-sharing and transparency across Web3 starts with your team. By encouraging your team members to collaborate, share knowledge, and provide feedback, you can not only build a cohesive team and a strong product but also support such practices in Web3 development. 

And with the full-stack Tenderly infrastructure, you get a partner to support you as your team grows. With everything in one place from development to production, you can improve your teams’ development flows and facilitate their collaboration. So, start using Tenderly DevNets and empower your team to build innovative Web3 solutions.

How to Make Ethereum Transactions Human-Readable


Even the most experienced Web3 devs can get lost in the technical complexities of managing transactions on the blockchain. Now imagine what this must look like for everyday users who don’t come from technical backgrounds. Confusing? Frustrating? Discouraging? All of this and more? 

So the question for all of us is – how can we make Ethereum transactions more accessible and human-readable? 

With this question in mind, Web3 devs have been implementing different upgrades to make wallets, as the first point of contact with the blockchain, easier and more intuitive to use. And transaction simulations emerged as one of the most promising solutions.

So, let’s explore a few simple, yet powerful ways to make Ethereum transactions human-readable with transaction simulations. Let’s do this! 

How to Make Ethereum Transactions Human-Readable

How to use simulations to make Ethereum transactions human-readable for wallet users

Integrating transaction simulations into wallets is becoming a standard in Web3. It enables wallet users to preview exact transaction outcomes before submitting them on-chain. This way, they can better understand the effects of their transactions, having greater confidence and peace of mind when sending them.

Additionally, enabling transaction simulations in your wallet can help you build confidence in your product too, especially among first-time users. Ultimately, by making users feel at ease when sending transactions, you will also help increase trust in the industry and support mainstream blockchain adoption. 

So, what exactly can you do with transaction simulations to make Ethereum transactions human-readable? 

Show the dollar value of asset transfers

With token values constantly fluctuating, wallet users need to invest additional effort into deciphering how much they’re earning or spending on their assets. So, why not display the actual, real-time dollar value for your users straight away? 

By integrating Tenderly simulations into your wallet, DeFi platform, or DEX, you can show the current dollar value of ERC-20 tokens. This way, your users can fully analyze and understand the financial implications of their transactions, making informed decisions when managing their assets. 

Simplify the process of testing transactions

To make your wallet or DeFi platform accessible even to newcomers in the space, you need to make the process of testing and sending transactions as effortless as possible. And yes, there are ways: 

  • Remove the complexity from running simulations: You can enable your users to run simulations without any technical expertise required. They just need to input the basic transaction data and click Simulate
  • Enable simulation bundling to eliminate unnecessary steps: Sometimes, users need to manage multiple transactions at the same time. For instance, multisignature wallets require you to submit, approve, and send transactions. So, instead of users having to run every simulation separately, you can enable them to run a simulation bundle. 
  • Allow users to try out your dapp without spending any gas: You can even run your entire dapp in simulated demo mode. Your users can activate the demo mode to try out your dapp functionalities and get familiar with token transfers, swaps, etc.

Warn against reverted transactions

Even users coming from a technical background can overlook issues with their transactions. Users can easily submit improperly configured transactions on-chain and pay gas fees only to find out that their transactions have been reverted.

To help your users avoid sending faulty transactions on-chain, make sure to display a clear warning sign in your wallet interface. Safeguarding them against submitting reverted transactions will help save both financial and computational resources.

How to Make Ethereum Transactions Human-Readable

Allow users to inspect simulated transactions

Exposing simulation data in your wallet or dapp enables users to gain a deeper insight into transaction execution. This can be helpful for users who want to learn more about what actually happens when sending transactions. It can also provide Web3 developers with an opportunity to inspect transaction simulations in greater detail. 

To achieve this, you can enable users to open their simulations on Tenderly. Once in the Tenderly Dashboard, they can examine which tokens have been transferred, which state changes have been made, and whether the expected events have been emitted. Plus, they can also get a granular view of how much gas their transactions spend. 

3 Ways to integrate transaction simulations into your wallet 

To make Ethereum transactions understandable to a wider audience, you can integrate Tenderly’s simulation infrastructure. Here are a few ways to introduce transaction simulations into your wallet with Tenderly. 

1. Integrate the Simulation API

An efficient way to simulate transactions and expose the information to your users is to use Tenderly’s Simulation API. Your users will automatically send requests to our Simulation API and get a response, without putting any additional pressure on your team. 

With the Simulation API, you have multiple options to expose simulations to your users: 

  1. Call the Simulation API endpoint to get asset_changes, including exact dollar values. Your request will return comprehensive data on asset changes for ERC-20 and ERC-721 tokens that happened during a transaction. Plus, the dollar value is based on the most recent, real-time on-chain data rather than historical information. 



Integrating Tenderly simulations with MetaMask Snap

  1. Dry-run individual transactions so your users can see their outcomes before sending them on-chain. This way, the request would automatically go to the Simulation API and return a response instantly. 



Simulating transactions on Safe with Tenderly

  1. Introduce Simulation Bundles to simulate multiple transactions consecutively using a single request. When running a simulation bundle, the endpoint receives a single request and simulates the execution of the transactions within the same block. Your users then get a response with the possibility to inspect individual simulations within the bundle. 
How to Make Ethereum Transactions Human-Readable
Simulating a bundle of transactions
  1. Use simulations on Forks to run your dapp in demo mode and enable users to try it out for free. In this case, you need to add a Fork RPC as your JSON-RPC provider.



Running dapp simulation mode on Instadapp with Tenderly

2. Use the Simulation RPC

With Tenderly, you can also use our node as a service to simulate and send transactions in one place. Tenderly Web3 Gateway enables you to simulate your users’ transactions before sending them on-chain. You can then automatically submit them to the blockchain if the simulations get executed successfully. 

Plus, Tenderly Web3 Gateway supports both one-off and bundled simulations: 

  1. tenderly_simulateTransaction performs a single simulation and returns a response. 
  2. tenderly_simulateBundle enables you to group multiple transactions and simulate them one after the other. 

3. Don’t forget the SDK

The Tenderly SDK is another fast and easy way to integrate simulations into your dapp or wallet. It enables you to simulate transactions in two ways

  • Simulate individual transactions by calling simulate_Transaction 
  • Simulate a bundle of transactions by calling simulate_Bundle

Help your users understand Ethereum transactions with simulations

Web3 keeps evolving, yet interacting with the blockchain can be highly confusing, frustrating, and risky. This is especially visible when sending transactions on-chain. So, to help accelerate the adoption of blockchain technology on a global scale, Web3 devs need to make it more accessible to a wider audience. 

And one of the key ways to achieve this is to make Ethereum transactions more understandable and human-readable. Easy, right? Well, it is with Tenderly’s transaction simulations. So, ready to try them out? Start by experimenting with transaction simulations yourself!

How to Use Tenderly to Build Innovative Dapps on Polygon


With more than 2.44B processed transactions and around 6M deployed smart contracts, the Polygon network is one of the most widely used chains in the Web3 space. As an Ethereum scaling solution and an EVM-compatible network, the Polygon protocol offers some important benefits to Web3 developers, including scalability, two-second block time, and high transaction throughput.

To start getting the benefits of building on the Polygon network and further improve the efficiency and performance of your dapp development and on-chain, you can use Tenderly Web3 Gateway, our production node. Web3 Gateway fully supports the Polygon protocol and the standard set of APIs, allowing you to interact with the network uninterruptedly. You can also use it to perform read-heavy operations up to eight times faster than the industry standard.

However, the very nature of the RPC interface in the Web3 space places certain limitations on dapps. So, even with these valuable benefits of the Polygon network, you might still struggle to make RPCs fit your dapp. Until now. 😎

To take full advantage of building innovative dapps on the Polygon blockchain, you shouldn’t be limited by predefined APIs. Instead, use Tenderly Node Extensions to build custom RPC methods for your dapp and bring unique functionalities to your users.

Why build with Node Extensions on Polygon

The Polygon network is EVM-compatible, so you can easily migrate your dapp if you’re just starting out with the Polygon protocol. The chain’s security stems from its network of PoS validators. It offers high scalability, since it relies on multiple sidechains, and high speed, with even up to 10,000 transactions per second running on a sidechain on their internal testnet.

Want to start building with the existing Tenderly RPCs?

With Tenderly Web3 Gateway, you can improve the performance of your dapp. Just use tenderly_simulateTransaction to automatically run a transaction simulation before sending it on-chain.

You can take it a step further by using tenderly_simulateBundle. This RPC method allows you to group and simulate consecutive transactions one after the other using a single call. 

However, using predefined APIs often requires you to build alternative solutions for your dapp. This can prevent you from making the most of the benefits the Polygon blockchain offers. So, why not use Tenderly Node Extensions for some new or not-so-common use cases?

Node Extensions enable you to create and deploy custom RPC methods for your dapp on the Polygon blockchain. This means you can completely customize how your dapp interacts with the Polygon network, optimize its on-chain performance, and even simplify its development.

Want to learn more about the benefits of building a custom RPC interface? Right this way: 👇

How to Use Tenderly to Build Innovative Dapps on Polygon
Why you should build custom RPC methods with Tenderly Node Extensions

How to use Node Extensions to build custom RPCs for your dapp on Polygon

If you want to use Tenderly Node Extensions to build scalable, flexible, and user-friendly dapps on the Polygon network, here’s how to start:

  • Create your own custom Node Extension: The greatest perk of Node Extensions is that you can build your own, completely from scratch. So, no matter the nature of your dapp on the Polygon network, you can use JavaScript or TypeScript to write your custom RPC methods that you can then integrate into your dapp UI or backend. Cool, right? 🤯
  • Support your development with a ready-made extension: Our Node Extension Library contains multiple ready-to-use Node Extensions sourced from the community of Web3 builders. Aside from using one of them as a starting point for your own extension, you also have a ready-made Node Extension from the Polygon protocol – Block Author Extension.

Which library Node Extensions to use?

Ready to start by exploring our open-source GitHub library? Here are some of the Node Extensions you can use:

1. Block Author Extension from Polygon

The Block Author Extension from Polygon is a ready-made extension that you can activate directly in the Tenderly Dashboard. This extension computes the author of a block (a.k.a. coinbase) of the Polygon network.

2. Simulate Mempool TX Extension

If you want to know how a pending transaction will play out while it’s still in the Polygon mempool, just use the Simulate Mempool TX Extension. You can use the results to improve your development and testing processes, optimize gas usage, and avoid transaction failures or unwanted consequences.

3. Simulate Send TX Extension

Using this Tenderly Node Extension, you can send, simulate, and submit signed transactions to the Polygon network. The Simulate Send TX Extension allows you to ensure a transaction will execute successfully before being executed on the network. This way, you can help your dapp users avoid errors, minimize risks, and protect their funds when using your dapp.

Start building innovative dapps on Polygon with Tenderly

Building on the Polygon network offers some major benefits both to you and your users. But to truly make the most of these benefits, you shouldn’t be limited by standard APIs. Instead, you can build some unique functionalities into your dapp using a custom RPC interface tailored to your and your users’ needs.

And the best way to get started is to use Tenderly Node Extensions to build custom RPCs. Improve your dapp performance, speed, and scalability while also ensuring excellent user experience every step of the way!

A Developers’ Guide to Building Smarter on Boba Network With Tenderly


The Tenderly team is happy to announce that we completed our integration with Boba Network, an industry-known Layer 2 solution. Tenderly supports Boba Network on four chains: Ethereum, Binance, Moonbeam, and Avalanche. Web3 developers can now use the all-in-one Tenderly platform to build on Boba Network and contribute to the efforts to scale Ethereum.

Boba Network is an optimistic-based multichain Layer 2 scaling solution that aims to unlock the potential of rollup technology and enable more flexible blockchain communication. The protocol is fully compatible with EVM-based tools and has multichain support for Avalanche, BNB, Moonbeam and Fantom. Boba Network is powered by Hybrid Compute technology that brings the power of Web2 on-chain.

Now with Tenderly, Web3 developers have all the development, observability, and infrastructure tools they need to build even smarter on Boba Network. Additionally, this integration helps us further support making Ethereum scalable and onboard new Web3 users to the blockchain.

What to expect when building on Boba Network

The Boba Network is a compute-focused Layer 2 scaling solution. It’s almost identical to Ethereum, enabling Web3 developers to easily build on or bridge to Boba Network. Here are some of the advantages Boba Network offers:

  • Hybrid Compute: Boba Network uses Hybrid Compute technology to connect Web3 with Web2. As a Hybrid Compute platform, it enables you to make external Web2 API calls and gather real-world data. You can then leverage off-chain compute and real-world data to deliver enriched experiences to decentralized applications.

    Hybrid Compute is a general-purpose pipe between Web3 systems and Web2 computers. It operates on a pull basis, unlike oracle services that use push commands. So, ths system provides data only when requested, which significantly reduces gas consumption. Plus, it pulls and retrieves data atomically within the same transaction.

  • EVM compatibility and scalability: Boba Network is based on the optimistic rollup architecture, which makes it highly scalable. Plus, since it’s EVM-compatible, you can port or build smart contracts with ease.
  • Multichain support: Boba Network supports a range of L1 networks, so you can choose networks other than Ethereum as a settlement layer for your dapps. You can choose $BOBA or some other L1-native cryptocurrency to pay for fees on the network.
  • High transaction throughput and finality: Since Boba Network uses optimistic rollups, it processes transaction batches on the network and then sends them to the selected L1. In return, this offers high transaction speed and 40-100x lower gas fees than on the respective Layer 1.

    Additionally, Boba runs a Sequencer node that orders transactions quickly, bringing fast transaction confirmation times and finality.

  • An L1-L2 swap system: You can move funds across different chains using Boba’s swap-based system. The swaps are based on liquidity pools that gather small swap fees and distribute them among liquidity providers. There are no delays when bridging funds between chains on Boba Network.

How Tenderly brings security and predictability to Boba Network

As a smart contract developer, you can use Tenderly’s Debugger, Gas Profiler, Transaction Simulator, Forks, Alerting, Web3 Actions, and other functionalities to build, optimize, monitor, and operate reliable smart contracts.

However, aside from improving your development, testing, and monitoring processes, Tenderly allows you to bring security and predictability to other applications on Boba Network.

Develop low gas-consuming smart contracts

Since Boba Network is EVM-compatible, you can deploy smart contracts to the network just as you do on Ethereum. Supported by the already familiar Tenderly tools, you can ensure smart contract correctness before deployment to Boba Network.

On Tenderly, you get a detailed transaction overview so you can analyze executed or simulated transactions.

A Developers’ Guide to Building Smarter on Boba Network With Tenderly
A Boba transaction overview on Tenderly

By using Tenderly’s Debugger and Transaction Simulator, you can catch a bug early on, apply a fix, and then simulate it to ensure it resolves the problem successfully. Plus, Gas Profiler allows you to analyze smart contract gas consumption down to individual functions. So, you can optimize your contract’s code and reduce its gas usage prior to deployment.

Preview withdrawal execution

Boba Network allows you to bridge tokens and data between L1 and L2 using the Standard Token Bridge. The bridge allows you to move and exit assets quickly, with waiting times varying from several hours to a few minutes depending on the transaction number. If you decide to withdraw your funds, you just need to trigger the withdrawal functions.

However, once triggered, you cannot cancel your withdrawals. So, to make sure you entered the right transaction parameters, you can run a simulation using Tenderly’s Transaction Simulator. This way, you can ensure your token withdrawal goes as planned before actually executing it.

A Developers’ Guide to Building Smarter on Boba Network With Tenderly
Running a transaction simulation on Boba

Strengthen your monitoring process

To stay up to date with balance or other smart contract changes, you can use Tenderly Alerting. By setting up alerts on Tenderly, you can receive notifications about balance changes on specific addresses, ERC20 token transfers, events emitted in your smart contracts, and other relevant changes on Boba Network.

A Developers’ Guide to Building Smarter on Boba Network With Tenderly
Creating an alert for successful transactions on Boba

Plus, you can get updates directly to your email, Slack, or Telegram, set up webhook endpoints, or go with some other channel. This way, you can act as soon as something of interest happens on Boba Network, without having to manually check for network updates.

Automate custom responses to off-chain events

As mentioned, Boba allows you to connect Web2 and Web3 systems using their Hybrid Compute technology. Turing is a Hybrid Compute component that allows your smart contracts to interact with the outside world. To ensure these smart contracts execute properly, you can first use Tenderly simulations to test their communication with a Web2 endpoint.

To take it a step further, you can connect this system with Tenderly Web3 Actions. As a serverless backend, Web3 Actions can execute your custom code in response to pre-defined triggers relevant to your project.

A Developers’ Guide to Building Smarter on Boba Network With Tenderly
Creating a Web3 Action on Boba

So, by using Hybrid Compute to connect off-chain APIs to Web3 Actions, you can automate your responses to specific events. Once triggered, Tenderly Web3 Actions will execute your custom logic automatically.

Secure governance voting

The Boba DAO handles the governance of the network using $BOBA, its native token. Following a set of governance guidelines, $BOBA token holders can vote on governance proposals and suggest improvements for the network.

When voting on governance proposals, token holders can turn to Tenderly’s simulations. By integrating with Simulation API, Boba governance voters can preview proposal effects before submitting their votes.

Specifically, Tenderly’s Simulation Bundles allow you to run a bundle of simulations using a single request. The API response returns the information on each simulated transaction in the bundle. This way, you can see how a proposal executes, including individual transactions, and cancel your vote in the event of any undesired results.

Scale with Boba Network, build with Tenderly

Tenderly continues to support Web3 developers in their efforts to build innovative products on the blockchain. Our integration with Boba Network allows us to expand the list of networks and, therefore, possibilities for smart contract engineers.

With our all-in-one Web3 development platform, you can build reliable smart contracts on Boba Network, eliminate avoidable risks, and enjoy a frictionless experience along the way. Create a free account with Tenderly and start building smarter on Boba Network.

How to Secure Multisig Wallets With Transaction Simulations


As smart contracts that require multiple signatures for transaction execution, multisig wallets have become a widely used security feature, especially among DeFi companies and DAOs. However, although they offer a high level of security and minimize the risk of unauthorized transactions, they’re not without challenges.

Multisig transactions can be complex for stakeholders who don’t come from a technical background. Even multisig owners who have technical experience often don’t have enough time to go over transactions in detail. So, an exploit can easily go unnoticed and multisig owners can approve a malicious act without even knowing it.

But what if you could see if that complex chain of transactions will execute as expected? What if you could show what would happen to anyone involved in the process? And what if you could, wait for it…, simulate complex transactions in a simple and straightforward way?

Why use transaction simulations in a multisig?

Simulating transactions and viewing their outcomes prior to submitting them on-chain helps avoid financial losses caused by failed, incorrect, or malicious transactions. This further helps eliminate anxiety and frustration among multisig users. And Tenderly enables Web3 developers to offer these and many other benefits by integrating Transaction Simulator into their multisig wallets.

By introducing Transaction Simulator, Web3 engineers can build multisig wallets that prioritize users and the safety of their funds. With Tenderly’s Simulation Bundles, multisig users can simulate a bundle of sequential transactions by clicking a single button. In return, they get results for each transaction in the bundle so they can see exactly how they execute.

The benefits of simulating transactions in a multisig

So, integrating this soon-to-be essential functionality into a multisig brings essential benefits:

  • Preventing errors and eliminating risks: By simulating multisig transactions, you can instantly see if they execute as expected. And if you uncover a bug, you can take action before your transactions even hit the blockchain (at which point, it’s time for risk mitigation, not prevention).
  • Reducing costs: By detecting bugs in code or mistakes in transaction parameters, you avoid paying gas fees for failed transactions. Plus, by using the tenderly_simulateBundle request, a multisig can show exactly how much gas each transaction in a bundle will spend and, therefore, the entire bundle. What does this mean? No underpaying for gas either!
  • Increasing security: A rogue individual or company employee can submit a malicious transaction with a faulty description to a multisig. However, by clicking a simple “simulate transaction” button, you can see the effects of the transaction you’re approving. This way, you can avoid accidentally authorizing a malicious act.
  • Improving user experience: By removing anxiety and guesswork for multisig users, transaction simulations can help establish trust and improve users’ overall experience when using a multisignature wallet.

    Plus, users with less technical knowledge and experience can be more confident when approving transactions. And the simplicity of using a multisig, or any other dapp for that matter, can be a decisive factor for users when choosing their provider.

  • Simplifying and securing the decision-making process: By using simulations when voting on governance proposals, voters can see the effects of a proposal before passing their votes to a multisig. Additionally, stakeholders who don’t have a technical background can better understand the proposal execution by seeing the simulation on Tenderly.
  • Increasing trust in the blockchain: Finally, simulating multisig transactions can help build trust in the industry. With minimized risks and greater transparency, users will keep coming back to dapps that prioritize security, as well as the blockchain in general.

Who benefits from simulations in a multisig?

So, yes, there are invaluable benefits to integrating this simple (on the user-facing side at least) functionality into multisig wallets. But then a question arises – who benefits from this integration?

We’re glad you asked! Everyone benefits from transaction simulations, including:

  • Web3 devs who are able to build better, user-friendlier multisignature wallets that users will keep coming back to. Plus, Tenderly offers several simulation methods, providing Web3 developers with flexibility depending on the requirements of their projects.
  • Individual users who want to have greater control over their assets through multisigs and gain a better understanding of what’s going on with their transactions.
  • Companies and corporations that want to prevent unauthorized transactions of company assets and eliminate risks that could cost them and their clients.
  • Governance voters who want to bring security and predictability to the voting process. Simulations enable them to preview proposal outcomes and verify their impact before passing the proposal.
  • A wider blockchain community that’s still evolving and gaining trust in the technology. Transaction simulations bring predictability and security to the blockchain, eliminating hesitation and anxiety among less technical users.

How to secure your multisig with transaction simulations

Okay, so far, we’ve been discussing the user-facing side and what simulations mean for multisig owners. But what’s happening in the background? How do you actually integrate simulations into a multisig wallet?

With Tenderly, you can choose between two options:

1. Simulation RPC: This method allows you to simulate transactions through Tenderly Web3 Gateway, a super fast production node. By integrating Simulation RPC into your multisig wallet, you can use it for more than just transaction simulations.

You can use the same RPC to send transactions after simulating them, as well as submit read calls and check balances. Plus, you can offer the same information to multisig wallet users.

2. Simulation API: Integrating Tenderly Transaction Simulator through API brings you greater flexibility with the endpoint and enables you to persist simulation data on Tenderly. And with the simulation data persisted, you can expose it to multisig users.

This way, if multisig owners want to look into executed transactions in greater detail, they can open them on Tenderly. There, they can take a look at the changes simulated transactions made, emitted events, state changes, and other information about their execution.

Simulations in a bundle

Both Simulation API and Simulation RPC support simulation bundles that consist of transaction arrays. Being able to simulate an entire bundle of transactions is particularly useful in multisigs since they involve multiple transactions. Multisigs require passing the first transaction (the one you wish to execute), the required number of signatures for its execution, and the execution of the first transaction.

With a single tenderly_simulateBundle request, you can test this entire flow. Both Simulation API and RPC will run the execution of these simulations against a simulated Tenderly blockchain environment. Once you run the simulation, you will receive the results for each transaction in the bundle so you can analyze their execution. And on the user-facing side, multisig owners just need to click one button – simulate. ⏯️

How Safe integrates multisig transaction simulations

One of the key players in DeFi is already familiar with the advantages of integrating simulations into multisig wallets – Safe. Safe offers multisignature wallet solutions to both individuals and companies.

By creating a safe on their platform, you’re actually creating a proxy contract that executes your multisig transactions. You’re able to add as many multisig owners as you’d like and set the required number of signatures for the execution of transactions.

Once your wallet is up and running, head over to Transaction Builder to start sending transactions. Fill in the required details for each transaction you want to send. Once done, click Create Batch so you can execute all transactions at once.

How to Secure Multisig Wallets With Transaction Simulations
Filling in tx details in Safe’s Transaction Builder

However, before actually executing your transaction batch, Safe allows you to preview the outcome by clicking Simulate. This will send a request to Tenderly’s Simulation API that runs your transactions against a simulated blockchain environment.

How to Secure Multisig Wallets With Transaction Simulations
Simulating a transaction batch in Safe’s Transaction Builder

Almost instantly, you’ll receive the results of your simulated transactions. So, instead of blindly sending these transactions, you can see exactly what would happen and cancel the execution should anything go wrong.

How to Secure Multisig Wallets With Transaction Simulations
Failed transaction simulation in Safe’s Transaction Builder

Finally, since Safe uses Simulation API, they’re persisting the data of simulated transactions and can show it to their users. So, you can open failed transactions on Tenderly and examine exactly what went wrong.

How to Secure Multisig Wallets With Transaction Simulations
Examining a failed tx simulation on Tenderly

Here’s also a short video of simulating transactions in a Safe multisig:



Simulate then sign a multisig with high security by design

Transaction simulations are on their way to becoming a must-have feature in multisig wallets. Given the numerous benefits they offer and the level of security they bring, simulations will soon become the new standard for establishing greater control over multisig assets.

By integrating with Tenderly’s Transaction Simulator, you can start building next-gen multisigs now. With Tenderly’s support, you can remove the complexity and anxiety associated with the execution of multisig transactions and build a multisig wallet your users will keep coming back to. Set up an account with Tenderly and start today!