https://blog.tenderly.co/preview-transactions-in-metamask-with-tenderly-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. 

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. 

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.  

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.  

https://blog.tenderly.co/how-to-build-on-base-network-with-tenderly/

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. 

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.

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. 

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. 

• 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.  

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. 

https://blog.tenderly.co/how-to-build-bnb-chain-dapps-using-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. 

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. 

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. 

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. 

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. 

https://blog.tenderly.co/how-to-use-devnets-to-improve-team-collaboration/

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. 

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. 

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.

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.

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. 

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. 

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

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.

https://blog.tenderly.co/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 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.

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. 

2. 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. 

3. 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. 

4. 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.

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!

https://blog.tenderly.co/building-innovative-dapps-on-polygon-with-tenderly/

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.

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 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!