Smart Contract Development from the Trenches
Tags: smartcontracts, ethereum, solidity, blockchain
Published: 2018-05-10 02:35:25

---
title: Smart Contract Development from the Trenches
published: true
description: Detailing my experiences with writing smart contracts
tags: smart contracts, ethereum, solidity, blockchain
cover_image: https://d1udjo59ytjrp6.cloudfront.net/img/uploads/2016/12/12155730/Block-CDN.jpg
---

I’ve been writing smart contracts for fun since 2017 and have been given the opportunity to write them in a professional setting. This post is an overview of my experiences writing smart contracts for the past year and a half.

* Writing an ERC20 token is not like the examples found online

Most ERC20 token examples are like this:

{% gist https://gist.github.com/andredublin/f2ff9d32cfc85fc419d4ed9eaef56f00 %}

This is your typical example where the token is initialized and all of your tokens are assigned to the contract creator.  This example is pretty straightforward, but in most business use cases this will not work. You won’t want to be sitting at your computer issuing tokens to your end users manually.

In most business requirements I’ve encountered the process for issuing tokens had to be automated which leads me to my next point

* The Agent Pattern

At least I’m calling it the `Agent Pattern`, but it is akin to the Service Pattern in SOA, where a contract `B` is the RPC interface for another contract `A`. Let’s look at an example:

{% gist https://gist.github.com/andredublin/0907588a1e1a8bf2fba718eb235e730a %}

In this example the `MyToken` contract has a modifier on the transfer function `onlyAgent` that restricts the sender of the method call to be the agent with the correct address. Our agent is only settable by the owner of the contract.

Now this is a trivial example and the security flaw is that **ANYONE** can call the agent contract to transfer tokens. One secure approach might be to have a whitelist of valid addresses in the token or separate contract that are allowed to have tokens issued to.

Now we are able to apply business logic and evolve the contract as requirements change. But what if we want to have multiple agents?

{% gist https://gist.github.com/andredublin/f1c601397d1814ca61cfddc67172fbfd %}

The example above has been shortened for brevity, but you see now that we have a mapping or dictionary of agent address to boolean that denotes if they are authorized or not to execute method calls on our smart contract. We can enable and disable agents as needed!

* Use Open Zeppelin

Please use [Open Zeppelin](https://github.com/OpenZeppelin/openzeppelin-solidity) smart contracts, they help to take the guesswork out of security issues with solidity and ensure that you are deploying a safe smart contract. It is not a silver bullet, but it will help you to develop more secure code.

* Write tests, write more tests, write more tests after that

I can’t stress this enough the more unit tests the better, also if you do use Open Zeppelin, then import their tests into your code base for verification.


* Use the Truffle framework

[Truffle](http://truffleframework.com/) is pretty much the standard starter kit for writing smart contracts, paired with [Ganache](http://truffleframework.com/ganache/) makes for a pretty sweet development experience. YMMV with Ganache, in the past I've had issues with it, but recently its been quite pleasant. Ganache also does a better job of giving more explicit error output in the console when running unit tests or interacting with contracts through truffle.

* **ALWAYS** deploy to a testnet first

I've made the mistake of deploying a smart contract to the mainnet once and found a minor bug in it. If I had deployed to a testnet first this could have been avoided. Ropsten is my testnet of choice as I've found it easy to get test ether from their [faucet](http://faucet.ropsten.be:3001/). The faucet has an api that can be used to greylist your wallet address for a short period of time to receive ether.

* Deployments

So far my deployment tools of choice are [Remix](https://remix.ethereum.org/) and [Metamask](https://metamask.io/). The deployment process to either test or main nets have been quite painfree. I'll save the details for how I do that in another post. 

Alternatives would be to use your own Ethereum lite node or [Infura.io](https://infura.io/). However setting up a lite node just to deploy contracts can involve a lot of friction before your pushing contracts to an Ethereum network and I didn't have the best of luck with Infura when it first emerged. However things may have gotten better and could be worth exploring again.


* Read other peoples code

Most Google searches will only bring up ERC20 tokens and probably Cryptokitties, but those are still good sources of information for understanding how to write better smart contracts.

* Architecting smart contracts

Start out with a single solidity file and work from there. The interfaces will reveal themselves as you write the code. Assuming your interfaces from the get go will only cause you pain as it takes more work to orchestrate and deploy smart contracts than it does with your typical software codebase.

Thanks for reading!