In this guide I’ll go through the basics of deploying and interacting with a simple smart contract including:
- An overview of a simple smart contract
- How to compile and deploy the contract
- Interacting with the smart contract and saving information to the blockchain
- Interacting with the smart contract and reading information from the blockchain
- BONUS: Verifying the contract code for the public
- BONUS: Using the Kovan testnet and getting test ETH to power your wallet
The Smart Contract
I chose to use this simple contract (courtesy of Loom Network via CryptoZombies) instead of a typical “Hello, World!” as it allows users to interact with data on the blockchain.
In brief, the contract has two functions, one which allows users to set their own lucky number (Solidity uses
msg.sender to retrieve the address of the wallet interacting with the contract), and a second function which accepts any address as an input, and returns that address’s lucky number.
Compiling and Deploying the Contract
Now that we have a smart contract, we need to deploy it to the blockchain. For this walkthrough, I’ll be using the Deploy Contract functionality built into MyEtherWallet (MEW). I used the Kovan testnet, but the procedure is the same for the mainnet.
On MEW, navigate to the Contracts tab at the top, and click Deploy Contract. MEW will ask for the bytecode of the contract, as well as the gas limit.
How do we get the bytecode? Well, we need to compile the Solidity contract. To do so, I used Remix — a browser-based Ethereum IDE. We copy in the Solidity code, and Remix spits out the bytecode (you’ll need to click Details on the right-hand side, and use the
object value of the bytecode).
We copy this into MEW, and are ready to deploy — you’ll notice the Gas Limit auto-populates based on the bytecode. The last step is to open the wallet that will deploy the contract. Like any transaction, deploying a smart contract costs gas. Luckily, since this is a simple contract, the gas cost is minimal. If you want to avoid using ETH while experimenting, review the section on receiving ETH on the Kovan testnet below. I unlock my wallet, and hit Deploy. The contract has now gone out as a transaction waiting to be mined. A few seconds later it is mined, and our transaction is live! We need to look at the transaction and find the contract to see at which address it has been deployed.
Saving Our Lucky Number to the Blockchain
Now that our contract is live, we can now interact with it — first by calling the setNumber function to store our lucky number. In MEW, we go back to the Contract tab, and input the contract address. Unfortunately, it’s asking for one more thing — the ABI. The ABI, Application Binary Interface, is basically how you call functions in a contract and get data back. An ABI is necessary so that you can specify which function in the contract to invoke, as well as get a guarantee that the function will return data in the format you are expecting. Luckily, it’s very easy to find out the contract’s ABI, we can go back to Remix and copy it in. Now, we hit the Access button, and…. voilà: MEW pulls up the two functions available to use,
We’ll invoke the
setNumber function first, setting our lucky number to 23. As we saw before, the contract will take the number 23, and set it against our address. We’ll unlock our wallet once again to sign the contract and pay the gas fee, and the transaction is sent off to be mined.
Reading from the Blockchain
Once our previous transaction is mined, we’re ready to invoke the second function
getNumber. As you may recall, this function accepts an address as an input, and outputs that address’s lucky number. Back to MEW, we invoke the
getNumber function, and use our own wallet address in the address field. We click Read and MEW spits back the answer in an instant: 23!
You’ll notice that we didn’t need to create a transaction to read the data, only when we wrote it. This is because once on the blockchain, any block explorer is able to read the data readily, whereas the
setNumber function actually involves writing new data to the blockchain.
So there we have it — a live, working contract on the blockchain! Feel free to experiment with this contract or with your own! You can experiment with my instance of the contract which can be found here. Now that you understand the basics of deploying and interacting with a smart contract, you’re ready to start writing and deploying more advanced contracts! A great place to start learning about Solidity is with CryptoZombies — think Rails for Zombies meets CryptoKitties.
Sharing the Contract
As you may have noticed in our previous steps, you had to tell MEW the ABI for the contract before you were able to interact with it. But wait, isn’t the contract on the blockchain visible and thus viewable by anyone? Well — like most things — yes and no. When we deploy a contract, we deployed the compiled bytecode. This bytecode cannot be used by others to engineer the original contract, but much like hashing, given a contract you can easily verify that its compiled bytecode is the same.
That said, if you want others to interact with the contract, you need to share the ABI with them. Further, if you’re providing a product or service and you want users to trust you, you may need to display your full contract code so that it can be audited to make sure your contract isn’t doing anything malicious such as stealing funds.
EtherScan supports Contract Source verification, by which the contract creator shares the source. When you do, EtherScan compiles the contract to make sure it matches the contract deployed, and then shares the ABI for anyone to use.
Additionally, as we saw in the MEW
getNumber example, EtherScan can read data from the contract without any transactions neeeded!
Testing with Kovan
Kovan is one of Ethereum Proof of Authority testnet. As such, you wouldn’t mine for ETH as on the Ropsten testnet. Opening a wallet is as easy as going to MEW, selecting the Kovan network, and creating a wallet through the standard procedure.
Once you’ve done that, go to Kovan’s Gitter and ask the team to send ETH to your address. By default, only 5 ETH is sent to addresses (much more than the 0.005 ETH I needed for this contract) to prevent abuse.
Use my referral link on Coinbase to claim $10 in free Bitcoin when you buy your first $100 in any cryptocurrency using the link here.