Prepare your 🚀

# Prepare your 🚀
## we're going into cosmos

---

## why cosmos

<aside class="notes">
	What problem are we trying to solve?
	- Building dApps (as easily as possible)
	- Scale those apps (ref. Ethereum with skyrocketing fees and slow transactions)
</aside>

---

<aside class="notes">
	The popularity of Cosmos is due to its SDK. It allows developers to focus on
	the business logic, and reusable components called "modules".
	Cosmos SDK takes care of the "common problems" of blockchains:
	- distributed state machine + consensus among nodes
	- provides a "stdlib" of modules (e.g. staking, governance, slashing, ...)
</aside>

---

<aside class="notes">
	One of the main between Cosmos and other blockchains is that you build your
	own customized blockchain.
	The other piece of the puzzle that makes Cosmos that exciting is the "IBC"
	(Inter-Blockchain Communication).
</aside>

---

<aside class="notes">
	In this talk, I'll use Cosmos SDK supported by Ignite CLI.
	It's a tool focused on DX for Cosmos developers. Provides feature for
	scaffolding new chains, modules, messages, hot-reloading, a TypeScript
	client for your frontend.
</aside>

---

# let's get our hands dirty

<aside class="notes">
	Time to work. We'll create a blockchain that is a "blog". Users will be able
	to create transactions with "articles" (a title and a content).
</aside>

---

<pre><code data-trim data-line-numbers="1-2|4-16" class="txt stretch">
# Scaffold a new Cosmos SDK chain
$❯ ignite scaffold chain blog --address-prefix blog

# Start your node (with hot reloading!)
$❯ ignite chain serve
Cosmos SDK's version is: stargate - v0.46.3

🛠  Building proto...
🛠  Building the blockchain...
💿 Initializing the app...
🗂  Initialize accounts...
🙂 Added account alice with address blog1nq85jtlrjdtyvek8q9kdazxnz6fl55xt8m345h and mnemonic: man share habit age clap drama hammer pen genre flag employ bag fiscal air right stomach few risk fuel bleak certain phone victory topic
🙂 Added account bob with address blog1r2s8g8phvx9axv9fwzr65rg7m8lkkg92ce2xxc and mnemonic: entry real theory salt obvious item bid avocado cluster desk strike trigger need poverty toward soda cancel annual wife float jewel dash focus else
🌍 Tendermint node: http://0.0.0.0:26657
🌍 Blockchain API: http://0.0.0.0:1317
🌍 Token faucet: http://0.0.0.0:4500
</code></pre>

---

## 📦 Scaffold a Message

<pre><code data-trim data-language="sh" class="sh stretch">
$❯ ignite scaffold message createPost title body

modify proto/blog/blog/tx.proto
modify x/blog/client/cli/tx.go
create x/blog/client/cli/tx_create_post.go
create x/blog/keeper/msg_server_create_post.go
modify x/blog/module_simulation.go
create x/blog/simulation/create_post.go
modify x/blog/types/codec.go
create x/blog/types/message_create_post.go
create x/blog/types/message_create_post_test.go

🎉 Created a message `createPost`.
</code></pre>

<!--
Create a new "message" (a new type of tx) with fields:
- title
- body

Note:
- protobuf file tx.proto is modified
- keeper
- cli client
-->

---

## `proto/blog/blog/tx.proto`

<pre><code data-trim data-line-numbers class="proto stretch">
message MsgCreatePost {
  string creator = 1;
  string title = 2;
  string body = 3;
}

message MsgCreatePostResponse {
}

service Msg {
  rpc CreatePost(MsgCreatePost)
		returns (MsgCreatePostResponse);
}
</code></pre>

---

## `proto/blog/blog/tx.proto`

<pre><code data-trim data-line-numbers="8" class="proto stretch">
message MsgCreatePost {
  string creator = 1;
  string title = 2;
  string body = 3;
}

message MsgCreatePostResponse {
  uint64 id = 1; // <--------- Fill the response!
}

service Msg {
  rpc CreatePost(MsgCreatePost)
		returns (MsgCreatePostResponse);
}
</code></pre>

---

## `x/blog/keeper/msg_server_create_post.go`

<pre><code data-trim data-line-numbers="all|9" class="go stretch">
package keeper

func (k msgServer) CreatePost(
	goCtx context.Context,
	msg *types.MsgCreatePost,
) (*types.MsgCreatePostResponse, error) {
	ctx := sdk.UnwrapSDKContext(goCtx)

// TODO: Handling the message
	_ = ctx

return &types.MsgCreatePostResponse{}, nil
}
</code></pre>

---

# 🧑‍💻 our turn

---

---

<aside class="notes">
	Keepers: a module can only interact with the subset of state defined in
	another module via the methods exposed by the instance of the other module's
	keeper. This is a great way for developers to control the interactions that
	their own module can have with modules developed by external developers.

A keeper uses a "codec" to (de)serialize items in the store. We'll use protobuf.
</aside>

---

### Define Post type
##### we'll use it in the db

<pre><code data-trim class="proto stretch">
syntax = "proto3";

package blog.blog;

option go_package = "blog/x/blog/types";
// we'll be able to use `types.Post` in our Go code

message Post {
  string creator = 1;
  uint64 id = 2;
  string title = 3;
  string body = 4;
}
</code></pre>

---

### `x/blog/types/keys.go`
##### define new keys for our db

<pre><code data-trim data-line-numbers="17-18" class="go stretch">
package types

const (
	// ModuleName defines the module name
	ModuleName = "blog"

// StoreKey defines the primary module store key
	StoreKey = ModuleName

// RouterKey defines the module's message routing key
	RouterKey = ModuleName

// MemStoreKey defines the in-memory store key
	MemStoreKey = "mem_blog"

// Keep track of the index of posts
	PostKey      = "Post/value/"
	PostCountKey = "Post/count/"
)
</code></pre>

<aside class="notes">
	This keys are going to be used for tracking the actual posts, and the count
	of posts already existing (we'll be using the latter as an autoincremental
	id).
</aside>

---

### `x/blog/keeper/post.go`
##### Implement db r/w operations

<pre><code data-trim data-line-numbers="" class="go stretch">
package keeper

func (k Keeper) AppendPost(ctx sdk.Context, post types.Post) uint64 {
	// count = k.GetPostCount()
	// post = types.Post{ Id: count, ... }
	// k.Save(post)
	// k.SetPostCount(count + 1)
}

func (k Keeper) GetPostCount(ctx sdk.Context) uint64 {
	...
}

func (k Keeper) SetPostCount(ctx sdk.Context, count uint64) {
	...
}
</code></pre>

---

### Get post count

<pre><code data-trim data-line-numbers="" class="go stretch">
func (k Keeper) GetPostCount(ctx sdk.Context) uint64 {
	// Get the store using storeKey (which is "blog") and PostCountKey (which is "Post/count/")
	store := prefix.NewStore(ctx.KVStore(k.storeKey), []byte(types.PostCountKey))

// Get the value of the count
	bz := store.Get([]byte("count"))

// Return zero if the count value is not found (for example, it's the first post)
	if bz == nil {
		return 0
	}

// Convert the count into uint64
	return binary.BigEndian.Uint64(bz)
}
</code></pre>

---

### Set post count

<pre><code data-trim data-line-numbers="" class="go stretch">
func (k Keeper) SetPostCount(ctx sdk.Context, count uint64) {
	// Get the store using storeKey (which is "blog") and PostCountKey (which is "Post/count/")
	store := prefix.NewStore(ctx.KVStore(k.storeKey), []byte(types.PostCountKey))

// Convert count from uint64 to string and get bytes
	bz := make([]byte, 8)
	binary.BigEndian.PutUint64(bz, count)

// Set the value of Post/count/ to count
	store.Set([]byte("count"), bz)
}
</code></pre>

---

# 🙈 are we ignoring errors?

<aside class="notes">
	If something goes really bad with our store and panics(). The SDK will
	recover from the panic and mark the transaction as failed.
</aside>

---

### Append post

<pre><code data-trim data-line-numbers="" class="go stretch">
func (k Keeper) AppendPost(ctx sdk.Context, post types.Post) uint64 {
	// Get the current number of posts in the store
	count := k.GetPostCount(ctx)

// Assign an ID to the post based on the number of posts in the store
	post.Id = count

// Get the store
	store := prefix.NewStore(ctx.KVStore(k.storeKey), []byte(types.PostKey))

// Convert the post ID into bytes
	byteKey := make([]byte, 8)
	binary.BigEndian.PutUint64(byteKey, post.Id)

// Marshal the post into bytes
	appendedValue := k.cdc.MustMarshal(&post)

// Insert the post bytes using post ID as a key
	store.Set(byteKey, appendedValue)

// Update the post count
	k.SetPostCount(ctx, count+1)
	return count
}
</code></pre>

---

### Complete our RPC

<pre><code data-trim data-line-numbers="9" class="go stretch">
package keeper

func (k msgServer) CreatePost(
	goCtx context.Context,
	msg *types.MsgCreatePost,
) (*types.MsgCreatePostResponse, error) {
	ctx := sdk.UnwrapSDKContext(goCtx)

// TODO: Handling the message
	_ = ctx

return &types.MsgCreatePostResponse{}, nil
}
</code></pre>

---

### Complete our RPC

<pre><code data-trim data-line-numbers="7-22" class="go stretch">
package keeper

func (k msgServer) CreatePost(goCtx context.Context, msg *types.MsgCreatePost) (*types.MsgCreatePostResponse, error) {
    // Get the context
    ctx := sdk.UnwrapSDKContext(goCtx)

// Create variable of type Post
    var post = types.Post{
        Creator: msg.Creator,
        Title:   msg.Title,
        Body:    msg.Body,
    }

// Add a post to the store and get back the ID
    id := k.AppendPost(ctx, post)

// Return the ID of the post
    return &types.MsgCreatePostResponse{Id: id}, nil
}
</code></pre>

---

### Let's do some transactions

---

<pre><code data-trim data-line-numbers="1-4|6-16|21-22" class="sh stretch">
$❯ blogd tx blog create-post \
  'Ciao pisa.dev!!' \
  'Questo è il primo post sulla nostra blockchain!' \
  --from alice

auth_info:
  fee:
    gas_limit: "200000"
body:
  messages:
  - '@type': /blog.blog.MsgCreatePost
    creator: blog1nq85jtlrjdtyvek8q9kdazxnz6fl55xt8m345h
    body: Questo è il primo post sulla nostra blockchain!
    title: Ciao pisa.dev!!

confirm transaction before signing and broadcasting [y/N]:

...

gas_used: "53758"
gas_wanted: "200000"
</code></pre>

---

## 📦 Scaffold a Query

<pre><code data-trim class="sh stretch">
$❯ ignite scaffold query posts --response title,body

modify proto/blog/blog/query.proto
modify x/blog/client/cli/query.go
create x/blog/client/cli/query_posts.go
create x/blog/keeper/grpc_query_posts.go

🎉 Created a query `posts`.
</code></pre>

---

`modify proto/blog/blog/query.proto`

<pre><code data-trim class="proto stretch">
message QueryPostsRequest {
}

message QueryPostsResponse {
  string title = 1;
  string body = 2;
}

service Query {
  rpc Posts(QueryPostsRequest) returns (QueryPostsResponse)
}
</code></pre>

---

`modify proto/blog/blog/query.proto`

<pre><code data-trim class="proto stretch">
import "blog/blog/post.proto";

message QueryPostsRequest {
}

message QueryPostsResponse {
  repeated Post Posts = 1;
}

service Query {
  rpc Posts(QueryPostsRequest) returns (QueryPostsResponse)
}
</code></pre>

---

<pre><code data-trim class="go stretch">
func (k Keeper) Posts(
	goCtx context.Context,
	req *types.QueryPostsRequest,
) (*types.QueryPostsResponse, error) {
	if req == nil {
		return nil, status.Error(codes.InvalidArgument, "invalid request")
	}

ctx := sdk.UnwrapSDKContext(goCtx)

// TODO: Process the query
	_ = ctx

return &types.QueryPostsResponse{}, nil
}
</code></pre>

---

<pre><code data-trim class="go stretch">
func (k Keeper) Posts(
	goCtx context.Context,
	req *types.QueryPostsRequest,
) (*types.QueryPostsResponse, error) {
	...

// Define a variable that will store a list of posts
	var posts []*types.Post

// Get the post store
	store := ctx.KVStore(k.storeKey)
	postStore := prefix.NewStore(store, []byte(types.PostKey))

for iter := postStore.Iterator(nil, nil); iter.Valid(); iter.Next() {
		var post types.Post
		k.cdc.MustUnmarshal(iter.Value(), &post)
		posts = append(posts, &post)
	}

return &types.QueryPostsResponse{ Posts: posts }, nil
}
</code></pre>

---

<pre><code data-trim class="sh stretch">
$❯ blogd query blog posts

Posts:
- body: Questo è il primo post sulla nostra blockchain!
  creator: blog1nq85jtlrjdtyvek8q9kdazxnz6fl55xt8m345h
  id: "0"
  title: Ciao pisa.dev!!
- body: Questo è il secondo post sulla nostra blockchain!
  creator: blog1r2s8g8phvx9axv9fwzr65rg7m8lkkg92ce2xxc
  id: "1"
  title: Hey sono Bob
</code></pre>

---

# 🍾 Success

<br />

- Scaffolded a new Cosmos SDK message and query
- Implemented keeper methods to write data into the store
- Used the CLI to sign and broadcast a new transaction
</div>

---

# 🖥️ Frontend

<aside class="notes">
	Ignite automatically generates a typescript client from the protobuf. The
	same way it did with the CLI tool.

Ignite also generates a sample vue application that imports that client that
	you can use to build a frontend for your app.
</aside>

---

### Posts.vue

<pre><code data-trim class="vue stretch">
<template>
  <div class="container">
    <article v-for="post in posts.Posts">
      <h1>#{{ post.id }} {{ post.title }}</h1>
      <p>{{ post.body }}</p>
      <p style="opacity: 0.5">written by {{ post.creator }}</p>
    </article>
  </div>
</template>

export default {
  setup() {
    let $s = useStore()

$s.dispatch("blog.blog/QueryPosts", { subscribe: true })
    let posts = computed(() => $s.getters['blog.blog/getPosts']())
    return {
      posts: posts,
    }
  }
}
</script>
</code></pre>
</div>

---

# 🌐 IBC

(<a href="https://docs.ignite.com/guide/ibc" style="color: black; text-decoration: underline; text-underline-offset: 7px;">
https://docs.ignite.com/guide/ibc
</a>)

---

## Tendermint

---

## Sample Tendermint app

<pre><code data-trim data-line-numbers="" class="go stretch">
type MyApp struct {
  db        *badger.DB
  currentTx *badger.Txn
}

func (app *MyApp) Query(reqQuery abci.RequestQuery) (res abci.ResponseQuery) {
  value, _ := app.db.Get(reqQuery.Data)
  return &abci.ResponseQuery{Value: value}
}

func (app *MyApp) BeginBlock(...) abci.ResponseBeginBlock {
	app.currentTx = app.db.NewTransaction(true)
}

func (app *MyApp) DeliverTx(req abci.RequestDeliverTx) abci.ResponseDeliverTx {
	key, value := bytes.Split(req.Tx, []byte("="))
	err := app.currentTx.Set(key, value)
	...
}

func (app *MyApp) Commit() abci.ResponseCommit {
	app.currentTx.Commit()
}
</code></pre>

---

# Thanks!

<br />

### Antonio Pitasi

Blockchain Engineer @ Qredo

previously @ Tendermint

<a href="https://anto.pt" style="color: black; text-decoration: underline; text-underline-offset: 7px;">
	https://anto.pt
</a>