Write About Everything

A number one-edge performance and error monitoring tool for Ruby applications.

Working with Ethereum blockchain is vastly different from any tech stack that I’ve encountered before. In this weblog submit, claim ETHW I’ll describe a set of tools and strategies that I want I knew when i started building my first Solidity venture. We’ll focus on how to use the Mainnet without paying gasoline fees, apply superior debugging to native transactions and steal all the Vitalik’s Ether.

1. Don’t use testnets for testing

Growing for Ethereum is an expensive hobby. With the present fuel charges deploying a easy smart contract prices over $100.

A typical practice is to deploy contracts to one of many testnets before the ultimate release is ready. This strategy works good-sufficient for simpler contracts that are self-contained. In case your project relies on exterior dependencies, e.g., Uniswap protocol, or price oracles, you must replicate the identical setting on the testnet. For some protocols, testnet forks are available. In any other case, you have to deploy the fork yourself. And that’s so much of work. Even if you succeed, then you still have to take care of separate environments configuration, thus complicating your setup.

Local mainnet fork FTW

Mainnet forking is an alternative resolution to this problem. Hardhat allows you to spin up your local mainnet with a easy command. By default, it forks off the newest block, but you can configure it to any block up to now. Remember to make use of an archive node (e.g., by Alchemy) to avoid points with touring too far back.

Domestically forked mainnet means that you’ve all the unique protocols, accounts, ERC20 tokens, and so on., able to play with. No need for the tedious handbook setup. You may simulate transactions earlier than running them on the mainnet and deploy the check contract to see how it interacts with the manufacturing environment. Solely the required knowledge is transferred to your local machine, so the setup is almost instantaneous. It means that you may run a check suite in opposition to the local forked mainnet. And that’s all without paying a cent for the fuel charges! :exploding_head_emoji:

One thing I’m lacking when working with a locally forked community is an Etherscan UI. Explorer by Etherparty is a limited alternative. However, I still discover it useful for fast visual feedback.

Borrowing check funds

A bonus trick is that forking allows you to simply imporsonate any EOA account. Try the next Hardhat script which transfers all of the Vitalik’s Ether to your account:

On the time of writing, that’s over 22 million USD to play with. This method is tremendous helpful if you would like to test out transactions that will normally require you to take a flashloan. The next trick works also for borrowing ERC20 tokens, NFTs, gaining admin entry to protocols’ smart contracts, and so forth.

I’ve picked up the above approach from a video tutorial by Austin Griffith. BTW many of his tutorials are hidden gems that get like 1k whole views. I extremely advocate you to test them out if you’d like to boost your blockchain stats.

Please remember that some edge case situations may not work on a forked mainnet. In case you encounter bizarre local bugs you’re caught with testnets or paying real fuel charges.

2. Debug native transactions with tenderly.co

Now that we’ve enabled an area mainnet god mode, let’s run some transactions. tenderly.co affords highly effective debugging and introspection tools.

Even within the free plan, you can dissect any public transaction down to the one stack name with a built-in source code inspector and debugger:

You may as well see exactly why the prices of your transactions are sooo rattling excessive…

A killer feature of tenderly is that it allows all those debugging tools additionally to your native transactions. It implies that you may get the identical powerful insights for transactions that you’re running towards your native forked mainnet. Go to the Native transactions tab in tenderly UI to get detailed directions on setting it up.

Identical as earlier than, this tip comes from Austin Griffith’s video tutorial.

An honorable point out here is EthTx Transaction Decoder. This open-supply project gives similar debugging capabilities.

3. console.log

I’ve written my first Solidity project with Truffle and solely later switched to Hardhat. I don’t need to begin a flamewar, but from my beginner’s perspective, Hardhat appears to be superior in terms of options (Disclaimer: I solely have fingers-on expertise with these two frameworks). For example, the check swimsuit runs ~4x quicker, and there’s additionally a console.log available in Solidity.

When you test against a regionally running fork, you can see the log output in the node process. In comparison with debugging contracts’ inside state from the skin when working with Truffle, console.log considerably improved my improvement process. Simply remember to remove all the console.log entries before deploying to production because they eat extra gasoline.

4. TypeScript

I was stunned by how a lot static typing has improved my workflow. Before working with Ethereum, I’ve had only normal NodeJS expertise however switching to TypeScript had a minimal learning curve. For me, the syntax overhead is negligible compared to the number of errors that the compilation process prevents.

Hardhat provides first-class support for TypeScript, so configuring it in a new undertaking takes solely a second. TypeChain is also value adding to your stack if you’re already utilizing static typing.

A bonus tip is that you should use resolveJsonModule compiler option to import ABI JSON information instantly from the file without embedding it in the codebase.

5. Take a look at helpers

Earlier than discovering OpenZeppelin take a look at helpers I’ve used to write down monstrosities like this one:

and after:

Can you spot the distinction?

This lib gives dozens of helpers that simplify writing and maintaining check fits. Notable highlights are simulating the passing of time and tracking account steadiness modifications.

Check helpers library seamlessly integrates with Hardhat assessments using Waffle, ethers.js, and chai.

Summary

I’ve described the methods that so far had the very best affect on my each day workflow and productiveness. I’m simply beginning my journey as a blockchain developer, so please don’t hesitate to share extra tips within the comments.