Creating a Celo-based prediction market using Augur


In this tutorial, we will delve into the world of blockchain-based prediction markets, exploring how they function and how we can create one using Augur on the Celo blockchain. By the end of this guide, you will be equipped with the necessary skills and knowledge to build your own prediction markets on the Celo blockchain using Augur.

Code repository for our tutorial


  • Familiarity with blockchain technology, smart contracts, and Solidity

  • Basic knowledge of Node.js and JavaScript

  • Basic understanding of how Augur and Celo work


  • Installed Node.js and npm on your computer

  • A code editor like Visual Studio Code

  • A Celo Wallet or compatible provider like Metamask

Steps and Processes for Creating a Prediction Market using Augur

Understanding Prediction Markets and Augur

Prediction markets are speculative markets where participants trade on the outcome of future events. Augur is a decentralized oracle and peer-to-peer protocol for prediction markets on Ethereum, allowing users to create their own markets for specific questions they may have.

Setting Up the Development Environment

Install Celo Development Kit:
We will be using ContractKit, a Celo SDK, to interact with the Celo blockchain.


npm install @celo/contractkit

Install Augur packages: Augur provides several NPM packages that simplify interacting with Augur-based prediction markets.


npm install augur.js

Configure Metamask or Celo Wallet: Ensure your wallet is configured to work with the Celo network.

Developing Smart Contracts for the Prediction Market

Writing the Contracts: Write your smart contracts in Solidity that define the logic for your prediction market. You’ll need contracts for handling market creation, betting, resolving markets, and paying out.

create a new file named Market.sol and add the following code:

contract Market {
    struct MarketInfo {
        string question;
        uint256 betAmount;
        address creator;
    MarketInfo[] public markets;
    function createMarket(string memory question) public {
            question: question,
            betAmount: 0,
            creator: msg.sender

Create another file named Bet.sol and add the following code:

import "./Market.sol";

contract Bet {
    Market public market;

    constructor(address _market) {
        market = Market(_market);


Compiling the Contracts : Use Truffle to compile your contracts.


truffle compile

Testing the Contracts : Write tests for your contracts to ensure they behave as expected.


truffle test

Deploying the Contracts : Once your contracts are written and tested, deploy them to the Celo network.

truffle migrate --network celo

Interacting with the Prediction Market

We will use a web interface to interact with our prediction market. Here’s a high-level overview of how to set this up:

Setting up a Web3 Provider: We’ll use Web3.js to connect our web interface with our blockchain.

const Web3 = require('web3');

const web3 = new Web3('http://localhost:8545'); // Use the URL of your Celo node

Connecting to the Contracts : Use the ContractKit and Augur.js to interact with your deployed contracts.

const contractKit = require('@celo/contractkit');

const kit = contractKit.newKit('http://localhost:8545');

const augur = new Augur();

Creating Markets : Write functions that let users create new markets on the platform.

Creating Markets: Write functions that let users create new markets on the platform.

function createMarket(question) {
  const txObject = market.methods.createMarket(question);
  const tx = await kit.sendTransactionObject(txObject);
  const receipt = await tx.waitReceipt();
  console.log('Market created:', receipt.transactionHash);

Placing Bets : Similarly, write functions that allow users to place bets on these markets.

function placeBet(marketAddress, betAmount) {
  const txObject = market.methods.placeBet(marketAddress, betAmount);
  const tx = await kit.sendTransactionObject(txObject);
  const receipt = await tx.waitReceipt();
  console.log('Bet placed:', receipt.transactionHash);

Resolving Markets : Finally, you’ll need functions that resolve the markets and pay out users based on the results.

function resolveMarket(marketAddress, outcome) {
  const txObject = market.methods.resolveMarket(marketAddress, outcome);
  const tx = await kit.sendTransactionObject(txObject);
  const receipt = await tx.waitReceipt();
  console.log('Market resolved:', receipt.transactionHash);

Security Best Practices

Ensure that you observe best security practices when developing your prediction market:

  • Keep private keys secure and never expose them in your code or version control system.
  • Make sure to test your smart contracts thoroughly for any potential security vulnerabilities.
  • Use the OpenZeppelin library to secure your smart contracts.


This tutorial provides a step by step process of creating a Celo-based prediction market using Augur. While the exact code will depend on your specific requirements, this guide should give you a solid foundation from which to begin your development journey. Remember, developing on the blockchain is a continually evolving field. Always stay updated with the latest security practices and updates to the Celo and Augur platforms.

About the Author​

Ernest Nnamdi is a Web3, Solidity, Python developer and content creator with over 5 years of experience in the tech industry. He has always been fascinated by emerging technologies and have a strong passion for blockchain and its potential to change the world.

Connect with me on Twitter


Augur Documentation: The official documentation for Augur provides detailed information on how to use Augur and interact with its smart contracts. You can find it at:

Celo Documentation: The official documentation for Celo provides comprehensive resources on developing applications on the Celo blockchain. You can find it at:

Solidity Documentation: Solidity is the programming language used for writing smart contracts on Ethereum and other blockchain platforms. The Solidity documentation provides in-depth information on the language and its features. You can find it at:

Truffle Documentation: Truffle is a popular development framework for Ethereum and other blockchains. The Truffle documentation covers various aspects of smart contract development, testing, and deployment. You can find it at: Truffle Documentation - Truffle Suite


A great idea. I look forward to the outcome.


This proposal has to earn my vote, looking forward to the implementation


This looks good and solid


This should be interesting


Very interesting
I am particularly interested in seeing how you would utilise the Augur protocol


Fantastic news! Your proposal has landed in this week’s top voted list. As you begin your project journey, remember to align with our community and technical guidelines, ensuring a high quality platform for our developers. Congratulations! :mortar_board: :seedling:


Anticipating the full tutorial


I will be reviewing this in a day or two