Etherlime is supported by Ethereum foundation, Ethereum Community Fund, and ETHPrize.

The tale of Etherlime is one of necessity. It started a long time ago when I tried to deploy my first mainnet smart contract system. It all worked well on Ropsten and Rinkeby. The deployment script was running flawlessly and all my manual tests on the testnets were successful. Little did I know what was in store for me when I typed network live

Deploying on the mainnet
It all started with the normal transactions and suddenly it all failed. As blockchain is a new technology I swallowed the pricy hiccup and decided to retry my migration to live. Nope, failed again. And again. And again. Crying in pain I decided to write my own deployment node.js script with ethers.js — the only thing I was trusting at the moment to be stable and not let me down. And it all went well.

Is it me or is it you?
Since then, I’ve talked with many fellow developers on how do they deploy on mainnet. Everyone has their own solution — some use remix, some use bash scripts, some use node.js scripts. No one trusted the tooling for this job. Since I’ve found that ethers.js is the stability needed in this process, I’ve persuaded a small team in my company LimeChain, to start working on deployment and development framework — if not for commercial use, just to ease our own pains. Few weeks later we were all very happy with the results and we’ve decided to open-source it.

What is the state of Etherlime
Since then we’ve grown Etherlime to be much more than deployment framework. We’ve added features and we’ve crowdsorsed many more (see them in our github issues https://github.com/LimeChain/etherlime). It’s both an library and a CLI. You can use one or both of them.

Documentation is something that we swear by. If anything gets released it is documented and you can see it in the beautiful documentation. This is the only way to adoption — https://etherlime.readthedocs.io.

Here is an overview of some things that Etherlime can do (in chronological order of being added): Also available on video:

Deployment
Obviously the most acute pain-point was addressed first — adding much needed stability to the deployment procedure via the use of ethers.js. The deployer is very verbose, telling you everything it does, and ends with a nice shiny looking table. You can see what has been deployed and all the transactions executed with their labels (if you provide one). You can also view the history of your deployments, by simply typing — etherlime history.

Embedded Ganache-cli
Another thing comming from our experience as blockchain development company was that you need stability in your ganache-cli addresses and a lot of fake ETH. All the devs had written their own scripts to spawn such a ganache, and we’ve decided that we are going to embed this into etherlime. Typing etherlime ganache allows you to run such a ganache and to deploy on it extremely easy

Compilation and linking
Natural next thing was to embed a compiler into etherlime. Etherlime compiler supports multiple compiler version and optimizer enabling from the command line itself. No complicated config files.

Unit testing and code coverage
Last but not least, any blockchain project should have unit tests covering it’s logic. It’s not a “nice to have” thing — it is a must in our immutable world. With etherlime you get your well known mocha in place. We’ve taken a step further and extended it to include things like assert.revert . Solidity-coverage library is also embedded in etherlime so you can check your code coverage as easy as it can be etherlime coverage

Ethereum Community Fund and ETHPrize growing the EtherLime
We’ve been blessed to be helped by ECF and ETHPrize. They’ve helped water the Lime with $90,000 for the team to continue working hard on making the tool even better. The funding will make the following possible over the next 6 months:

Debugger
Recent study by https://ethresear.ch showed that there is a common consensus in the development community that the most desired improvement of the tooling would be seeing newer and better debugging functionality. Writing debugger is no easy feat, but stepping on the shoulder of giants and sparkling all of our hard work and expertise, we believe we can create a workable version and improve it gradually over time.

Code Scaffolding
One main repetitive task that we’ve done over and over again is write “connection code” in our client side application. Creating contract instances, connecting them with their ABIs and addresses and interacting with them via Wallets. We desire to auto-generate much of this repetitive work for the major client-side languages starting with JavaScript

CLI unit tests coverage
One of the greatest fears of any CLI developer, is the uproar of dissatisfaction on unfortuante release a broken library version. We’ve decided that much like smart contract development, we should guard ourselves and our contributors against that with meticilous and exhaustive unit test suite. This will allow for better development experience to both users and contributors.

Useful links:

*Why is Etherlime needed - https://medium.com/limechain/etherlim...

*Telegram group - https://t.me/etherlime/

*Twitter - https://twitter.com/etherlime

*Github - https://github.com/LimeChain/etherlime/

*Documentation - https://etherlime.readthedocs.io/en/l...