Pitching yourself as the “Internet of Blockchains'' is no small feat, but it conveys the ambition of Cosmos: to create a network where different blockchains can communicate and scale together. It’s similar to Polkadot but it prioritizes the sovereignty of independent blockchains, meaning they must secure themselves and have their own governance and validators.  

Cosmos

1 hour

2 hours +

Intermediate

Advanced

JS/TS

Application specific chains

Javascript

Tools & Infra

Time Commitment

Difficulty

Programming Language

Feature

Technology

[**The original tutorial can be found in the Cosmos SDK documentation here**](https://tutorials.cosmos.network/starport-blog/tutorial/01-index.html). 

# Introduction

By following this tutorial, you will learn how to create a simple blog app that is powered by the Cosmos SDK.

# Getting Started

Let's get started! The first step is to install the [starport](https://github.com/tendermint/starport) CLI tool.

After `starport` is installed, use it to create the initial app structure inside a directory named `blog`:

```text
starport app github.com/example/blog
```

One of the main features of Starport is code generation. The command above has generated a directory structure with a working blockchain application. Starport can also add data types to your app with `starport type` command. To see it in action, follow the [poll application tutorial](https://learn.figment.io/tutorials/build-a-polling-app). In this guide, however, we'll create those files manually to understand how it all works under the hood.

# Overview

Let's take a quick look at what Starport has generated for us. The [`app/app.go`](https://docs.cosmos.network/master/basics/app-anatomy.html#core-application-file) file imports and configures SDK modules and creates a constructor for our application that extends a [basic SDK application](https://docs.cosmos.network/master/core/baseapp.html) among other things. This app will use only a couple of standard modules bundled with the Cosmos SDK $including `auth` for dealing with accounts and `bank` for handling coin transfers$ and one module $`x/blog`$ that will contain custom functionality.

In `cmd` directory we have source files of two programs for interacting with our application: `blogd` starts a full-node for your blockchian and `blogcli` enables you to query the full-node, either to update the state by sending a transaction or to read it via a query.

This blog app will store data in a persistent [key-value store](https://docs.cosmos.network/master/core/store.html). Similarly to most key-value stores, you can retrieve, delete, update, and loop through keys to obtain the values you are interested in.

We’ll be creating a simple blog-like application, so let’s define the first type, the `Post`.

**`x/blog/types/TypesPost.go`**

```go
package types

import (
	sdk "github.com/cosmos/cosmos-sdk/types"
)

type Post struct {
	Creator sdk.AccAddress `json:"creator" yaml:"creator"`
	ID      string         `json:"id" yaml:"id"`
	Title   string         `json:"title" yaml:"title"`
	Body    string         `json:"body" yaml:"body"`
}
```

The code above defines the three properties of a post: Creator, Title and ID. The SDK provides useful types to represent things like addresses, so we use `sdk.AccAddress` for Creator. A Title is stored as a string. Lastly, we generate unique global IDs for each post and also store them as strings.

Posts in our key-value store will look like this:

```text
"post-0bae9f7d-20f8-4b51-9d5c-af9103177d66": {
  "Creator": "cosmos18cd5t4msvp2lpuvh99rwglrmjrrw9qx5h3f3gz",
  "Title": "This is a post!",
  "Body": "Welcome to my blog app.",
  "ID": "0bae9f7d-20f8-4b51-9d5c-af9103177d66"
},
"post-8c6d8cd4-b4c9-4ba3-a683-e894db3f2605": {
  ...
}
```

Right now the store is empty. Let's figure out how to add posts.

With the Cosmos SDK, users can interact with your app with either a CLI $`blogcli`$ or by sending HTTP requests. Let's define the CLI command first. Users should be able to type `blogcli tx blog create-post 'This is a post!' 'Welcome to my blog app.' --from=user1` to add a post to your store. The `create-post` subcommand hasn’t been defined yet--let’s do it now.

**`x/blog/client/cli/tx.go`**

In the `import` block, make sure to import these five additional packages:

```go
import (
  // Existing imports...
  "bufio"
  "github.com/cosmos/cosmos-sdk/client/context"
  "github.com/cosmos/cosmos-sdk/x/auth"
  "github.com/cosmos/cosmos-sdk/x/auth/client/utils"
  sdk "github.com/cosmos/cosmos-sdk/types"
)
```

This file already contains `func GetTxCmd` which defines custom `blogcli` [commands](https://docs.cosmos.network/master/building-modules/module-interfaces.html#cli). We will add the custom `create-post` command to our `blogcli` by first adding `GetCmdCreatePost` to `blogTxCmd`.

```go
blogTxCmd.AddCommand(flags.PostCommands(
    GetCmdCreatePost(cdc),
  )...)
```

At the end of the file, let's define `GetCmdCreatePost` itself.

```go
package cli

import (
	"bufio"

	"github.com/spf13/cobra"

	"github.com/cosmos/cosmos-sdk/client/context"
	"github.com/cosmos/cosmos-sdk/codec"
	sdk "github.com/cosmos/cosmos-sdk/types"
	"github.com/cosmos/cosmos-sdk/x/auth"
	"github.com/cosmos/cosmos-sdk/x/auth/client/utils"
	"github.com/sdk-tutorials/starport-blog/blog/x/blog/types"
)

func GetCmdCreatePost(cdc *codec.Codec) *cobra.Command {
	return &cobra.Command{
		Use:   "create-post [title] [body]",
		Short: "Creates a new post",
		Args:  cobra.MinimumNArgs(2),
		RunE: func(cmd *cobra.Command, args []string) error {
			argsTitle := string(args[0])
			argsBody := string(args[1])

			cliCtx := context.NewCLIContext().WithCodec(cdc)
			inBuf := bufio.NewReader(cmd.InOrStdin())
			txBldr := auth.NewTxBuilderFromCLI(inBuf).WithTxEncoder(utils.GetTxEncoder(cdc))
			msg := types.NewMsgCreatePost(cliCtx.GetFromAddress(), argsTitle, argsBody)
			err := msg.ValidateBasic()
			if err != nil {
				return err
			}
			return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg})
		},
	}
}
```

The function above defines what happens when you run the `create-post` subcommand. `create-post` takes two arguments `[title] [body]`, creates a message `NewMsgCreatePost` $with title as `args[0]` and `args[1]`$ and broadcasts this message to be processed in your application.

This is a common pattern in the SDK: users make changes to the store by broadcasting [messages](https://docs.cosmos.network/master/building-modules/messages-and-queries.html#messages). Both CLI commands and HTTP requests create messages that can be broadcasted in order for state transition to occur.

**`x/blog/types/MsgCreatePost.go`**

Let’s define `NewMsgCreatePost` in a new file you should create as `x/blog/types/MsgCreatePost.go`.

```go
package types

import (
	sdk "github.com/cosmos/cosmos-sdk/types"
	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
	"github.com/google/uuid"
)

var _ sdk.Msg = &MsgCreatePost{}

type MsgCreatePost struct {
	ID      string
	Creator sdk.AccAddress `json:"creator" yaml:"creator"`
	Title   string         `json:"title" yaml:"title"`
	Body    string         `json:"body" yaml:"body"`
}

func NewMsgCreatePost(creator sdk.AccAddress, title string, body string) MsgCreatePost {
	return MsgCreatePost{
		ID:      uuid.New().String(),
		Creator: creator,
		Title:   title,
		Body:    body,
	}
}

func (msg MsgCreatePost) Route() string {
	return RouterKey
}

func (msg MsgCreatePost) Type() string {
	return "CreatePost"
}

func (msg MsgCreatePost) GetSigners() []sdk.AccAddress {
	return []sdk.AccAddress{sdk.AccAddress(msg.Creator)}
}

func (msg MsgCreatePost) GetSignBytes() []byte {
	bz := ModuleCdc.MustMarshalJSON(msg)
	return sdk.MustSortJSON(bz)
}

func (msg MsgCreatePost) ValidateBasic() error {
	if msg.Creator.Empty() {
		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "creator can't be empty")
	}
	return nil
}
```

Similarly to the post struct, `MsgCreatePost` contains creator and title properties. We don’t include ID property, because `MsgCreatePost` defines only the data we accept from the user—we will be generating ID automatically on the next step.

```go
package types

import (
	sdk "github.com/cosmos/cosmos-sdk/types"
	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
	"github.com/google/uuid"
)

var _ sdk.Msg = &MsgCreatePost{}

type MsgCreatePost struct {
	ID      string
	Creator sdk.AccAddress `json:"creator" yaml:"creator"`
	Title   string         `json:"title" yaml:"title"`
	Body    string         `json:"body" yaml:"body"`
}

func NewMsgCreatePost(creator sdk.AccAddress, title string, body string) MsgCreatePost {
	return MsgCreatePost{
		ID:      uuid.New().String(),
		Creator: creator,
		Title:   title,
		Body:    body,
	}
}

func (msg MsgCreatePost) Route() string {
	return RouterKey
}

func (msg MsgCreatePost) Type() string {
	return "CreatePost"
}

func (msg MsgCreatePost) GetSigners() []sdk.AccAddress {
	return []sdk.AccAddress{sdk.AccAddress(msg.Creator)}
}

func (msg MsgCreatePost) GetSignBytes() []byte {
	bz := ModuleCdc.MustMarshalJSON(msg)
	return sdk.MustSortJSON(bz)
}

func (msg MsgCreatePost) ValidateBasic() error {
	if msg.Creator.Empty() {
		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "creator can't be empty")
	}
	return nil
}
```

`NewMsgCreatePost` is a constructor function that creates the `MsgCreatePost` message. The following five functions have to be defined to implement the `Msg` interface. They allow you to perform validation that doesn’t require access to the store $like checking for empty values$, etc.

```go
package types

import (
	sdk "github.com/cosmos/cosmos-sdk/types"
	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
	"github.com/google/uuid"
)

var _ sdk.Msg = &MsgCreatePost{}

type MsgCreatePost struct {
	ID      string
	Creator sdk.AccAddress `json:"creator" yaml:"creator"`
	Title   string         `json:"title" yaml:"title"`
	Body    string         `json:"body" yaml:"body"`
}

func NewMsgCreatePost(creator sdk.AccAddress, title string, body string) MsgCreatePost {
	return MsgCreatePost{
		ID:      uuid.New().String(),
		Creator: creator,
		Title:   title,
		Body:    body,
	}
}

func (msg MsgCreatePost) Route() string {
	return RouterKey
}

func (msg MsgCreatePost) Type() string {
	return "CreatePost"
}

func (msg MsgCreatePost) GetSigners() []sdk.AccAddress {
	return []sdk.AccAddress{sdk.AccAddress(msg.Creator)}
}

func (msg MsgCreatePost) GetSignBytes() []byte {
	bz := ModuleCdc.MustMarshalJSON(msg)
	return sdk.MustSortJSON(bz)
}

func (msg MsgCreatePost) ValidateBasic() error {
	if msg.Creator.Empty() {
		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "creator can't be empty")
	}
	return nil
}
```

Going back to `GetCmdCreatePost` in `x/blog/client/cli/tx.go`, you'll see `MsgCreatePost` being created and broadcast with `GenerateOrBroadcastMsgs`.

After being broadcast, the messages are processed by an important part of the application, called [**handlers**](https://docs.cosmos.network/master/building-modules/handler.html).

**`x/blog/handler.go`**

Begin by importing your new blog types that we created:

```go
import (
  // Existing imports...
  "github.com/example/blog/x/blog/types"
)
```

You should already have `func NewHandler` defined which lists all available handlers. Modify it to include a new function called `handleMsgCreatePost`.

```go
package blog

import (
	"fmt"

	sdk "github.com/cosmos/cosmos-sdk/types"
	"github.com/sdk-tutorials/starport-blog/blog/x/blog/keeper"
	"github.com/sdk-tutorials/starport-blog/blog/x/blog/types"
	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
)

// NewHandler ...
func NewHandler(k keeper.Keeper) sdk.Handler {
	return func(ctx sdk.Context, msg sdk.Msg) (*sdk.Result, error) {
		ctx = ctx.WithEventManager(sdk.NewEventManager())
		switch msg := msg.(type) {
    // this line is used by starport scaffolding
		case types.MsgCreateComment:
			return handleMsgCreateComment(ctx, k, msg)
		case types.MsgCreatePost:
			return handleMsgCreatePost(ctx, k, msg)
		default:
			errMsg := fmt.Sprintf("unrecognized %s message type: %T", types.ModuleName, msg)
			return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg)
		}
	}
}
```

Now let’s define `handleMsgCreatePost`:

```go
package blog

import (
	sdk "github.com/cosmos/cosmos-sdk/types"
	"github.com/sdk-tutorials/starport-blog/blog/x/blog/keeper"
	"github.com/sdk-tutorials/starport-blog/blog/x/blog/types"
)

func handleMsgCreatePost(ctx sdk.Context, k keeper.Keeper, msg types.MsgCreatePost) (*sdk.Result, error) {
	var post = types.Post{
		Creator: msg.Creator,
		ID:      msg.ID,
		Title:   msg.Title,
		Body:    msg.Body,
	}
	k.CreatePost(ctx, post)

	return &sdk.Result{Events: ctx.EventManager().Events()}, nil
}
```

In this handler you create a `Post` object $post type was defined in the very first step$. You populate the post object with creator, title, and body from the message $`msg.Creator`, `msg.Title`, and `msg.Body`$ and use the unique ID that was generated in `tx.go` with `NewMsgCreatePost()` using `uuid.New().String()`.

After creating a post object with creator, ID and title, the message handler calls `k.CreatePost(ctx, post)`. “k” stands for [Keeper](https://docs.cosmos.network/master/building-modules/keeper.html), an abstraction used by the SDK that writes data to the store. Let’s define the `CreatePost` keeper function.

**`x/blog/keeper/keeper.go`**

Add a `CreatePost` function that takes two arguments: a [context](https://docs.cosmos.network/master/core/context.html#context-definition) and a post.

```go
package keeper

import (
	"github.com/cosmos/cosmos-sdk/codec"
	sdk "github.com/cosmos/cosmos-sdk/types"
	"github.com/sdk-tutorials/starport-blog/blog/x/blog/types"
)

func (k Keeper) CreatePost(ctx sdk.Context, post types.Post) {
	store := ctx.KVStore(k.storeKey)
	key := []byte(types.PostPrefix + post.ID)
	value := k.cdc.MustMarshalBinaryLengthPrefixed(post)
	store.Set(key, value)
}

func listPost(ctx sdk.Context, k Keeper) ([]byte, error) {
	var postList []types.Post
	store := ctx.KVStore(k.storeKey)
	iterator := sdk.KVStorePrefixIterator(store, []byte(types.PostPrefix))
	for ; iterator.Valid(); iterator.Next() {
		var post types.Post
		k.cdc.MustUnmarshalBinaryLengthPrefixed(store.Get(iterator.Key()), &post)
		postList = append(postList, post)
	}
	res := codec.MustMarshalJSONIndent(k.cdc, postList)
	return res, nil
}
```

`CreatePost` creates a key by concatenating a post prefix with an ID. If you look back at how our store looks, you’ll notice keys have prefixes, which is why `post-0bae9f7d-20f8-4b51-9d5c-af9103177d66` contained the prefix `post-` . The reason for this is you have one store, but you might want to keep different types of objects in it, like posts and users. Prefixing keys with `post-` and `user-` allows you to share one storage space between different types of objects.

**`x/blog/types/key.go`**

To define the post prefix add the following code:

```go
package types

const (
	// ModuleName is the name of the module
	ModuleName = "blog"

	// StoreKey to be used when creating the KVStore
	StoreKey = ModuleName

	// RouterKey to be used for routing msgs
	RouterKey = ModuleName

	// QuerierRoute to be used for querier msgs
	QuerierRoute = ModuleName
)

const (
	PostPrefix = "post-"
)
		
const (
	CommentPrefix = "comment-"
)
```

**`x/blog/types/codec.go`**

Finally, `store.Set(key, value)` writes our post to the store. Two last things to do is tell our [encoder](https://docs.cosmos.network/master/core/encoding.html#amino) how our `MsgCreatePost` is converted to bytes.

```go
package types

import (
	"github.com/cosmos/cosmos-sdk/codec"
)

// RegisterCodec registers concrete types on codec
func RegisterCodec(cdc *codec.Codec) {
	// this line is used by starport scaffolding
	cdc.RegisterConcrete(MsgCreateComment{}, "blog/CreateComment", nil)
	cdc.RegisterConcrete(MsgCreatePost{}, "blog/CreatePost", nil)
}

// ModuleCdc defines the module codec
var ModuleCdc *codec.Codec

func init() {
	ModuleCdc = codec.New()
	RegisterCodec(ModuleCdc)
	codec.RegisterCrypto(ModuleCdc)
	ModuleCdc.Seal()
}
```

# Launch

Now we are ready to build and start our app and create some posts.

To launch your application run:

```text
starport serve
```

This command installs dependencies, builds and initializes the app, and runs servers. You can also do it manually:

1. `go mod tidy` cleans up dependencies.
2. `make` builds your app and creates two binaries in your go path: `blogd` and `blogcli`.
3. Initialization scripts in the `Makefile` removes data directories, configures your app and generates two accounts. By default your app stores data in your home directory in `~/.blogd` and `~/.blogcli`. The script removes them, so every time you have a clean state.
4. `blogd start` launches your app. After a couple of seconds you will see hashes of blocks being generated. Leave this terminal window open and open a new one.

Note: depending on your OS and firewall settings, you may have to accept a prompt asking if your application's binary $`blogd` in this case$ can accept external connections.

Run the following command to create a post:

```text
blogcli tx blog create-post "My first post" "This is a post\!" --from=user1
```

“This is a post!” is a title for our post and `--from=user1` tells the program who is creating this post. `user1` is a label for your pair of keys used to sign the transaction, created by the initialization script located within the `/Makefile` previously. Keys are stored in `~/.blogcli`.

After running the command and confirming it, you will see an object with “txhash” property with a value like `CA1491B39384A4F29E568F62B156E0F2D0601507EF499CE1B8F3930BAFE7F03C`.

To verify that the transaction has been processed, open a browser and visit the following URL $make sure to replace `CA14...` with the value of your txhash but make sure to keep the `0x` prefix$:

```text
http://localhost:26657/tx?hash=0xCA1491B39384A4F29E568F62B156E0F2D0601507EF499CE1B8F3930BAFE7F03C
```

Congratulations! You have just created and launched your custom blockchain and sent the first transaction 🎉

# Potential errors and their solutions

## Cannot find module providing package

```text
x/blog/client/cli/tx.go:12:2: cannot find module providing package github.com/cosmos/cosmos-sdk/client/utils: import lookup disabled by -mod=readonly
x/blog/client/cli/tx.go:75:59: undefined: sdk
```

Make sure you import all required packages in `x/blog/client/cli/tx.go`:

```go
import (
  // ...
  sdk "github.com/cosmos/cosmos-sdk/types"
  "github.com/cosmos/cosmos-sdk/x/auth/client/utils"
)
```

## Unknown command "create-post" for "blog"

```text
blogcli tx blog create-post 'Hello!' 'My first post' --from=user1
ERROR: unknown command "create-post" for "blog"
```

Make sure you’ve added `GetCmdCreatePost(cdc)`, to `func GetTxCmd` in `x/blog/client/cli/tx.go`.

## Cannot encode unregistered concrete type

```text
blogcli tx blog create-post Hello! --from=user1
panic: Cannot encode unregistered concrete type types.MsgCreatePost.
```

Make sure you’ve added `cdc.RegisterConcrete(MsgCreatePost{}, "blog/CreatePost", nil)` to `func RegisterCodec` in `x/blog/types/codec.go`.

# Conclusion

Congratulations, you now have a functioning blog app which stores its data on Cosmos!


Learn how to create a simple blog app using the Cosmos SDK

Create a blog module using Cosmos SDK

Learn how to build a scavenger game using the Cosmos SDK

Build a scavenger game

Learn how to create a simple transaction search widget using Figment's Transaction Search API and DataHub

Create a transaction search widget

Learn how to build a nameservice application with the Cosmos SDK

Build a nameservice application

[**The original tutorial can be found in the Cosmos SDK documentation here**](https://tutorials.cosmos.network/starport-polling-app/). 

# Introduction

![Application screenshot](https://tutorials.cosmos.network/assets/img/1.8c86df06.png)

We will be creating a simple poll application, in which a user can sign in, create polls, cast votes and see voting results. Creating a poll will cost 200 tokens, voting is free, and both actions will be available only for signed in users.

For this tutorial we will be using [Starport](https://github.com/tendermint/starport), an easy to use tool for building blockchains. [Install Starport](https://github.com/tendermint/starport#installation) and run the following command to create a voter project:

```text
starport app github.com/alice/voter
```

Starport `app` command will scaffold a project structure for your application in a `voter` directory. Make sure to replace `alice` with your GitHub username.

Inside the `voter` directory we can see several files and directories:

* `app` contains files that connect all of the moving parts of your application.
* `cmd` is responsible for `voterd` and `votercli` programs, which respectively allow you to start your application and interact with it.
* `frontend` contains a web user interface for your app, reponsible for everything you see on the screenshot above.
* `x` contains the main building blocks of you app: modules. Right now we have only one: `voter`.

Our project's directory contains all the code required to build and launch a blockchain-based app. Let's try launching our app by running starport serve inside our project:

```text
starport serve
```

```text
📦 Installing dependencies...
🚧 Building the application... 
💫 Initializing the chain...
🙂 Created an account. Password (mnemonic): truth tooth front fabric sing divert zone milk fatigue urban hundred certain sorry merge milk treat foam coral absent run stand invest monkey aspect
🙂 Created an account. Password (mnemonic): famous faculty genre finger build fantasy squirrel icon carbon absent sleep weather fold piece thank earth pioneer excite trim cupboard grow pumpkin bundle auction
🌍 Running a Cosmos 'voter' app with Tendermint.

🚀 Get started: http://localhost:12345/
```

Congratulations! You now have a blockchain application running on your machine in just two commands. It doesn't do anything yet, so let's work on that.

Our voting applications has two types of entities: polls and votes. A poll is a type that has a `title` and a list of `options`.

# Adding polls

```text
starport type poll title options
```

This command generated code that handles the creation of `poll` items. If we now run `starport serve` and visit [http://localhost:8080](http://localhost:8080/) we will see a form for creating polls. It may take a short while to rebuild the app, so give it a couple of seconds.

![Application screenshot](https://tutorials.cosmos.network/assets/img/2.7f899a03.png)

Sign in with one of the passwords printed in the console and try creating a poll. You should see a new object created and displayed above the form. You have successfully created an object and stored it on the blockchain!

This, however, does not look and work exactly like we need. We should be able to add option fields $and store them as an array$ and they should be displayed as interactive buttons.

Let's take a look at some of the files modified by the `starport type` command.

**`x/voter/types/TypePoll.go`**

This file contains definition of the `Poll` type. We can see that a poll has two fields $creator and ID$, which will be created automatically, and two fields $title and options$ defined by us. Since we want `Options` to be a list of strings, **replace `string` with `[]string`**

**`x/voter/types/MsgCreatePoll.go`**

This file defines a message that creates a poll.

To write anything to a blockchain or perform any other state transition a client $web app in our case$ makes an HTTP POST request with a title and options to [http://localhost:1317/voter/poll](http://localhost:1317/voter/poll) endpoint handler for which is defined in `x/voter/client/rest/txPoll.go`. The handler creates an unsigned transaction which contains an array of messages. The client then signs the transaction and sends it to [http://localhost:1317/txs](http://localhost:1317/txs). The application then processes the transaction by sending each message to a corresponding handler, in our case `x/voter/handlerMessageCreatePoll.go`. A handler then calls a `CreatePoll` function defined in `x/voter/keeper/poll.go` which writes the poll data into the store.

Going back to `MsgCreatePoll.go`, we need to make options to be stored as a list instead of a string. Replace `Options string` with `Options []string` in `MsgCreatePoll` struct and `options string` with `options []string` in the arguments of `NewMsgCreatePoll` function.

**`x/voter/client/rest/txPoll.go`**

Replace `Options string` with `Options []string` in `createPollRequest` struct.

**`x/voter/client/cli/txPoll.go`**

A user can also interact with our application through a command line interface.

```text
votercli tx voter create-poll "Text editors" "Emacs" "Vim" --from user1
```

This command will generate a transaction with "create poll" message, sign it using a private key of `user1` $one of two users created by default$ and broadcast it to the blockchain.

The only modification we need to make is to change a line that reads arguments from the console: `argsOptions := args[1:len(args)]`. This will assume that all arguments after the first one represent a list of options.

Now that we have made all the necessary changes to our app, let's take a look at the client-side application.

```text
starport serve
```

# Front-end application

Starport has generated a basic front-end for our application. For convenience [Vue.js](https://vuejs.org/) framework is used with [Vuex](https://vuex.vuejs.org/) for state management, but since all features of our application are exposed through an HTTP API, clients can be built using any language or framework.

We'll be mostly interested in `frontend/src/views` directory, which contains page templates of our app, `frontend/src/store/index.js` handles sending transactions and receiving data from our blockchain and `frontend/src/components` directory, which contains components, like buttons and forms.

Inside `frontend/src/store/index.js` we import [CosmJS](https://github.com/cosmwasm/cosmjs), a library for handling wallets, creating, signing and broadcasting transactions and define a Vuex store. We'll use `entitySubmit` function for sending data to our blockchain $like a JSON representing a newly created poll$, `entityFetch` for requesting a list of polls and `accountUpdate` to fetch information about our token balance.

**`frontend/src/view/Index.vue`**

Since we don't need the default form component replace `<type-list />` inside of `frontend/src/views/Index.vue` with a new component `<poll-form />` that will be created in a new file at `frontend/src/components/PollForm.vue`.

**`frontend/src/components/PollForm.vue`**

```jsx
<template>
    <div>
      <app-input placeholder="Title" v-model="title" />
      <div v-for="option in options">
         <app-input placeholder="Option" v-model="option.title" />
      </div>
      <app-button @click.native="add">Add option</app-button>
      <app-button @click.native="submit">Create poll</app-button>
    </div>
</template>

<script>
export default {
  data() {
    return {
      title: "",
      options: []
     };
  },
  methods: {
    add() {
      this.options = [...this.options, { title: "" }];
    },
    async submit() {
      const payload = {
        type: "poll",
        body: {
          title: this.title,
          options: this.options.map(o => o.title)
        }
      };
      await this.$store.dispatch("entitySubmit", payload);
			  await this.$store.dispatch("entityFetch", payload);
			  await this.$store.dispatch("accountUpdate");
    }
  }
};
</script>      
```

The `add()` function:

```javascript
<script>
  add() { 
    this.options = [...this.options, { title: "" }]; 
  }, 
  async submit() { const payload = { type: "poll", body: { title: this.title, options: this.options.map(o => o.title) } }; 
await this.$store.dispatch$"entitySubmit", payload$; 
await this.$store.dispatch$"entityFetch", payload$; 
await this.$store.dispatch$"accountUpdate"$; } } };
</script>
```

Poll form component has an input for title and a list of inputs for options. Clicking "Add option" button adds an empty input and clicking "Create poll" sends, creates and broadcasts a transaction with a "create poll" message.

Refresh the page, sign in with a password and create a new poll. It takes a couple of seconds to process a transaction. Now, if you visit [http://localhost:1317/voter/poll](http://localhost:1317/voter/poll) you should see a list of polls $this endpoint is defined in `x/voter/rest/queryPoll.go`$:

```json
{
  "height": "0",
  "result": [
    {
      "creator": "cosmos19qqa7j73735w4pcx9mkkaxr00af7p432n62tv6",
      "id": "826477ab-0005-4e68-8031-19758d331681",
      "title": "A poll title",
      "options": ["First option", "The second option"]
    }
  ]
},
{ 
  "height": "0", 
  "result": [ 
    { 
      "creator": "cosmos19qqa7j73735w4pcx9mkkaxr00af7p432n62tv6", 
      "id": "826477ab-0005-4e68-8031-19758d331681", 
      "title": "A poll title", 
      "options": ["First option", "The second option"]
    } 
  ] 
}
```

# Adding votes

A vote type contains poll ID and a value $string representation of the selected option$.

```text
starport type vote pollID value
```

**`frontend/src/views/Index.vue`**

Add `<poll-list />` into the `frontend/src/view/Index.vue` file after the poll form component. Then make a new component at `frontend/src/components/PollList.vue` and add the following:

**`frontend/src/components/PollList.vue`**

```jsx
<template>
  <div>
    <div v-for="poll in polls">
      <app-text type="h2">Poll {{ poll.title }}</app-text>
      <app-radio-item
        @click.native="submit(poll.id, option)"
        v-for="option in poll.options"
        :value="option"
      />
      <app-text type="subtitle">Results: {{ results(poll.id) }}</app-text>
    </div>
  </div>
</template>

<script>
export default {
  data() {
    return {
      selected: ""
    };
  },
  computed: {
    polls() {
      return this.$store.state.data.poll || [];
    },
    votes() {
      return this.$store.state.data.vote || [];
    }
  },
  methods: {
    results(id) {
      const results = this.votes.filter(v => v.pollID === id);
      return this.$lodash.countBy(results, "value");
    },
    async submit(pollID, value) {
      const type = { type: "vote" };
      const body = { pollID, value };
      await this.$store.dispatch("entitySubmit", { ...type, body });
      await this.$store.dispatch("entityFetch", type);
    }
  }
};
</script>
```

The `PollList` component lists for every poll, all the options for that poll, as buttons. Selecting an option triggers a `submit` method that broadcasts a transaction with a "create vote" message and fetches data back from our application.

By now should be able to see the same UI as in the first screenshot. Try creating polls and casting votes. You may notice that it's possible to cast multiple votes for one poll. This is not what we want, so let's fix this behaviour.

# Casting votes only once

To fix this issue we first have to understand how data is stored in our application.

We can think of our data storage as a lexicographically ordered key value store. You can loop through the entries, filter by key prefix, add, update and delete entries. It is easier to visualize the store as JSON:

```json
{
  "poll-1a266241-c58d-4cbc-bacf-aaf939c95de1": {
    "creator": "cosmos15c6g4v5yvq0hy3kjllyr9ytlx45r936y0m6dm6",
    "id": "1a266241-c58d-4cbc-bacf-aaf939c95de1",
    "title": "Soft drinks",
    "options": ["Coca-Cola", "Pepsi"]
  },
  "vote-cd63b110-2959-45b0-8ce3-afa2fb7a5652": {
    "creator": "cosmos15c6g4v5yvq0hy3kjllyr9ytlx45r936y0m6dm6",
    "id": "cd63b110-2959-45b0-8ce3-afa2fb7a5652",
    "pollID": "1a266241-c58d-4cbc-bacf-aaf939c95de1",
    "value": "Pepsi"
  }
}
```

Both `poll-` and `vote-` are prefixes. They are added to keys for ease of filtering. By convention, prefixes are defined in `x/voter/key.go`.

Whenever a user casts a vote, a new "create vote" message is handled by a handler and is passed to a keeper. Keeper takes a `vote-` prefix, adds a UUID $unique to every message$ and uses this string as a key.

**`x/voter/keeper/vote.go`**

```go
key := []byte(types.VotePrefix + vote.ID)
```

These strings are unique and we get duplicate votes. To fix that we need to make sure a keeper records every vote only once by choosing the right key. In our case, we can use poll ID and creator address to make sure that one user can cast only one vote per poll.

```go
key := []byte(types.VotePrefix + vote.PollID + "-" + string(vote.Creator))
```

Restart the application and try voting multiple times on a single poll, you'll see you can vote as many times as you want but only your most recent vote is counted.

# Introducing a fee for creating polls

Let's make it so that creating a poll costs 200 tokens.

This feature is very easy to add. We already require users to have accounts registered, and each user has tokens on balance. The only thing we need to do is to send coins from user's account to a module account before we create a poll.

 **`x/voter/handlerMsgCreatePoll.go`**

```go
moduleAcct := sdk.AccAddress(crypto.AddressHash([]byte(types.ModuleName)))
payment, _ := sdk.ParseCoins("200token")
if err := k.CoinKeeper.SendCoins(ctx, poll.Creator, moduleAcct, payment); err != nil {
	return nil, err
}
```

Add the code above before `k.CreatePoll(ctx, poll)`. This way, if a user does not have enough tokens, the application will raise an error and will not proceed to creating a poll. Make sure to add `"github.com/tendermint/tendermint/crypto"` to the import statement $if your text editor didn't do that for you$.

Now, restart the app and try creating several polls to see how this affects your token balance.

# Conclusion

Congratulations, you now have a working poll app running on Cosmos!


Learn how to build a polling app using the Cosmos SDK

Cosmos

Where to start

Tutorials

Create a blog module using Cosmos SDK

Build a scavenger game

Create a transaction search widget

Build a nameservice application

Build a polling app

Want to write about Cosmos and earn $ATOM?