Links
📣

General Info

Learn all about the Tenderly platform and how it provides a fully integrated Web3 developer experience. Get an overview of Tenderly’s essential development, observability, and infrastructure tools.
​Tenderly is an all-in-one Web3 development platform that accelerates smart contract development and provides a fully integrated developer experience. It combines in-depth debugging tools with observability and blockchain infrastructure.
Web3 developers can use the Tenderly platform to build, test, monitor, and operate smart contracts in one place. The platform covers every aspect of smart contract development, from inception and prototyping to production monitoring and on-chain usage.
All Tenderly tools are fully integrated, eliminate development fragmentation, and ensure a unified experience for Web3 developers. They fall into three main categories:
  • Development
  • Observability
  • Infrastructure 3.0
Learn more about each category and how you can benefit from Tenderly tools.

🚀 Infrastructure 3.0

Tenderly Infrastructure 3.0 brings together integral building blocks for smart contract integration and blockchain interaction. This category gives you fast and easy blockchain access with Tenderly Web3 Gateway. It also includes Tenderly Web3 Actions that give you more control over your contracts’ on-chain usage. Finally, Tenderly APIs are also part of the core infrastructure, enabling workflow automation and easy integration.

Tenderly Web3 Gateway

Tenderly Web3 Gateway is a production node that offers reliable, fast, and consistent access to the blockchain. It supports the standard JSON-RPC interface and custom-built endpoints thanks to its unique architecture.
Use the Tenderly node to:
  • Perform read-heavy workloads up to eight times faster.
  • Read, stream, and analyze blockchain data with 100% consistency.
  • Build your own custom node abstraction by writing your own RPC methods using Node Extensions.
  • Eliminate the node infrastructure overhead and focus on building your dapps.
Additional resources:

Simulation API

Tenderly Simulation API enables you to run transaction simulations programmatically. Integrate Transaction Simulator into your workflow and fork any Tenderly-supported network. This way, you can automate your development process and boost team efficiency. For instance, you can use Simulation API to integrate a testing environment and run batched simulations for a more efficient testing process.
Then, you can stage a QA environment for your dapp so you can complete end-to-end testing before deploying it on-chain. To enable your users to try out your dapp for free, just use Simulation API to run your dapp in demo mode.
Once your dapp is live on-chain, you can use Simulation API to improve its UX. Simply allow your users to dry-run transactions and execute them with confidence.
Integrate with Simulation API to:
  • Expose Transaction Simulator to your dapp users and enable them to validate transactions directly from your dapp.
  • Deliver more value faster and eliminate guesswork and anxiety for your users.
  • Simulate DAO governance proposals to generate reports and preview their effects.
  • Automate your development, testing, and troubleshooting processes to eliminate manual work for your team.
Additional resources:

Tenderly Web3 Actions

Tenderly Web3 Actions are a low-setup, low-maintenance, and low-cost automated serverless backend for your dapps. They can serve as programmable hooks for relevant on-chain or off-chain events.
A customizable Tenderly Web3 Action enables you to:
  • Build active monitoring and automate custom code responses to on-chain or off-chain events.
  • Combine Web3 Actions with Alerting to create new alert-response patterns and stay on top of relevant on-chain changes.
  • Connect your smart contracts with on-chain events, dapp frontends, APIs, and other services.
  • Improve dapp UX and interactivity by gathering and sharing in-depth information through notifications.
Additional resources:

Tenderly SDK

The Tenderly SDK is a TypeScript library built for efficient blockchain development, integrating with Tenderly's robust tools.
Features:
  • Transaction Simulator: Test transaction outcomes before deploying them to the blockchain.
  • Transaction Simulation Bundles: Simulate multiple transactions as a bundle for comprehensive testing.
  • Contract & wallet management: Add, update, and remove contracts in your Tenderly project.
  • Smart contract verification: Verify your smart contracts' integrity directly from your code.

🏗️ Development

Tenderly’s development tools enable you to speed up and simplify smart contract development. They provide the necessary support for debugging, testing, and optimizing your smart contracts. You can use them to build smart contracts on more than 20 Tenderly-supported networks.

Sandbox

Tenderly Sandbox is a sharable zero-setup prototyping environment for Solidity developers. As an in-browser editor, it helps you eliminate the lengthy setup part of Web3 development. Sandbox also combines Solidity and JavaScript, so it’s an easy entry point for Web3 newcomers.
Set up your own Tenderly Sandbox to:
  • Deploy and run your smart contracts on a Tenderly Fork almost instantly without using a testnet.
  • Get extensive data on smart contract execution with a detailed output, list of executed transactions, and other information available in the Tenderly Dashboard.
  • Debug executed transactions quickly and easily by opening Tenderly Debugger directly from your Sandbox environment.
  • Share your work with other engineers, demonstrate protocol integration, and clone others’ work to test your own solutions.
Additional resources:

Tenderly Debugger

Tenderly Debugger is a user-friendly tool for streamlining your debugging process during development and when troubleshooting transactions in production. This tool allows you to identify the exact lines of code causing a bug. It also eliminates the need for manual decoding, speeding up the entire process.
With Tenderly Debugger, you can:
  • Inspect, troubleshoot, and fix exact lines of code to speed up and simplify debugging.
  • Filter internal and external calls to identify suspicious activity in the event of hacks and exploits.
  • Trace transaction execution and use filters such as opcode, state variables, and functions for in-depth information.
  • ​Use Evaluate Expression as a part of Advanced Debugger to evaluate both simple and complex transaction expressions.
  • ​Use State Inspector to analyze decoded state changes and state variables of your smart contract in a granular view to understand how it behaves in production.
  • ​Use Debugger Chrome Extension to open transactions in Tenderly Debugger directly from your browser.
Additional resources:

Gas Profiler

Gas Profiler gives you an in-depth insight into how your smart contract uses gas per function call. It enables you to analyze executed transactions or optimize your code while still in development.
To reduce smart contract gas consumption, use Gas Profiler to:
  • Get a granular gas usage breakdown and analyze how each function call spends gas.
  • Identify gas-intensive lines of code that you can further optimize using other Tenderly tools.
  • Apply some of the best coding practices to reduce the gas cost of your transactions before sending them on-chain.
Additional resources:

Transaction Simulator

Transaction Simulator allows you to preview transactions directly from the Tenderly Dashboard before sending them on-chain. You can use this tool to run simulations using the most recent or historical blockchain data. It enables you to play out transaction outcomes, minimize the risk of errors, and eliminate unnecessary costs.
You can use this feature to simulate transaction execution with updated contract source code or different parameters, including tx indexes, block number, value, gas, and addresses.
By simulating transactions, you can:
  • Try out your smart contracts during development and identify potential issues early on, without deploying to a testnet.
  • Test and validate smart contract bug fixes or upgrades to ensure code correctness both during development and in production.
  • Replay failed transactions to identify the cause of a problem and gain a deeper understanding of their execution.
  • Simulate the expected outcome of pending transactions and optimize gas usage for all your transactions.
Additional resources:

Tenderly DevNets

With DevNets, you can swiftly build, iterate, and debug your blockchain applications in an isolated environment with Mainnet data. They empower you to conduct extensive testing of smart contracts, manipulate contract states in real time, and access Ether effortlessly for transactions. Using DevNets, you can streamline your development workflow, ensure the robustness of your application, and expedite the overall development process. With DevNets, you can:
  • Deploy, test, and debug your smart contracts using tools such as Debugger, Gas Profiler, Call Trace, and other Tenderly features.
  • Access Mainnet data, including contracts code, contract state alongside Ether, and token balances.
  • Re-simulate transactions and analyze their execution.
  • Utilize custom RPCs to change state, obtain Ether, etc.
  • Debug not only transactions but also eth_call and eth_estimateGas.
  • Create a fully-featured blockchain environment in seconds.
  • Integrate DevNets in your day-to-day development and CI pipelines.
Additional resources:

Tenderly Forks

Tenderly Forks allow you to create a temporary fork of a Tenderly-supported network and use it for development, testing, and simulating complex scenarios. You can deploy, test, and simulate smart contracts on a Fork without submitting changes on-chain. You can also fully customize your Fork environment by adjusting different parameters.
Use a Tenderly Fork to:
  • Set up your own private development environment and control who has access to your smart contracts while still in progress.
  • Chain multiple transaction simulations to preview complex scenarios against the most recent or historical network data.
  • Run one or more tests simultaneously either from the Tenderly Dashboard or your local environment by using a Fork RPC URL.
  • Share your test results with team members and keep everyone aligned to facilitate collaboration and ensure consistency.
Additional resources:

🔍 Observability

With Tenderly’s observability stack, you have greater visibility into blockchain data. You can use it to add specific wallets and contracts, track relevant metrics, and stay up to date with the on-chain usage of your smart contracts. This stack also allows you to identify and resolve potential issues quickly thanks to having easily accessible and up-to-date blockchain data.

Transaction Filtering

Transaction Filtering gives you a fast and easy way to navigate through all transactions in the Transaction Overview section. Simply use relevant parameters and pinpoint the transactions relevant to your project. This way, the transaction data is more accessible and you can react quickly in time-sensitive situations.

By using this functionality, you can:

  • Sort and group transactions to explore and analyze robust data more easily.
  • Filter transactions by their status, relevant network, date range, or other relevant parameters.
  • Use highly specific filters such as pinpointing failed internal transactions sent to your smart contract.

Alerting

Alerting enables you to receive real-time updates whenever something of interest happens on the blockchain. You can set up customizable triggers for your alerts by adjusting different parameters. This way, you can stay up-to-date with relevant on-chain changes, security threats, or any other unexpected behavior.
Set up an alert to:
  • Receive real-time notifications to stay up to date with events involving your smart contracts or wallets.
  • Customize your notification triggers to include specific data, including state changes, emitted events, specific function calls, and others.
  • Configure alert destinations and get notifications directly to a webhook destination or your email, Slack, Discord, Telegram, or some other channel.
Additional resources:

Smart Contract Analytics

Tenderly Analytics gives you insight into your smart contract usage and relevant on-chain data. You can use it to extract and visualize in-depth, real-time blockchain data thanks to the unique way Tenderly interacts with the blockchain. You can also create custom graphs and use them to bring a depth of information to both your team and your users.
Tenderly Analytics enables you to:
  • Visualize and analyze the behavior of your smart contracts to spot patterns and gain a deeper insight into transaction data.
  • Track metrics and trends important to your project and identify specific usage trends.
  • Use custom queries to request complex on-chain data and even expose it to your users through API integration.

Tenderly in War Rooms

The all-in-one Tenderly development platform provides a structured framework for mitigating hacks and exploits. Use the Tenderly in War Rooms aid kit to deal with time-sensitive situations quickly and efficiently. The war room aid kit includes the following Debugger functionalities:
  • Call Trace: Quickly navigate through internal and external calls in the Function Trace. Filter out external calls to detect potential vulnerabilities of the exploited and identify suspicious behavior.
  • Evaluate Expression: Speed up exploit resolution by quickly inspecting specific parts of code in a human-readable format. Evaluate code functions, global and local variables, and simple and complex expressions to identify contract vulnerabilities quickly.
  • Annotation & Prioritization: Use the Prioritization feature to flag specific lines of code and set different levels of priority. Then, use Annotation to leave comments for your team or yourself, providing direction and reminders for debugging.
Additional resources:
To enable all the functionalities of the all-in-one Tenderly platform, you need to complete the smart contract verification process.

Contract Verification

Smart contract verification allows you to enable Tenderly Debugger, Transaction Simulator, Web3 Actions, and other Tenderly features. It also helps you ensure that the all-in-one Tenderly platform works seamlessly with your smart contracts.
In Tenderly, you can choose among several methods of verification and get different levels of control, visibility, and flexibility. You can also opt for public or private verification depending on whether you’re ready to share your contracts with other Tenderly users.
Additional resources: