Posts on Program the Blockchain

Introduction to Ethereum Payment Channels Video

Mon, 10 Dec 2018 00:00:00 +0000

We’ve created a short (32-minute) video to help explain Ethereum payment channels—what they are and how they work. This video complements two of our previous posts: Writing a Simple Payment Channel and Building Long-lived Payment Channels.

Implementing Harberger Tax Deeds

Wed, 19 Sep 2018 00:00:00 +0000

This post will demonstrate how to implement deeds that collect a “Harberger tax”. The recently published book, Radical Markets: Uprooting Capitalism and Democracy for a Just Society, proposed Harberger taxes for a number of applications. Since then Vitalik Buterin (here) and Simon de la Rouviere (here) have speculated on smart contract applicability.

Writing a Dollar Auction Contract

Thu, 16 Aug 2018 00:00:00 +0000

This post will implement a “dollar auction” contract for ERC20 tokens. It will be a modest change to the English auction contract.

Writing a Penny Auction Contract

Wed, 08 Aug 2018 00:00:00 +0000

This post will implement a bidding fee auction (aka “penny auction”) contract for ERC20 tokens. It will be a modest change to the English auction contract.

Contracts Calling Arbitrary Functions

Thu, 02 Aug 2018 08:58:52 -0400

Solidity offers convenient high-level syntax for calling functions in other contracts, but this high-level syntax is only available when the target contract’s interface is known at compile time. In this post, I’ll show how smart contracts can use low-level message passing to make arbitrary calls into other contracts. I’ll use this mechanism to enhance our trivial multisig wallet so that it can make function calls in addition to transferring ether.

Anatomy of Transaction Data

Wed, 25 Jul 2018 12:46:04 -0400

[This blog post explains how transaction data is used to invoke smart contracts in Ethereum, but it is not necessary for learning Solidity programming. We write it for those of you who would like a deeper understanding of what is going on when a transaction is sent to a smart contract.]

In our previous post How Ethereum Transactions Work, we mentioned that the data field of a transaction encodes what (if any) smart contract function should be invoked. In this post, I’ll dive deeper into the specifics of the data field.

State Channels with Signing Keys

Wed, 18 Jul 2018 12:38:49 -0700

In this post, I’ll show how a temporary signing key can be used to improve the user experience of working with state channels.

Writing a Trivial Multisig Wallet

Wed, 11 Jul 2018 10:15:50 -0700

This post will demonstrate a very simple multisig wallet. This multisig wallet requires unanimous consent for the transfer of funds, and the consent is collected off-chain via signed messages.

Performing Multiple Actions Transactionally

Fri, 06 Jul 2018 08:41:23 -0700

This post will demonstrate a simple technique for combining multiple actions into a single transaction. This will enable you to be certain that you get “all or nothing” execution of the combined actions. It builds on Ensuring the Effects of a Transaction.

Ensuring the Effects of a Transaction

Thu, 28 Jun 2018 11:35:44 -0700

This post will demonstrate a simple technique for ensuring that a transaction had the desired effects.

Working with State Channels in JavaScript

Sat, 23 Jun 2018 08:26:13 -0700

In this post, I’ll show how to build a JavaScript front end for a two-player game based on state channels.

This post is a continuation of my previous posts “Two-Player Games in Ethereum” and “State Channels for Two-Player Games.” This post assumes that you’ve read and understood those.

Supporting an Off-Chain Market Maker

Sat, 16 Jun 2018 06:33:49 -0700

This post will implement a token-trading “market maker” that will fulfill multiple signed prediction market wagers simultaneously. It will be a modest change to the clearinghouse contract presented earlier, and it will exploit the token-based prediction market contract unchanged.

Betting Tokens In A Prediction Market

Tue, 12 Jun 2018 07:37:58 -0700

This post will describe how to implement a prediction market where bets are for ERC20 tokens rather than ether.

Reversible Ether

Sat, 09 Jun 2018 09:13:25 -0700

In this post, I’ll develop an ERC20 token that acts as “reversible ether” as described by Ethereum’s creator, Vitalik Buterin:

Someone should come along and issue an ERC20 called "Reversible Ether" that is 1:1 backed by ether but has a DAO that can revert transfers within N days.

–Vitalik Buterin, April 2018

Supporting Off-Chain Token Trading

Wed, 06 Jun 2018 07:56:25 -0700

This post will implement a token trading “clearinghouse” that will execute multiple signed trade offers simultaneously.

Storage Patterns: Set

Sun, 03 Jun 2018 07:14:02 -0700

In this post, I’ll build a minimal enumerable set in Solidity. A set stores unordered values without repetition.

Escrowing ERC20 Tokens

Wed, 30 May 2018 08:56:35 -0700

[EDIT 2018-06-05] This post has been edited to introduce a transfer function.

This post describes a simple contract to escrow ERC20 tokens for a period of time. Keeping tokens (or ether) in escrow is a common pattern in smart contracts.

Wrapping Ether in an ERC20 Token

Sat, 26 May 2018 07:58:51 -0700

In this short post, I’ll show how ether can be “wrapped” in an ERC20-compatible token. This means ether can be used anywhere that an ERC20 token is expected.

Writing a Prediction Market Contract

Tue, 22 May 2018 05:33:00 -0700

This post will demonstrate how to write a smart contract that implements a prediction market. The contract will leverage much of the logic in my token-based parimutuel betting contract.

Using Tokens for Parimutuel Wagers

Fri, 18 May 2018 05:21:04 -0700

This post describes an alternative implementation of parimutuel wagering to my original post. This implementation will use ERC20 tokens to represent wagers.

Changing the Supply of ERC20 Tokens

Wed, 16 May 2018 05:15:24 -0700

[EDIT 2018-05-25] This post has been edited to introduce a BaseERC20Token contract.

This short post will add dynamic control of the total supply of tokens to the previously introduced simple ERC20 tokens.

State Channels for Two-Player Games

Fri, 11 May 2018 13:31:35 -0400

This post will introduce the concept of state channels in the context of a two-player game. I’ll enhance the contract from Two-Player Games in Ethereum to support making moves in the game without sending transactions. By avoiding on-chain transactions, the new game will be faster and less expensive.

Writing a Parimutuel Wager Contract

Tue, 08 May 2018 05:37:16 -0700

This post will demonstrate how to write a smart contract that implements parimutuel betting. The contract will accept and pay off bets on the outcome of a single proposition.

Two-Player Games in Ethereum

Fri, 04 May 2018 09:57:46 -0400

This is the first post in a series about building efficient two-player games in Ethereum. This post will demonstrate a simple, but complete, smart contract that implements a variant of “the 21 game.”

Writing a Dominant Assurance Contract

Tue, 01 May 2018 06:15:04 -0700

This post will demonstrate how to write a smart contract that implements a “dominant assurance contract”. It assumes that you have read our previous post on vanilla assurance contracts.

Avoiding Integer Overflows: SafeMath Isn't Enough

Fri, 27 Apr 2018 12:20:05 -0400

This post describes what an integer overflow is and how to avoid them in smart contracts.

Writing a Periodic Loan Contract

Tue, 24 Apr 2018 05:28:18 -0700

This post will demonstrate how to write a smart contract that will administer an ether loan while holding ERC20 tokens as collateral. My previous post on a collateralized loan contract assumed that there would be just a single loan payment. This post will generalize that to a more typical structure where the loan requires equal payments at regularly-spaced intervals at a fixed interest rate.

Storage Patterns: Pagination

Fri, 20 Apr 2018 09:21:02 -0400

This post will show how to support pagination for returning large data sets from a smart contract. It builds on concepts introduced in my post on doubly-linked lists.

Keep Your Code Simple

Tue, 17 Apr 2018 08:43:38 -0400

This post will explain the importance of writing simple code in the context of smart contracts, where bugs can be very expensive.

Writing a Pawnshop Bazaar Contract

Fri, 13 Apr 2018 05:44:23 -0700

In our pawnshop post, we built a contract that creates loans between a lender and multiple borrowers using ERC20 tokens as collateral.

This post will demonstrate a token bazaar contract which creates and tracks many pawnshops on behalf of many lenders.

Capture the Ether: the Game of Smart Contract Security

Tue, 10 Apr 2018 09:39:49 -0700

Capture the Ether is a game that tests your understanding of smart contract security by challenging you to hack a series of smart contracts.

Writing a Vickrey Auction Contract

Tue, 03 Apr 2018 11:00:33 -0700

This post will demonstrate how to implement a Vickrey auction. The post assumes you are familiar with techniques introduced in my post on sealed-bid auctions.

Storage Patterns: Doubly Linked List

Fri, 30 Mar 2018 09:44:41 -0700

In this post, I’ll build a doubly linked list in Solidity. A doubly linked list supports efficient insertion and deletion of nodes anywhere within an ordered list. I’ll be building on concepts introduced in “Understanding Ethereum Smart Contract Storage” and “Storage Patterns: Stacks, Queues, and Deques”.

Writing a Sealed-Bid Auction Contract

Tue, 27 Mar 2018 09:32:58 -0700

This post will demonstrate how to implement a first-price sealed-bid auction of ERC20 tokens. The post assumes you are familiar with techniques introduced in our posts on English auctions and revealing secrets.

Storage Patterns: Stacks Queues and Deques

Fri, 23 Mar 2018 07:58:57 -0700

In this post, I’ll show how a few common data structures can be implemented in Solidity. I recommend first reading our post “Understanding Ethereum Smart Contract Storage.”

Writing a Token Auction Contract

Tue, 20 Mar 2018 10:39:42 -0700

This post will demonstrate how to write a smart contract that will auction off ERC20 tokens to the highest bidder. The post assumes you are familiar with techniques for how a contract deals with an ERC20 token contract, which we covered in our token sale post. The post will briefly touch on some of the challenges around conducting auctions on the blockchain.

Flipping a Coin in Ethereum

Fri, 16 Mar 2018 11:09:36 -0700

In this post, I’ll describe how two parties can bet on a coin flip in an Ethereum smart contract by using a simple commitment scheme.

Writing an ERC20 Pawnshop Contract

Tue, 13 Mar 2018 06:11:09 -0700

This post will demonstrate how to write a pawnshop-like smart contract that will lend ether to anybody willing to provide ERC20 tokens as collateral. The post adopts and generalizes techniques that we covered in our collateralized-loan post.

Understanding Ethereum Smart Contract Storage

Fri, 09 Mar 2018 06:45:17 -0800

Ethereum smart contracts use an uncommon storage model that often confuses new developers. In this post, I’ll describe that storage model and explain how the Solidity programming language makes use of it.

Writing a Collateralized Loan Contract

Tue, 06 Mar 2018 07:13:04 -0700

[EDIT 2018-03-13] This post has been updated to use Solidity 0.4.21 event syntax.

This post will demonstrate how to write a smart contract that will administer an ether loan while holding ERC20 tokens as collateral. The post assumes you are familiar with techniques for how a contract deals with an ERC20 token contract, which we covered in our token sale post. The post introduces the technique of having a smart contract deploy a second contract to carry out future work.

Building Long-Lived Payment Channels

Fri, 02 Mar 2018 04:56:33 -0800

[EDIT 2018-12-10] Since publishing this post, We’ve added a related video explanation of payment channels.

[EDIT 2018-03-13] This post has been updated to use Solidity 0.4.21 event syntax.

In Writing a Simple Payment Channel, I introduced payment channels as a way to reduce the number of Ethereum transactions required for repeated payments between the same two parties. This post will improve upon that post’s SimplePaymentChannel contract to make it suitable for long-lived payment channels, such as might be used to pay an employee an hourly wage over the course of their career.

Writing a Token Market Contract

Tue, 27 Feb 2018 06:13:43 -0700

[EDIT 2018-03-13] This post has been updated to use Solidity 0.4.21 event syntax.

This post will demonstrate how to write a smart contract that creates a token marketplace, where people can buy and sell ERC20 tokens. The smart contract acts like eBay by enabling sellers to list tokens for sale, and then brokering sales to buyers. This post relies on concepts introduced in our post on ERC20 tokens.

Writing a Simple Payment Channel

Fri, 23 Feb 2018 10:28:42 -0800

[EDIT 2018-12-10] Since publishing this post, We’ve added a related video explanation of payment channels.

In this post, I’ll build a simple, but complete, implementation of a payment channel. Payment channels use cryptographic signatures to make repeated transfers of ether securely, instantaneously, and without transaction fees. This post will rely heavily on the concepts and code from our post “Signing and Verifying Messages in Ethereum”.

Writing an Estate Planning Contract

Tue, 20 Feb 2018 13:05:14 -0800

[EDIT 2018-03-13] This post has been updated to use Solidity 0.4.21 event syntax.

This post will demonstrate how to write a smart contract that transfers your ether to a beneficiary after you die. It assumes that you have read our previous post on dealing with time on the blockchain.

Signing and Verifying Messages in Ethereum

Sat, 17 Feb 2018 06:47:55 -0800

Cryptographic signatures are a powerful primitive in Ethereum. Signatures are used to authorize transactions, but they’re a more general tool that’s available to smart contracts. Signatures can be used to prove to a smart contract that a certain account approved a certain message.

Writing A Robust Dividend Token Contract

Tue, 13 Feb 2018 13:29:03 -0800

[EDIT 2018-03-13] This post has been updated to use Solidity 0.4.21 event syntax.

The simple dividend token post made one big simplifying assumption—it assumed that there were few token units compared to the number of wei in a typical dividend deposit. This assumption meant that the contract could ignore the fact that integer divisions could result in some wei being forever wasted. This post will demonstrate how to write an ERC20-compliant token contract that is robust to that problem.

End to End: Initial Coin Offering

Fri, 09 Feb 2018 12:10:47 -0800

In this post, I’ll walk through the end-to-end process of deploying a new ERC20-compatible token, a token sale contract to sell it, and a website to help users buy the token.

Writing A Simple Dividend Token Contract

Wed, 07 Feb 2018 05:49:29 -0700

[EDIT 2018-03-13] This post has been updated to use Solidity 0.4.21 event syntax.

Tokens can provide rights or privileges to their owners. One of the most natural is the right to share proportionally in an income stream. This post will demonstrate how to write an ERC20-compliant contract that can divide ether dividends proportionally amongst token owners. This post combines ideas from our ERC20 token post, and our banking post.

Writing a Token Sale Contract

Fri, 02 Feb 2018 12:14:20 -0800

[EDIT 2018-03-13] This post has been updated to use Solidity 0.4.21 event syntax.

In this post, I’ll build a simple smart contract that sells a limited supply of an Ethereum-based token for a fixed price. To understand this post, you’ll need to be familiar with ERC20 Tokens.

Writing an ERC20 Token Contract

Tue, 30 Jan 2018 13:33:39 -0800

[EDIT 2018-03-13] This post has been updated to use Solidity 0.4.21 event syntax.

This post will demonstrate how to write a simple, but complete, smart contract in Solidity that implements the ERC20 token standard. It assumes that you are familiar with concepts introduced in our post, What is an Ethereum Token?, which discussed how tokens are maintained as per-account balances and how those balances can be transferred between accounts.

What is an Ethereum Token?

Fri, 26 Jan 2018 09:15:05 -0800

This post explains what an Ethereum “token” or “coin” is (and is not). It will convey an intuitive understanding of tokens and describe the implementation of a very simple token in Solidity.

Logging and Watching Solidity Events

Wed, 24 Jan 2018 08:04:38 -0800

[EDIT 2018-03-13] This post has been updated to use Solidity 0.4.21 event syntax. Events are a way for smart contracts written in Solidity to log that something has occurred. Interested observers, notably JavaScript front ends for decentralized apps, can watch for events and react accordingly. In this post, I’ll show you how to log events from a Solidity smart contract and watch those events in JavaScript. The code in this post builds on the example from the earlier post, Building Decentralized Apps With Ethereum and JavaScript.

Writing a Crowdfunding Contract (a la Kickstarter)

Fri, 19 Jan 2018 06:11:30 -0700

This post will demonstrate how to write a smart contract that controls a crowdfunding effort in the spirit of Kickstarter. It assumes that you have read our previous posts on banking and time.

Verifying Contract Source Code

Tue, 16 Jan 2018 09:16:05 -0800

For a deployed smart contract to be trusted, its source code should be available for inspection. This post explains why source code for smart contracts should be published and how someone can verify that published source code corresponds to a given deployed smart contract.

Writing a Contract That Handles Time

Fri, 12 Jan 2018 09:22:33 -0800

This post will demonstrate how to write a simple, but complete, smart contract in Solidity that deals with time. It assumes that you have read our previous post, Checking the Sender In a Smart Contract.

How Smart Contract Deployment Works

Tue, 09 Jan 2018 07:20:47 -0800

[This blog post explains a little bit about how smart contract deployment works in an Ethereum network, but it is not necessary for learning Solidity programming. We write it for those of you who’d like a little deeper understanding of what is going on when a smart contracts are deployed.] In our How Ethereum Transactions Work post, we described the essential elements of a transaction message in an Ethereum network and how they work.

Writing a Banking Contract

Fri, 05 Jan 2018 13:10:30 -0800

This article will demonstrate how to write a simple, but complete, smart contract in Solidity that acts like a bank that stores ether on behalf of its clients. The contract will allow deposits from any account, and can be trusted to allow withdrawals only by accounts that have sufficient funds to cover the requested withdrawal.

Making Smart Contracts with Public Variables

Tue, 02 Jan 2018 07:08:58 -0500

State variables in Solidity, like functions, have a notion of visibility. By default, they are not marked as “public,” but this is a somewhat confusing concept in the context of a public blockchain, where all data can be read by anyone. In this post, I’ll give an overview of state variable visibility and explain why and how to mark a state variable as public. Nothing is Hidden The nature of a public blockchain like Ethereum is that all data is replicated on all nodes.

How Ethereum Transactions Work

Fri, 29 Dec 2017 09:33:18 -0500

[This blog post explains a little bit about how transactions work in Ethereum, but it is not necessary for learning Solidity programming. We write it for those of you who’d like a little deeper understanding of what is going on when a transaction is attempted.] Smart contracts are interesting because of the side-effects they can have—including transferring ether—when executing transactions. How exactly are transactions constructed and sent to the network?

Checking the Sender in a Smart Contract

Tue, 26 Dec 2017 10:26:27 -0500

This article will demonstrate how to write a simple, but complete, smart contract in Solidity that accepts and distributes ether on behalf of the contract’s owner. It assumes that you are comfortable with the ether-handling concepts introduced in our last Solidity example blog post.

Testing and Deploying Smart Contracts with Remix

Tue, 19 Dec 2017 07:11:31 -0500

In my post Building Decentralized Apps With Ethereum and JavaScript, I showed how to write a front end for a smart contract that was already deployed to the Ethereum network. This post will cover how that smart contract got deployed. I’ll walk you through compiling a smart contract, doing some basic testing, and deploying it to the world.

There are a number of tools available for compiling, testing, and deploying smart contracts. For this post, I’ll use Remix, which has the advantage of being entirely browser-based. This means you’ll be able to compile, deploy, and test smart contracts without installing any local tools.

Be Careful When Using the Solidity Fallback Function

Sat, 16 Dec 2017 04:46:36 -0700

This post will discuss Solidity’s anonymous “fallback function”, which is a commonly used mechanism for accepting ether transfers. This post expands a topic briefly mentioned in the post, Writing a Contract That Handles Ether. Below, we explain what this function does and why we encourage caution when using it.

Writing a Contract That Handles Ether

Fri, 15 Dec 2017 15:13:40 -0700

This post will demonstrate how to write a simple, but complete, smart contract in Solidity that accepts and distributes ether. It assumes that you have read our previous post, Writing a Very Simple Smart Contract.

Building Decentralized Apps With Ethereum and JavaScript

Wed, 13 Dec 2017 08:26:31 -0500

For users to be able to interact with a smart contract, they need some sort of user interface. The standard means of providing this interface in Ethereum is called a “decentralized app.”

Writing a Very Simple Smart Contract

Fri, 08 Dec 2017 05:48:50 -0700

This article will demonstrate how to write a simple, but complete, smart contract in Solidity that maintains and updates persistent state. The demonstration will begin with an even simpler contract, which is progressively enhanced in two steps. Future articles will build on these ideas to construct more complicated and interesting smart contracts.

What Is a Smart Contract?

Wed, 06 Dec 2017 08:29:53 -0500

An Ethereum “smart contract” is a computer program that has been deployed to the Ethereum blockchain, where it will exist forever. Deployed smart contracts represent many different capabilities: