How Velvet Capital Uses DevNets on Their Road to Omni-Chain Asset Management

Velvet Capital is a DeFi asset management infrastructure for crypto hedge funds and asset managers. Striving to bring fund management on-chain, their team of developers wants to help fund managers transition from CeFi to mitigate counterparty risks and ensure full DeFi transparency. 

Using the Velvet Capital operating system, investors and asset managers have control over their funds and can launch DeFi products. Then, Velvet Capital users can invest in those products. And since their asset management platform is on-chain, users have complete insight into what’s happening with their assets. The Velvet Capital team explains:

“The reason why we started building Velvet Capital is that we saw a lot of people getting wrecked with centralized platforms. So, our mission is to bring fund management on-chain as much as possible because we believe that’s where it’s supposed to be!”

However, given the complexity of their product and the nature of DeFi, the Velvet Capital development team employs rigorous and multifaceted testing procedures that involve Tenderly DevNets. Such extensive testing allows them to build a professional-grade product that inspires trust in their users while preserving their security.

The modular layers of the Velvet Capital infrastructure

Asset managers and investors can use Velvet Capital as an on-chain portfolio management or execution management system. Using Velvet Capital, asset managers can set up vaults and adjust different parameters, including vault strategy descriptions, minimum and maximum deposited amounts, and whitelisted users. 

Once they set up their funds, Velvet Capital users can trade assets across supported protocols. They can execute different DeFi strategies, including asset lending, liquid staking, and adding liquidity into AMMs.

Aggregating various DeFi protocols, the Velvet Capital team strives to provide superior on-chain trade execution and capital efficiency to their users. To achieve this, the Velvet Capital asset management system brings together multiple components. Their architecture is modular and consists of: 

  • Strategy modules that enable asset managers to execute different DeFi strategies and the Velvet Capital team to create automated strategies. 
  • Fee modules that entail different types of fees that asset managers charge their users.
  • Integration modules that allow them to integrate different DeFi products, such as 0x and 1inch, and ensure they work properly. 
  • Oracle modules that ensure the system has relevant, accurate, and up-to-date data.
  • Indexing module that keeps track of user interactions. 

Since Velvet Capital’s architecture is modular, the team needs to build and test each component of their complex system. 

Preserving the integrity of modular infrastructure

During their extensive internal testing process, the Velvet Capital developers write different types of tests. However, since their system involves multiple DeFi protocols and products, these integrations bring a lot of intricacies to their testing procedures. 

At first, the team used multiple tools, including Hardhat, Remix, and Truffle, to debug issues they came across during testing. However, they had limited insights into the entire flow of their smart contracts.  

While the Velvet Capital team first started using Tenderly for debugging and understanding failed transactions with Transaction Simulator, they soon implemented Tenderly DevNets. Using DevNets, a private, real-time replica of a given network, the Velvet Capital team managed to simplify and automate their entire testing process. As the Velvet Capital team says: 

“DevNets are a very useful tool, not only for developers but for product owners as well.”

Using DevNets to test real-world scenarios 

Having integrated DevNets into their internal testing, the Velvet Capital developers can: 

  • Spin up a private development and testing environment that’s based on the production data of BnB Chain and Arbitrum, the two currently supported networks. 
  • Deploy and test any smart contract interaction against mainnet data to ensure their protocol integrations work as expected. 
  • Simulate transactions in a customizable environment to play out complex strategy scenarios and ensure their proper execution. 
  • Integrate DevNet environments with their frontend to try out different real-world scenarios, try to “hack” their own contracts, and see what would happen. 
  • Automate their testing with customizable YAML templates and override on-chain data with custom values. 
  • Inspect and debug problems quickly and in-depth right from their development and testing environment using Tenderly Debugger and Transaction Simulator.

Want to learn more about Tenderly DevNets? Watch this overview video:



Building toward omni-chain functionalities

As the Velvet Capital team continues to build their product, their goal is to create a professional toolset that would allow users to create and manage their DeFi portfolios with omni-chain functionalities. The team first plans to tackle feature expansion, integrate more DeFi protocols, and add more advanced functionalities such as derivative trading. 

Following the feature expansion, the Velvet Protocol developers will work toward chain expansion. They’ll add all major EVM chains, such as Ethereum Mainnet, Optimism, and Polygon. This chain expansion is their road toward enabling omni-chain fund management, lowering cross-chain barriers for their users. 

Tenderly DevNets will continue to be an integral part of their development and testing processes. Since DevNets support more than 30 EVM networks, the Velvet Capital team can test their integrations against both historical and recent network states. 

And the team advises everyone to do the same – explore DevNets and test out different scenarios for valuable insights. So, give DevNets a try and start building your products faster. 

DevNets Resource Hub

DevNets Resource Hub

Kickstart your dapp development journey on DevNets in no time. This page provides all the essential resources you need to set up your development environment on DevNets, customize it, and integrate it with your existing projects.

DevNets Resource Hub

Why develop on DevNets?

DevNets offers a managed, zero-setup development environment specifically designed for smart contracts. With built-in debugging and testing tools, it integrates seamlessly into your existing Hardhat, Foundry, or Truffle projects.

  • Isolated environment

  • Mainnet data replica

  • Network customization

  • Reusable network templates

  • 10 pre-loaded test accounts

  • Millisecond TX execution

DevNets Resource Hub

Supported across
30+ networks

Build and test your dapps using production data. Execute transactions and deploy your code on an exact replica of the latest state of your selected network.

Explore supported networks

DevNets toolset

Harness the power of Tenderly’s advanced development, testing, and debugging tools right in your local environment.

DevNets Resource Hub

Visual Debugger

Catch and fix bugs in your contracts and understand failing transactions at a glance.

DevNets Resource Hub


Leave comments on any line of code and get your entire team involved in debugging.

DevNets Resource Hub

Transaction Simulator

Dry-run transactions and edit the contract source to ensure your fixes work as intended.

DevNets Resource Hub

Gas Profiler

Get precise insights into how each function in your code consumes gas and how much.

DevNets Resource Hub

Transaction Trace

Understand the inner workings of your code with detailed insights into TX execution.

DevNets Resource Hub

Private block explorer

Explore and track all transactions executed in your environment in one place.

DevNets Resource Hub

Public sharing

Share your transaction runs and environment with your colleagues or the public.

DevNets Resource Hub

Unlimited faucet

Change or top up the balance on any of the accounts on the network fork.

Stay in the loop with DevNet updates

You’ll receive updates only related to new DevNet features and improvements. Or keep an eye on our Changelog to stay up-to-date with the latest releases from Tenderly.

How to use DevNets

Whether your developing contracts locally or need a quick way to automate testing, DevNets fit seamlessly into your existing workflows.

Contract development

DevNets enhances contract development by offering rapid testing without public testnet latency, complete network customization, utmost privacy, independence from acquiring testnet ETH, and seamless integration with Tenderly’s toolset.

Read the docs

Continuous integration

Integrating DevNet into your CI provides an isolated and automated testing environment with efficient debugging, ensuring code accuracy, minimizing setup time, accessing up-to-date chain states, and optimizing costs and resources.

Read the docs

Easy integration with the frameworks you already use & love

Use these resources to learn how to integrate DevNets into your existing Hardhat, Truffle, and Foundry projects.

Spawning a DevNet environment

Get your DevNet environment up and running in seconds.

  • Create template
  • Spawn a DevNet
  • Copy the RPC URL
DevNets Resource Hub

DevNets + Hardhat quickstart

Integrating DevNets into your Hardhat project is straightforward. Simply make a few edits to your Hardhat config file: add a new Tenderly networks object and insert the auto-generated RPC URL.

DevNets Resource Hub

Create DevNet templates faster using YAML

If you need more customization options when creating DevNet template, use the YAML template editor. With YAML templates, you can override balances on any of the accounts on your fork, modify storage, change the balances of addresses for specific ERC-20 contracts, and more.

DevNets Resource Hub

Spawn a DevNet using Tenderly CLI

Automate DevNet spawning using the spawn-rpc CLI command, which will instantly spin up a DevNet environment and injecting its RPC URL directly into your Hardhat config file.

Unlimited faucet

All accounts on your network fork are unlocked, enabling you to easily adjust the balance of any contract or wallet. The unlimited faucet is accessible from the Dashboard or you can use the Tenderly Faucet app. Alternatively, you can use custom Tenderly RPC methods to set a specific balance on an account or add more test ETH.

DevNets Resource Hub

Contract verification on DevNets

Tenderly uses the contract source code to enable the full potential of our Debugger and other tools. To take advantage of these and other feature, we recommend that you verify your smart contracts. Here’s hwo to verify contracts on DevNets.

✅ Simple contract verification

Learn how to deploy and verify a simple smart contract on a DevNet using Hardhat. Read tutorial

✅ Proxy contract verification

Learn how to deploy and verify Open Zeppeline’s proxy contracts on DevNets using Hardhat. Read tutorial

Start building on DevNets

Create a free Tenderly account and spawn your first DevNet in seconds.


DevNets Resource Hub

How Enso Finance Carries on the Social Responsibility to Bring Transparency to DeFi With Simulations

Enso Finance is a DeFi platform that enables users to interact with all DeFi primitives in one place. It enables users to trade, swap, lend, borrow, and earn on their assets while automating the entire process. Enso users can do this either through the platform interface or by introducing the Enso API into their products without building their own integrations. 

The Enso Finance team allows users to bundle and execute multiple transactions across all DeFi protocols, such as Yearn Finance, Aave, and Compound. They achieved this by building a complex infrastructure consisting of the Enso pathfinder and transaction bundling that enables one transaction to be submitted for many nested DeFi actions by simply returning one calldata. 

However, the Enso engineers not only create one unified gateway to all of DeFi across all EVM chains, but they embed confidence and transparency into the process. How?

As Connor Howe, co-founder and CEO at Enso Finance explains: “If people interact with our products, we don’t want them to lose any money anywhere. We feel a social responsibility for ensuring that people can interact safely with our products, and simulations allow us to do that.”

Bringing the Enso Finance vision to life

Coming from Aragon, Gnosis, Maker DAO, Polygon, and CoinFLEX, the seasoned devs started working on the first version of Enso Finance. The Enso V1 was a social trading platform where anyone could create trading strategies comprising ERC-20 tokens, yield farming, and so forth. Then, users coming to the platform could invest in the strategies and earn a percentage out of the earnings.

However, their vision was to interact with all of DeFi, so the Enso dev team decided to rebuild their entire architecture. The new architecture enables the Enso Finance system to interact with any arbitrary call. It interacts with every contract deployed on any of the EVM chains, bundles users’ transactions across different protocols, and offers the most efficient routing path with optimal earned amounts and gas prices.

In the process of rebuilding their system, the Enso team wanted to provide their users with certainty, security, and transparency. For this reason, they decided to introduce transaction simulations and help users be certain of the success of their transactions. This led them to Tenderly, which was easy and quick to set up.

Integrating simulations for greater team and user confidence 

By introducing Tenderly simulations, the Enso development team is able to integrate new protocols quickly. They can test whether the integrations work through transaction simulations using different environments, starting states, block numbers, and other relevant parameters.

This way, the Enso team offers the best DeFi routes to their users while also empowering them with the same level of confidence. As Howe simply puts it:

If we didn’t use Tenderly, we would not be able to create the product that we have now.”

And simulations help them achieve this in two ways. 

1. Simulations as a part of the Enso sanitization process 

First, the Enso engineering team uses simulations in their own internal processes to check if everything executes properly and find the best routes for their users. For instance, let’s say a user wants to deposit a token to a balancer pool. However, the user has USDC, but the pool accepts two different tokens, so they need to swap their USDC. 

The Enso team runs simulations in their own private environment to test the swap. They swap the tokens and deposit them to the balancer pool, checking if everything executes as expected. This way, they can determine the optimal route, checking: 

  • Whether the route works.
  • What the expected slippage is.
  • What the minimum earned amount is.
  • Whether there are any unexpected failures.
  • Whether you can exit a certain position once you’ve entered it.
How Enso Finance Carries on the Social Responsibility to Bring Transparency to DeFi With Simulations
Finding the optimal route with transaction simulations

As Howe further describes:

“For every single interaction for every single DeFi protocol, whether that’s harvesting, entering, withdrawing, leveraging perps, whatever it may be, we use simulations. We call this a “sanitized list”.”

So, the Enso team runs everything through simulations to make sure it works. Once everything is tested, they can proceed with the next stage of their development and testing process. And before a specific action even reaches users, the team performs another final check with simulations. 

2. Simulations as a part of the Enso Transaction Cart 

Once the action reaches the users in the interface, the Enso team runs simulations for every interaction the user wants to perform. In the Enso Finance interface, users can enter 20 different DeFi positions within a single transaction into the Enso Transaction Cart.

At this stage, the Enso team employs Tenderly simulations in two ways: 

  1. They simulate every single position their users add to the Transaction Cart. Whenever users add individual positions across all DeFi protocols, the Enso system simulates them.
  2. They also simulate the entire bundle of transactions before executing them. The Enso system bundles individual positions into a single transaction and simulates the whole bundle before submitting it on-chain. 

This way, users get the maximum possible chance that everything works as expected and that there are no errors. Plus, they get a streamlined experience throughout the process with complete transparency. 

How Enso Finance Carries on the Social Responsibility to Bring Transparency to DeFi With Simulations
Simulated transactions with estimated earned amount and gas fees

Sharing simulation data as a social responsibility for greater transparency

At that stage, the user gets all the information they need to be able to run their transactions with confidence. They receive a response with call data, including: 

  • How much gas their transactions spend. 
  • Which tokens will come out of the transactions. 
  • Any state modifications such as approvals and transfers. 

By exposing information about successful and failed transactions, the Enso team brings confidence and transparency to their users. “Before, you had no clue why sometimes your transactions were submitted and you never got the money. And that was really, really common in the industry”, describes Howes.

So, the Enso dev team feels the social responsibility to make this entire process more transparent and ensure their users can interact with their product safely. 

Additionally, the Enso team brings the same level of transparency to their internal process. For instance, if a transaction fails, they send a link to all of their team members to go directly into the Tenderly Dashboard. Then, they can inspect every single opcode, every single call trace, token changes, and so forth. 

“Simulations create a lot of transparency by showing token transfers, state changes, what works, what doesn’t work, and what events were emitted. And this goes not only for our team but for our users too. They can actually see what’s happening, and that it’s not just a black box, right? Simulations are an immediate diagnosis tool, but they also create more transparency in the ecosystem.”

DeFi security starts with simulations

The Enso Finance team invested a lot of time and effort into building a system that makes DeFi accessible to their users. With their one API or through their interface, users can interact with all of DeFi primitives in a single place. Plus, their system prioritizes users’ security, complete transparency, and ease of use. 

But they didn’t have to do it alone. With Tenderly’s simulation infrastructure, the Enso devs have maximized the chances of getting the best possible outcome out of DeFi positions. And all of this while showing what’s actually happening when sending transactions. 

So, ready for increased security? Try running simulations yourself and empower your users. And to interact with all DeFi primitives, give the Enso API a try and start exploring!

How ShapeShift Overcomes the Challenges of Testing in Web3 With Tenderly DevNets

Founded in 2014, ShapeShift first started out as a trading tool in the wake of the Mt. Gox hack, believing that third-party intermediaries shouldn’t hold customers’ funds. Over time, they evolved into an all-in-one crypto trading platform. 

As the space continued to evolve and DeFi emerged as an innovative way to manage finances without an intermediary, the founders realized that the model of decentralized exchanges (DEXs) is much closer to their initial vision. So, in 2020, ShapeShift started to sunset its trading engine and launched a DAO. 

ShapeShift is now an open-source DeFi dapp, serving as an interface between users and their wallets. It’s community-owned, non-custodial, free, and decentralized, embodying the values of Web3 at its very core. Since their interface runs on IPFS, users can even host it locally. Also, ShapeShift supports 12 chains and more than 170 wallets, bringing DeFi closer to a wide range of users.

The ShapeShift testing process

Their ShapeShift core team of developers integrated LI.FI. into their platform. With this integration, they added additional routes to the existing ShapeShift cross-chain swaps, bringing more comprehensive trading capabilities to their users. 

However, such upgrades are difficult and expensive to test. For instance, whenever they update the swapper system or change the logic of handling trades, fees, inputs, or outputs, they need to test everything out to ensure it executes as expected.

So, even back in the day, the ShapeShift developers looked for a way to validate their solutions before going into production.

“I thought it had to be a way to simulate transactions before sending them on-chain. So, a ShapeShift community member recommended Tenderly, and that’s how we started using it”, says Woody, a senior software engineer and core contributor at ShapeShift. 

What the ShapeShift testing flow looks like

So, to confirm the validity and correctness of their upgrades, the ShapeShift team employs stringent testing procedures. Their test suite consists of unit, integration, and end-to-end testing, both manual and automated. 

The ShapeShift testing process starts with unit testing, followed by integration and then end-to-end testing. The team first initiates automated testing and then moves on to manual testing for a comprehensive code review. 

As part of the manual testing process, the ShapeShift engineers spin up their app in a remote or local environment. Then, they closely inspect and double-check the code by doing a regression test. Once the engineering team gives their approval, the upgrade goes into a staging environment. As the final step, their Ops team performs another final revision. 

The challenges of standard testing procedures

While performing their extensive testing procedures, the ShapeShift developer team came across multiple challenges:

  • They have to invest a lot of time into manual testing, most of which are very basic and limited types of tests.
  • Even with manual testing, the costs keep increasing, putting a major overhead on their team.  
  • It also proved difficult to automate cross-chain testing without actually forking an entire network and simulating its real-time behavior.
  • With end-to-end testing, they need to be careful not to get caught in the loop of writing tests that would always work. When mocking out parts of the network in this stage, it’s easy to write tests that are guaranteed to pass because you can easily code your assumptions into your tests. 
  • End-to-end testing is also quite limited, limiting the ShapeShift engineers to testing only the basic functionalities of their platform. 

“The type of things you can test with end-to-end testing without Tenderly is very skin-deep stuff that doesn’t really matter as much. So, for example, if you’re running an end-to-end test without Tenderly, you can test items like – can you switch between dark mode and light mode? Can you open and close this menu? Or does your wallet connect properly”, explains Woody.

Tenderly DevNets: a zero-setup testing solution

Striving to further resolve the challenges of running standard manual and automated tests, the ShapeShift engineering team integrated Tenderly Developer Networks (DevNets). Using this managed, zero-setup environment, ShapeShift eliminated the need for running a high number of tests manually and dealing with the lengthy setup and revision process. 

Instead, the ShapeShift team runs a Tenderly yarn command to automatically spin up a DevNet and different proxies locally. Then, once they run their app, it runs through a proxy and redirects requests to Tenderly.  

How DevNets improve testing

Using DevNets, Shapeshift developers can develop, deploy, and test their smart contracts against the most recent state of a selected network. This means they can spin their own private networks with production data, yet still have control of local development and testing.

After spinning up a DevNet, the team can just jump into their testing process and not worry about test tokens. Each DevNet environment has 100 test tokens and can easily be topped off using an unlimited faucet.

Additionally, Tenderly DevNets open a range of other possibilities: 

  • The ShapeShift team can create reusable templates with fresh states without manual configuration.
  • They can also automate DevNet creation using the Tenderly CLI.
  • With custom RPCs, the ShapeShift engineers can change blocks, states, contract codes, timestamps, and other parameters.
  • The team can run their tests against the latest or historical states of more than 30 supported networks. 
  • They can use DevNets in their local development or as part of their CI pipeline. 

How DevNets simplify debugging

While using Tenderly DevNets for testing, the ShapeShift developers can also access Tenderly Debugger if they come across any issues. The seamless integration enables them to quickly inspect any bug in detail and apply a fix. 

When it comes to diagnosing failed transactions, the ShapeShift team already uses Tenderly Debugger in combination with Transaction Simulator. This way, if some of their transactions aren’t going through, they resimulate them in Tenderly. Then, they use Debugger to go through stack traces and identify the exact cause of an issue. 


Want to optimize your debugging flow? Check out this video to learn how to use Tenderly Debugger and Transaction Simulator to identify bugs and validate your solutions. 👇



Validating bug fixes with TX Simulator and Debugger

Rigorous testing: a road to foolproof Web3 solutions

The ShapeShift engineering team ensures the integrity of their DeFi solutions through extensive, rigorous testing. However, their testing process shouldn’t be an overhead for their team and prevent them from focusing on building innovative products. 

With Tenderly DevNets, they’re able to speed up and simplify development and testing, while ensuring the correctness of their smart contracts and the validity of their upgrades. Additionally, with other Tenderly features readily available, the team can quickly address any issue before going into production. 

So, if you’d like to optimize your testing process and get the support you need so you can focus on the creative part of building in Web3, give Tenderly DevNets a try. Start testing the easy way!

Tenderly Node Extension Library

Tenderly Node Release: Ready to try DevNets or Node Extensions? For more information on our new node solutions, check out our changelog!

Node Extensions

Create a custom RPC interface for your dapp or search the library of community-sourced Node


What are Node Extensions?

With Tenderly Node Extensions, you can build and deploy custom RPCs and integrate them into
your dapp, without changing its existing logic. You can also use preset, community-sourced
Node Extensions for plug-and-play functionalities.

Want to help the community grow? Submit your custom Node Extensions to our library and help
share some unique use cases.

Node Extension Library

Explore ready-made Node Extensions sourced from some of the key industry players.


Fetch the Uniswap ERC-20 balance, optimize eth_call performance, and minimize node
RPC consumption.


Use this Node Extension to get the author of a block (a.k.k coinbase) on the Polygon


Get the latest price feed from Chainlink with just the token pair information – no
need for contract addresses.


Use a single request to simulate a signed transaction, make sure it’s successful, and
submit it on-chain./p>


Simulate a transaction that’s still in the mempool and know its exact outcome while
it’s still pending.


Activate this Node Extension to get the list of supported entryPoint contracts on the
chain you’re building.


Check whether Pimlico’s Paymaster can sponsor a submitted User Operation on behalf of
a wallet.


Ask Pimlico’s Paymaster to sponsor a submitted User Operation on behalf of a third

Worldwide Locations

North America HQ

16 Maiden Lane, San Francisco CA 94108, USA


Milutina Milankovića 7đ, Belgrade 11070, Serbia

Cyberpunks Gather at ETHTaipei!

The Tenderly crew is visiting the lovely island of Taiwan for the first edition of ETHTaipei! ETHTaipei is a five-day event (21 – 25 April) hosted and organized by the strong and vibrant Ethereum and developer community.

And do we have some fun things in store for the Heart of Asia!

Tenderly will be hosting a Happy Hour “Block Party” and a mini, cyberpunk-themed hacking event together with Furucombo, and much more!

On the ground in Taipei, representing Tenderly will be our DevRel duo Nenad and Vanja, together with Aleksa, software engineer, and Nikola, event manager.


The ETHTaipei hackathon is a three-day event organized by TAIKAI, a platform that connects hackers and companies through engaging hackathons.

Developers have the opportunity to compete for prizes sponsored by local community initiatives and renowned projects backing the event. To be victorious, participants must work in teams to come up with innovative blockchain solutions using Ethereum technologies.

On the first day of the hackathon, Tenderly is organizing a Happy Hour “Block Party” together with frens from Furucombo. Furucombo is a multi-chain DeFi aggregator that aims to simplify, optimize, and automate DeFi trading for everyone. We teamed up with Furucombo to help the hackers relax and unwind a bit over free drinks and snacks.

The party will take place at the official hackathon venue, POPOP Taipei (Building: I) 13號 Section 2, Nangang Road Nangang District, between 5 – 7 PM.

Due to high demand and interest, the tickets for the event are unfortunately sold out.

We’re looking forward to seeing and meeting all of the builders from the community and visiting Taipei!

ETHTaipei 2023 Conference

After the three-day building extravaganza wraps up, the official conference will kick off with Vitalik’s keynote speech, “The Need for Standardization of L2s, Smart Contract Wallet and Privacy“.

The main part of the event will feature speeches divided into two distinct tracks: DeFi and Protocol. The DeFi track delves into decentralized finance and security topics, while the Protocol track explores various subjects, including clients, ZK Proofs, and Layer 2.

War Room Games Taipei

Cyberpunks Gather at ETHTaipei!

We’re stoked to announce another edition of War Room Games – Tenderly’s famous capture the flag event! We’re bringing our fun event focused on finding exploits and vulnerabilities in smart contracts to the neon-lit Taipei.

We’ve teamed with Furucombo to bring you a mini, cyberpunk-themed hacking event with several interesting challenges that will definitely make some hackers sweat. This is also an awesome opportunity to flex some of those hacking muscles.

War Room Games Taipei will be hosted on April 24th at 4:30 PM in the official venue, POPOP Taipei, I building, in the heart of Taipei’s tech district.

As with every other War Room Game so far, the stakes are high, the atmosphere difficult and challenging to work in 😃, but the prizes will be grand!

Those who can handle the pressure stand to win the following prizes:

  • 1st place – 3000 USDT
  • 2nd place – 1500 USDT
  • 3rd place – 500 USDT

And, of course, all active participants of the WRG CFP will receive a free 3-month subscription to Tenderly’s Dev plan.

Register before Monday and show off your skills! Just don’t forget your cyberdeck!

Shortcuts to better Dapp development

On the second day of the conference, our Head of DevRel Nenad will hold an in-depth talk titled “Shortcuts to Better Dapp Development.

The focus of the talk is to provide practical advice and inspiration for developers looking to streamline their dapp development process and get the most out of their time. Nenad will also share some personal tips and tricks, particularly about how Tenderly Node Extensions, SDK, DevNets, and other tools can be used.

We’re looking forward to Nenad sharing his expertise and hearing his interactive and engaging discussion with the audience.

During the Q&A portion, attendees are more than welcome to share their own best practices for writing efficient and scalable code.

See you at ETHTaipei!

So there it is, Tenderly crew is coming to Formosa and the bustling Taipei. We invite all the hackers and cyberpunks to join us at POPOP Taipei between 21 – 25 April for the first-ever edition of ETHTaipei 2023!

We’re thankful we were invited to take part in this event, and we are super eager to meet the local community of developers and teams hacking away our shared, decentralized future!

How GasHawk Brings More Value to Users With Transaction Simulations

GasHawk is a straightforward tool designed to help users save money on Ethereum gas fees. The project achieves this by queuing signed transactions and sending them to the mempool once gas fees are low. Since users submit signed transactions, GasHawk cannot make any changes, ensuring high security.

The GasHawk system is based on a transaction submission strategy that relies on historical data, EIP-1559 knowledge, and other relevant factors. Upon submitting their transactions, users can specify deadlines, maxBaseFeePerGas, priority fees, and other parameters.

Daniel Pfeffer, CTO at GasHawk, shares the team’s vision and insights into how they bring additional value to their users.

Dealing with gas price volatility

Gas fees are highly volatile on Ethereum, with prices going up during bull and high network usage periods. For instance, simple ETH transfers can cost users even up to $20 or $30. Additionally, transactions can easily get stuck in the mempool if users set low gas fees.

With GasHawk, Ethereum users don’t need to deal with gas volatility. Instead, they can just submit their transactions and let the platform determine the best time within their given time window to send them on-chain. GasHawk also offers its API so that automated services can benefit from the savings.

“If you have this stochastic volatility in front of you, you have to pick the right moment, the very right moment to send transactions. Using this approach, we are able to save on gas fees for our users”, explains Daniel Pfeffer, CTO at GasHawk.

To facilitate gas payments, the GasHawk system runs an RPC proxy service that collects signed user transactions. Instead of sending them to the mempool immediately, GasHawk queues transactions in its transaction manager through its API. The underlying strategy system then determines the right time to send transactions on-chain, scheduling them for time slots when gas prices are low.

So far, GasHawk saved on average 30% on gas fees for the processed user transactions. During high volatility times and with deadlines up to 24 hours, GasHawk even achieved more than 90%. And also during low-fee times, GasHawk can still successfully navigate while achieving savings between 10 and 20%.

How GasHawk Brings More Value to Users With Transaction Simulations
Using GasHawk to save money on Ethereum gas fees

Offering value beyond gas cost savings

However, for the GasHawk developers, saving on gas is only one part of their vision. Since GasHawk lies between users’ wallets and the Ethereum network, the development team is in a unique position to offer additional value to their users. The team wants to make their service accessible to every Ethereum user while ensuring gas payments are user-friendlier and more cost-efficient.

So, in addition to helping users save money on gas, GasHawk also:

  • Provides protection against failed transactions through transaction simulations.
  • Protects against transactions stuck in the mempool when there’s a maxBaseFeePerGas setting that would prevent the transaction from inclusion.
  • Allows users to send their transactions to a private instead of the public mempool, e.g. Flashbots Protect.

Further items on their roadmap are:

  • Checking whether a transaction interacts with blacklisted services and protecting the user from losing funds.
  • Detecting whether a transaction has unintentional consequences, such as giving a large approval on an ERC-20 token or NFT collection.
  • Blocking or automatically failing transactions with other undesirable effects.

Protecting user funds with transaction simulations

GasHawk has managed to bring a lot of value to Ethereum users since the project went live in September 2022. To achieve this, in addition to developing their own system and strategies, GasHawk developers also integrated Tenderly’s Simulation API into their core service.

The integration of Tenderly API was so straightforward and easy and it added this value to our service, which really impressed me, says Pfeffer.

The Simulation API allows GasHawk to preview pending user transactions before sending them on-chain. This integration enables the GasHawk development team to:

  • Improve the user experience on their platform by removing anxiety among users.
  • Protect users’ funds by preventing failed transactions from being sent to the chain.
  • Take precautionary measures if they identify transactions with undesirable effects.
  • Cater to their highly technical audience by exposing simulation data for additional insight.

Tenderly is adding a lot of value for the more technical audience we have. We’re quite a technical product and we’re pulling the more technical people of the community, such as developers who’re deploying smart contracts on-chain. We know they’re interested in these deeper insights and they also want to know whether transactions would succeed and be worth the cost before actually sending them”, says Pfeffer.

Integrating Simulation API

GasHawk acts as a standard RPC provider that’s accessible to any Ethereum user. You can connect it to your MetaMask wallet and add GasHawk as your chosen network. Then, when processing your transactions, the GasHawk team makes Tenderly’s Simulation API accessible, showing you exactly what to expect from their execution.

How GasHawk Brings More Value to Users With Transaction Simulations
Simulating a transaction on GasHawk with Tenderly’s Simulation API

The user can let GasHawk send transactions to Tenderly’s Simulation API through the GasHawk Dashboard. The API returns simulation data, including the actual gas usage of a transaction. The GasHawk team uses this data in combination with their own insights and predictions to handle users’ transactions.

How GasHawk Brings More Value to Users With Transaction Simulations
Allowing users to inspect simulation data on Tenderly

If a simulation gets executed successfully, GasHawk schedules a user’s transaction for a low-cost time slot. If not, the platform issues a warning, advising the user against sending the transaction. GasHawk also persists simulation data and allows users to inspect transaction execution in detail on Tenderly.

How GasHawk Brings More Value to Users With Transaction Simulations
Inspecting a simulated transaction on Tenderly

Empowering users with transaction simulations

The unpredictability of the Web3 space brings highly volatile gas prices, which often makes gas calculations complex and time-consuming even for technical users. Underpaying for gas, having transactions stuck in the mempool, and losing money can deter users from using the blockchain altogether.

GasHawk strives to eliminate this unpredictability, brings precise gas estimates, and helps users save money. Through the integration with the Simulation API, the GasHawk system estimates the actual gas usage of users’ transactions while also preventing failing or malicious transactions from being sent to the chain. GasHawk then uses this information to protect and save users’ funds.

If you’d like to try transaction simulations, take a look at some additional examples of projects that use Tenderly simulations:

Then, create a Tenderly account for free and start bringing more value to your users.

How Tenderly Helps Alluvial Reduce Development Complexity and Enable Team Collaboration

Building a new standard in liquid staking

How Tenderly Helps Alluvial Reduce Development Complexity and Enable Team Collaboration

Alluvial protocol developers focus on supporting the development of Liquid Collective, a new liquid staking standard for blockchain enterprises and institutions. The Liquid Collective protocol consists of liquid staking contracts on different networks, including the Ethereum Mainnet and Gorli. It’s built and governed by a community of participants.

At the heart of the protocol lies the Liquid Collective oracle service. The oracle helps collect all staking rewards on the consensus layer and report them to the execution layer. The information gathered through the oracle allows the Liquid Collective protocol to programmatically update the conversion rate for its liquid staking receipt token (LsETH), which represents the staked ETH plus the network rewards it has accrued.

Looking for more than a transaction overview

The complexity of the Liquid Collective protocol requires Alluvial’s Web3 development team, and the other technical teams supporting the protocol’s development, to actively monitor and analyze its activity. However, the team initially had poor visibility into protocol activity. This impeded their ability to review and analyze transaction execution in detail. Consequently, Alluvial developers had a limited understanding of what happened in the Liquid Collective protocol, especially when issues occurred.

Tracking transaction information is also essential to the Alluvial team’s operations. They need a consistent and in-depth way to monitor and analyze oracle data. If any inconsistencies occur in the submitted reports, Alluvial engineers need to go through all the executed transactions to get an understanding of what happened.

Introducing greater visibility into protocol activity with Tenderly

The Alluvial development team started their search for a solution that would provide them with extensive information and context surrounding the Liquid Collective protocol. This search led them to the Tenderly platform where they found the in-depth tx data they needed along with highly responsive engineering support.

"We needed to get more information on the protocol and Tenderly is a very obvious choice for everything that it brings”, explains Nicolas Maurice, the co-founder and CTO at Alluvial.

Thanks to the extensive level of detail available in Tenderly Debugger, Alluvial developers and Liquid Collective’s other technical partners can now analyze transaction stack traces in a granular view.

“Deployment that we have is quite complex and advanced. With Tenderly, we’re able to review the execution of a transaction as it goes through a series of contracts, which is super important and helpful for us”, continues Maurice.

Now, Alluvial’s use of the Tenderly platform spans a diverse set of features. Contract verification on Tenderly allows them to work on Liquid Collective’s smart contracts without deploying them to an actual network. Alluvial developers can privately verify the smart contracts on the platform and then use Transaction Simulator and Tenderly Forks for testing and validation.

Protocol monitoring has also become much easier and streamlined thanks to Tenderly Alerting. Alluvial developers can set up a range of alerts to stay up to date with what’s going on in the protocol. From balance updates to specific transaction calls, Tenderly alerts notify the Alluvial team of any important on-chain changes. With real-time information, the team can review relevant events and act accordingly.

Removing blockchain complexity and enabling cross-team collaboration

Thanks to Tenderly’s Transaction Simulator and Forks, Alluvial engineers can now validate both administrative actions and contract upgrades prior to deployment. Running simulations on Tenderly Forks allows them to ensure everything executes as expected and detect possible issues early on.

Alluvial developers are also able to share test results across different teams, including non-technical stakeholders. Tenderly brings in-depth information and context around sending administrative transactions to the protocol. While sending these transactions can be a sensitive operation, Alluvial engineers can bring security and certainty to this process.

“Using Tenderly simulations to show my co-founders and partners that our administrative actions will execute properly changes the way you work with your team because it makes everyone comfortable”, says Maurice.

Finally, the Tenderly platform helped remove the manual work for Alluvial developers. Instead of having to deploy nodes and deal with the complexity of blockchain data, they can rely on Tenderly for the depth of information and the tools they need.

Getting value with Tenderly from the very start

“Tenderly as a platform is very complete with different features”, explains Maurice.

It provides Alluvial developers with tools that enable them to better understand what’s actually happening in the protocol.

In the next phase, Alluvial engineers plan to integrate Forks into their development and testing framework. Using API, they can integrate Tenderly Forks as a testing environment. This will allow them to automate their development and testing with a fully integrated Mainnet replica.

As for Tenderly newcomers, Maurice further explains:

“Something that I find interesting about the platform is that you get value as soon as you start using it. And as you mature on the platform and start using other features, then you get to increase the value you get from Tenderly.”