Smart Contracts in Ethereum, Solidity, and Geth: first impression

Today is another exciting day, because I was able to build and deploy a simple smart contract on the Ethereum production chain.

What is a smart contract? A contract that is signed and executed digitally, between one or several parties. For example, a Zipcar rental can be described as a smart contract, since all steps from booking to unlocking, to returning the car are automated. A traditional car rental is not a smart contract, since it requires me to sign several papers and the counter person to physically give me the key to the car.

What about distributed smart contracts? They are smart contracts that can be signed and enforced via a decentralized network - so unlike the Zipcar rental, they may not require a corporation intermediary.

Why are distributed smart contracts important? Because much of modern economy is, in the end, about creating, documenting, settling, and litigating contracts, in a very centralized way. Smart contracts can remove the layer of intermediaries, so that people and companies can transact directly with each other. In the future, the smart contracts may even replace lawyers with coders, or have coders go to law school, or have lawyers learn how to code, whichever is easier. Of course, the application of blockchain is not limited to financial services - healthcare and governance projects are also being implemented.

Initial impression

Ethereum is still in early stages of development, and it is impressive what the team has accomplished to date. The blockchain is the first public one that actually permits execution of smart contracts, and the software is mostly easy to use. And all of this was crowd-funded by the sale of ether, the chain's cryptocurrency.

Ethereum and smart contracts are very different from the old-school coding - smart contracts are asynchronous. A "transaction" sent to a contract can take a minute to process and get "mined" - in the meanwhile, the contract remains in the old state. This is the cost of confirming the transaction by a consensus of mining nodes: we cannot be 100% sure a transaction has completed until it enters the main chain. In some instances, a transaction may end up on an orphaned block and then it will not be reflected in the state variables of the contract.

In practice, this considerable latency can be a barrier for fast retail transactions (image settling a restaurant bill!), but should not be a problem for deals where a few minutes' settlement is acceptable, or for person-to-person money transfers.

Technical steps

First and foremost, one needs a Ubuntu Linux computer. I used the digitalocean virtual box, which costs $10/month. This second-cheapest option, however, is barely sufficient to run the full Ethereum client. At this time, the 30GB of disk space is 90% full. On this computer, I installed the Geth Ethereum client. The steps for the installation can be found on Github - but be prepared to spend a couple of hours downloading dependencies. 

 When Geth starts for the first time, it will set up an Ethereum account with a passphrase. The passphrase must be saved securely, or else all funds in the account will be lost.

 Secondly, I needed Ether to deploy and run the contract. I started by buying Bitcoins on Circle. Then I swapped them for Ether on Shapeshift, using my new Ledger wallet as the source of funds. So the account managed by Geth was now populated.

Finally, my full client needed to synchronize with the blockchain. A great idea is to have Geth run in the background, because it will take several hours for the client to synchronize, and the state database to download. A great reference is here: https://hiddentao.com/archives/2016/05/04/setting-up-geth-ethereum-node-to-run-automatically-on-ubuntu/. Then the interactive geth can be started with 'geth attach'.

The code that I executed can be seen below. It creates a Messenger contract, where anybody can send a message, and anybody can read it. This 'contract' is extremely simplified on purpose, because in the Ethereum world, each increase in complexity takes several hours or days to go through. In my next experiment, I will implement a multi-party contract with conditional payments.

The resulting contract can be seen at the following address: http://etherscan.io/address/0xe9b57fd6c767893b0fa5de7206fb2917e748bcb1

Code

Geth is an interactive Javascript shell. To deploy the contract, I entered the following commands in the shell. One key point about the code is the amount of gas specified in the deployment command. I used the online Solidity compiler on Github to check that amount. Too little gas will get the contract rejected, and too much gas is wasteful, because it will be collected from my Ether money.

var contractSource = 'contract Messenger {

     string message;
    address owner;

     function Messenger() {
        owner = msg.sender;
        message = "";
    }

     function kill() { if (msg.sender == owner) selfdestruct(owner);}

     function SendMessage(string message_) {
        message = message_;
    }
    
    function ReceiveMessage() constant returns (string)
    {
        return message;
    }
}';

 var contractCompiled = web3.eth.compile.solidity(contractSource);

 var myContract = web3.eth.contract(contractCompiled.Messenger.info.abiDefinition);

 web3.eth.defaultAccount = web3.eth.accounts[0];

 personal.unlockAccount(web3.eth.defaultAccount);

 var messenger = myContract.new({from:web3.eth.accounts[0], data: contractCompiled.Messenger.code, gas: 309425}, function(e, contract){
    if(!e) {

       if(!contract.address) {
        console.log("Contract transaction send: TransactionHash: " + contract.transactionHash + " waiting to be mined...");

       } else {
        console.log("Contract mined! Address: " + contract.address);
        console.log(contract);
      }

     } else {
        console.log("e is true");
        console.log(e);
    }
})

 personal.unlockAccount(web3.eth.defaultAccount);
messenger.SendMessage("Monkey");

 messenger.ReceiveMessage();

 personal.unlockAccount(web3.eth.defaultAccount);

 messenger.SendMessage("Orangutan")

 messenger.ReceiveMessage();

 personal.unlockAccount(web3.eth.defaultAccount);

 messenger.kill();

 Result

 The contract results can be seen here:

 http://etherscan.io/address/0xe9b57fd6c767893b0fa5de7206fb2917e748bcb1

Screenshots




Comments

Post a Comment

Popular posts from this blog

A smart collateralized non-recourse futures contract on Ethereum: first impression

Image
Today is yet another exciting day, because I just built the first "smart" Ethereum contract that performs a futures trade between two parties. The contract allows two entities with Ethereum accounts to enter into an ether-settled, margined futures agreement on any market (or non-market!) variable - be that the closing price of SP 500, the air temperature at Noon in downtown Manhattan, or a hurricane event in the Caribbean. Why are smart distributed financial contracts important? The world creates a huge notional volume of "exchange-traded" and "over-the-counter" derivative transactions. At this time, these transactions go through investment banks and through exchanges, adding a layer of fees for buy-side institutions and individual investors. If the decentralization trend continues, we will see this marketplace evolve from fees based on volume ("spread") to fees based on access, or consulting fees, making trading cheaper. Smart contracts and E...
Read more

Ethereum Client Platforms: Parity versus Go-Ethereum

Image
The next step in the Ethereum world, after mastering the basics of the Solidity language and the smart contract development, is about developing simple production applications. The key ingredient here is client software. In this article, I review parity , the newer client software layer, and compare it to geth, the product of the Homestead project. What does the client software do? It downloads the whole blockchain onto your system on a regular basis, keeping the tab on the whole network. It verifies all transactions and contracts on the blockchain. If you are building your own contracts, it broadcasts them to the network so that they are included in the next block and confirmed by the miners. Client software can also do the mining but these days you may need a super-computer do make any ether this way. Why is this important? In order to successfully integrate blockchain transactions into a real-world application, a reliable client layer is needed. Just using https://etherscan...
Read more

How to steal money in Ethereum (and how to protect your Ether)

Ethereum's smart contracts can be deceptively easy to code, but the devil is in the details. This post is about the vulnerability underneath the DAO hack and the preventative measures. First of all, I am grateful to Daniel Nagy, my friend and an Ethereum developer, for explaining the below material concisely. This is public material but not so trivial to understand, especially when written for technical audiences, so here you go - a simple explanation of the DAO hack and the ways to design your contract to avoid being a victim of this type of attack. You and a group of 5 friends want to get into a Drake concert, but do not want to pay for 6 tickets. How get around it? You look around the concert site and find that the people that check the tickets do not stamp or take them away - and the fence around the concert area is tall, but a chain-link type - and now the solution is trivial. You buy one ticket, agree on a secret meeting spot with your friends around the fence of the con...
Read more